Golang os.Expand函数代码示例

func (m *Machine) cmdLine() []string {
	result := []string{"--driver", m.driver}
	keys := []string{}
	for k := range m.options {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		v := m.options[k]
		switch val := v.(type) {
		case string:
			result = append(result, "--"+k)
			val = os.Expand(val, func(key string) string { return m.expand(key) })
			result = append(result, val)
		case map[interface{}]interface{}:
			keys := []string{}
			for kk := range val {
				keys = append(keys, kk.(string))
			}
			sort.Strings(keys)
			for _, kk := range keys {
				vv := val[kk]
				result = append(result, "--"+k)
				evv := os.Expand(vv.(string), func(key string) string { return m.expand(key) })
				result = append(result, kk+"="+evv)
			}
		case bool:
			if val {
				result = append(result, "--"+k)
			}
		}
	}
	result = append(result, m.name)
	return result
}

func (s *ShellExecutor) Prepare(globalConfig *common.Config, config *common.RunnerConfig, build *common.Build) error {
	if globalConfig != nil {
		s.Shell.User = globalConfig.User
	}

	// expand environment variables to have current directory
	wd, err := os.Getwd()
	if err != nil {
		return fmt.Errorf("Getwd: %v", err)
	}

	mapping := func(key string) string {
		switch key {
		case "PWD":
			return wd
		default:
			return ""
		}
	}

	s.DefaultBuildsDir = os.Expand(s.DefaultBuildsDir, mapping)
	s.DefaultCacheDir = os.Expand(s.DefaultCacheDir, mapping)

	// Pass control to executor
	err = s.AbstractExecutor.Prepare(globalConfig, config, build)
	if err != nil {
		return err
	}

	s.Println("Using Shell executor...")
	return nil
}

func (lw *LogWatcher) AddContainer(cid string) {
	c, err := lw.docker.InspectContainer(cid)
	if err != nil {
		log.WithFields(log.Fields{
			"ID": cid,
		}).Warn(err)
		return
	}

	var envExpand = func(key string) string {
		for _, v := range c.Config.Env {
			if strings.HasPrefix(v, key+"=") {
				return strings.SplitN(v, "=", 2)[1]
			}
		}
		return ""
	}

	if os.Expand("$DLE_IGNORE", envExpand) != "" {
		log.WithFields(log.Fields{
			"ID": cid,
		}).Info("Ignoring container")
		return
	}

	token := os.Expand("$DLE_TOKEN", envExpand)
	if token == "" {
		token = defaultToken
	}

	lf := log.Fields{
		"ID":    cid,
		"token": token,
	}

	log.WithFields(lf).Info("Watching container")

	logwriter := &LogWriter{
		logline: lw.LogLines,
		token:   token,
	}

	logopts := docker.LogsOptions{
		Container:    cid,
		OutputStream: logwriter,
		ErrorStream:  logwriter,
		Stdout:       true,
		Stderr:       true,
		Follow:       true,
		Tail:         "0",
		RawTerminal:  true,
	}
	err = lw.docker.Logs(logopts)
	if err != nil {
		fmt.Println("error:", err)
	}

	log.WithFields(lf).Info("Stopped watching container")
}

func TestReplaceEnvironment(t *testing.T) {
	r := ReplaceEnvironment([]string{
		"TMP_DIR=/home/user/please/src/core",
		"PKG=src/core",
		"SRCS=core.go build_env.go",
	})
	assert.Equal(t,
		"/home/user/please/src/core src/core core.go build_env.go",
		os.Expand("$TMP_DIR ${PKG} ${SRCS}", r))
	assert.Equal(t, "", os.Expand("$WIBBLE", r))
}

