go_sysutils/envs/funcs.go

package envs

import (
	`bytes`
	`errors`
	`fmt`
	`io/ioutil`
	`os`
	`strings`

	`r00t2.io/sysutils/internal`
	`r00t2.io/sysutils/paths`
)

// GetPathEnv returns a slice of the PATH variable's items.
func GetPathEnv() (pathList []string, err error) {

	var pathVar string = internal.GetPathEnvName()

	pathList = make([]string, 0)

	for _, p := range strings.Split(os.Getenv(pathVar), string(os.PathListSeparator)) {
		if err = paths.RealPath(&p); err != nil {
			return
		}
		pathList = append(pathList, p)
	}
	return
}

// GetEnvMap returns a map of all environment variables. All values are strings.
func GetEnvMap() (envVars map[string]string) {

	var envList []string = os.Environ()

	envVars = envListToMap(envList)

	return
}

/*
	GetEnvMapNative returns a map of all environment variables, but attempts to "nativize" them.
	All values are interfaces. It is up to the caller to typeswitch them to proper types.

	Note that the PATH/Path environment variable (for *Nix and Windows, respectively) will be
	a []string (as per GetPathEnv). No other env vars, even if they contain os.PathListSeparator,
	will be transformed to a slice or the like.
	If an error occurs during parsing the path env var, it will be rendered	as a string.

	All number types will attempt to be their 64-bit version (i.e. int64, uint64, float64, etc.).

	If a type cannot be determined for a value, its string form will be used
	(as it would be found in GetEnvMap).
*/
func GetEnvMapNative() (envMap map[string]interface{}) {

	var stringMap map[string]string = GetEnvMap()

	envMap = nativizeEnvMap(stringMap)

	return
}

/*
	GetFirst gets the first instance if populated/set occurrence of varNames.

	For example, if you have three potential env vars, FOO, FOOBAR, FOOBARBAZ,
	and want to follow the logic flow of:

		1.) Check if FOO is set. If not,
		2.) Check if FOOBAR is set. If not,
		3.) Check if FOOBARBAZ is set.

	Then this would be specified as:

		GetFirst([]string{"FOO", "FOOBAR", "FOOBARBAZ"})

	If val is "" and ok is true, this means that one of the specified variable names IS
	set but is set to an empty value. If ok is false, none of the specified variables
	are set.

	It is a thin wrapper around GetFirstWithRef.
*/
func GetFirst(varNames []string) (val string, ok bool) {

	val, ok, _ = GetFirstWithRef(varNames)

	return
}

/*
	GetFirstWithRef behaves exactly like GetFirst, but with an additional returned value, idx,
	which specifies the index in varNames in which a set variable was found. e.g. if:

		GetFirstWithRef([]string{"FOO", "FOOBAR", "FOOBAZ"})

	is called and FOO is not set but FOOBAR is, idx will be 1.

	If ok is false, idx will always be -1 and should be ignored.
*/
func GetFirstWithRef(varNames []string) (val string, ok bool, idx int) {

	idx = -1

	for i, vn := range varNames {
		if HasEnv(vn) {
			ok = true
			idx = i
			val = os.Getenv(vn)
			return
		}
	}

	return
}

/*
	GetPidEnvMap will only work on *NIX-like systems with procfs.
	It gets the environment variables of a given process' PID.
*/
func GetPidEnvMap(pid uint32) (envMap map[string]string, err error) {

	var envBytes []byte
	var envList []string
	var envArr [][]byte
	var procPath string
	var exists bool

	envMap = make(map[string]string, 0)

	procPath = fmt.Sprintf("/proc/%v/environ", pid)

	if exists, err = paths.RealPathExists(&procPath); err != nil {
		return
	}
	if !exists {
		err = errors.New(fmt.Sprintf("information for pid %v does not exist", pid))
		return
	}

	if envBytes, err = ioutil.ReadFile(procPath); err != nil {
		return
	}

	envArr = bytes.Split(envBytes, []byte{0x0})
	envList = make([]string, len(envArr))
	for idx, b := range envArr {
		envList[idx] = string(b)
	}

	envMap = envListToMap(envList)

	return
}

/*
	GetPidEnvMapNative, like GetEnvMapNative, returns a map of all environment variables, but attempts to "nativize" them.
	All values are interfaces. It is up to the caller to typeswitch them to proper types.

	See the documentation for GetEnvMapNative for details.
*/
func GetPidEnvMapNative(pid uint32) (envMap map[string]interface{}, err error) {

	var stringMap map[string]string

	if stringMap, err = GetPidEnvMap(pid); err != nil {
		return
	}

	envMap = nativizeEnvMap(stringMap)

	return
}

/*
	HasEnv is much like os.LookupEnv, but only returns a boolean for
	if the environment variable key exists or not.

	This is useful anywhere you may need to set a boolean in a func call
	depending on the *presence* of an env var or not.
*/
func HasEnv(key string) (envIsSet bool) {

	_, envIsSet = os.LookupEnv(key)

	return
}