func (g *goemon) externalCommand(command, file string) bool {
	var cmd *exec.Cmd
	command = os.Expand(command, func(s string) string {
		switch s {
		case "GOEMON_TARGET_FILE":
			return file
		case "GOEMON_TARGET_BASE":
			return filepath.Base(file)
		case "GOEMON_TARGET_DIR":
			return filepath.ToSlash(filepath.Dir(file))
		case "GOEMON_TARGET_EXT":
			return filepath.Ext(file)
		case "GOEMON_TARGET_NAME":
			fn := filepath.Base(file)
			ext := filepath.Ext(file)
			return fn[:len(fn)-len(ext)]
		}
		return os.Getenv(s)
	})
	if runtime.GOOS == "windows" {
		cmd = exec.Command("cmd", "/c", command)
	} else {
		cmd = exec.Command("sh", "-c", command)
	}
	g.Logger.Println("executing", command)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	err := cmd.Run()
	if err != nil {
		g.Logger.Println(err)
		return false
	}
	return true
}

func main() {
	fmt.Println(os.ExpandEnv("HOME = $HOME; GOROOT = $GOROOT"))

	fmt.Println(os.Expand("$GOROOT", func(s string) string {
		return s + " = " + os.Getenv(s)
	}))
}

// ParseEnv parses io.Reader into an arrays of strings
// representing the environment, in the form "key=value".
func ParseEnv(r io.Reader) ([]string, error) {
	sysenv := env2Map(os.Environ())
	localenv := make(map[string]string)
	mapping := func(key string) string {
		value, ok := localenv[key]
		if !ok {
			value, ok = sysenv[key]
		}
		return value
	}

	env := []string{}
	scanner := bufio.NewScanner(r)
	for scanner.Scan() {
		entry := strings.TrimSpace(scanner.Text())
		if len(entry) == 0 {
			continue
		}

		pair := strings.SplitN(entry, "=", 2)
		key := pair[0]
		value := os.Expand(pair[1], mapping)
		localenv[key] = value
		env = append(env, fmt.Sprintf("%s=%s", key, value))
	}

	if err := scanner.Err(); err != nil {
		return nil, fmt.Errorf("procker: parse env error: %s", err)
	}

	return env, nil
}

func testExpand(name string) {
	testStr := fmt.Sprintf("hello, ${%s}", name)
	newStr := os.Expand(testStr, func(s string) string {
		return "My " + s
	})
	fmt.Println(newStr)
}

// parseURLPrefixTag expects an input in the form of 'tag-host/path'
// and returns the lower cased host plus the path unaltered if the
// prefix matches the tag.
func parseURLPrefixTag(s, prefix string, env map[string]string) (host, path string, ok bool) {
	s = strings.TrimSpace(s)
	if !strings.HasPrefix(s, prefix) {
		return "", "", false
	}

	// split host/path
	p := strings.SplitN(s[len(prefix):], "/", 2)
	if len(p) != 2 {
		log.Printf("[WARN] consul: Invalid %s tag %q", prefix, s)
		return "", "", false
	}

	// expand $x or ${x} to env[x] or ""
	expand := func(s string) string {
		return os.Expand(s, func(x string) string {
			if env == nil {
				return ""
			}
			return env[x]
		})
	}

	host = strings.ToLower(expand(strings.TrimSpace(p[0])))
	path = "/" + expand(strings.TrimSpace(p[1]))

	return host, path, true
}

// makeEnvMap parse the given env string set and returns a new envMap
func makeEnvMap(set []string, inherit bool, ref ...*envMap) *envMap {
	env := make(envMap)
	for _, kv := range set {
		if strings.Contains(kv, PathListSeparator) {
			kv = strings.Replace(kv, PathListSeparator, string(os.PathListSeparator), -1)
		}

		kv = os.Expand(kv, func(key string) string {
			for _, r := range append(ref, &env) {
				if v, ok := (*r)[key]; ok {
					return v
				}
			}
			if v := os.Getenv(key); inherit && v != "" {
				return v
			} else {
				return "" //key
			}

		})

		if pair := strings.Split(kv, "="); len(pair) < 2 {
			env[pair[0]] = ""
		} else if len(pair) > 2 {
			pair = strings.FieldsFunc(kv, getQuoteSplitter('='))
			env[pair[0]] = pair[1]
		} else {
			env[pair[0]] = pair[1]

		}

	}
	return &env
}

// getCmd returns exec.Cmd
// binary names will be evaluated with Env here since this is the last step before Run()
func (a *app) getCmd() (*exec.Cmd, error) {
	path, err := exec.LookPath(a.bin)
	if err != nil {
		if path, err = exec.LookPath(os.Expand(a.bin, func(key string) string {
			if v, ok := (*Env)[key]; ok {
				return v
			} else {
				return ""
			}
		})); err != nil {
			return nil, fmt.Errorf("installing %v is in your future...", a.bin)
		}
	}
	cmd := exec.Command(path, a.arg...)
	if a.dir != "" {
		cmd.Dir = a.dir
	}

	cmd.Env = Env.combine(append(a.env, os.Environ()...)).list()
	cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr

	if len(Env.list()) > 0 {
		logger.Printf("Env: %s\n", Env)
	}
	logger.Printf("Command loaded: %s\n", a.cmd)

	return cmd, nil
}

// parseURLPrefixTag expects an input in the form of 'tag-host/path[ opts]'
// and returns the lower cased host and the unaltered path if the
// prefix matches the tag.
func parseURLPrefixTag(s, prefix string, env map[string]string) (route, opts string, ok bool) {
	// expand $x or ${x} to env[x] or ""
	expand := func(s string) string {
		return os.Expand(s, func(x string) string {
			if env == nil {
				return ""
			}
			return env[x]
		})
	}

	s = strings.TrimSpace(s)
	if !strings.HasPrefix(s, prefix) {
		return "", "", false
	}
	s = strings.TrimSpace(s[len(prefix):])

	p := strings.SplitN(s, " ", 2)
	if len(p) == 2 {
		opts = p[1]
	}
	s = p[0]

	p = strings.SplitN(s, "/", 2)
	if len(p) == 1 {
		log.Printf("[WARN] consul: Invalid %s tag %q - You need to have a trailing slash!", prefix, s)
		return "", "", false
	}
	host, path := p[0], p[1]

	return strings.ToLower(expand(host)) + "/" + expand(path), opts, true
}

func (e *EnvMap) get(
	key string, top *EnvMap, processQueue map[string]*EnvMap,
	cache map[string]string,
) (string, bool) {
	resolve := func(s string) string {
		if value, ok := cache[s]; ok == true {
			return value
		}
		if last, ok := processQueue[s]; ok == true {
			// If this is the last element in this environment map
			// then we return ""
			if last == nil {
				return ""
			}
			processQueue[s] = last.parent
			r, _ := last.get(s, top, processQueue, cache)
			return r
		}
		processQueue[s] = top
		r, _ := top.get(s, top, processQueue, cache)
		return r
	}

	for e != nil {
		if value, ok := e.env[key]; ok == true {
			processQueue[key] = e.parent
			s := os.Expand(value, resolve)
			delete(processQueue, key)
			return s, true
		}
		e = e.parent
	}
	return "", false
}

func (m *Machine) executePostProvision() ([]string, error) {

	fmt.Println("Executing post-provision commands...")

	out := []string{}
	for _, p := range m.postProvision() {

		fmt.Printf("  ... '%s'\n", p)
		args, err := shellwords.Parse(p)
		if err != nil {
			return []string{}, err
		}

		if args[0] == "scp" {
			// it's docker-machine sub-command
			args = append([]string{"docker-machine", "-s", dpmHome()}, args...)
		}

		for i := range args {
			args[i] = os.Expand(args[i], func(key string) string { return m.expand(key) })
		}

		cmd := exec.Command(args[0], args[1:]...)

		if args[0] == "docker" {
			cmd.Env = m.GetEnv()
		}

		o, err := cmd.CombinedOutput()
		out = append(out, string(o))
	}
	return out, nil
}

func ExpandFromMap(template string, m map[string]interface{}) string {
	return os.Expand(template, func(s string) string {
		if v, ok := m[s]; ok {
			return fmt.Sprintf("%v", v)
		}
		return "[?]"
	})
}