Added a file provider which reads variables in env files

Author: zomglings

checkenv.go

@@ -1,22 +1,120 @@
 package main
 
 import (
+	"flag"
 	"fmt"
+	"os"
+	"strings"
 )
 
+type showSpec struct {
+	loadFrom      map[string]interface{}
+	providersFull map[string]interface{}
+	providerVars  map[string]map[string]interface{}
+}
+
+func parseShowSpec(args []string) *showSpec {
+	spec := showSpec{loadFrom: map[string]interface{}{}, providersFull: map[string]interface{}{}, providerVars: map[string]map[string]interface{}{}}
+	for _, arg := range args {
+		components := strings.Split(arg, "://")
+		providerSpec := components[0]
+		spec.loadFrom[providerSpec] = nil
+		if len(components) == 1 {
+			spec.providersFull[providerSpec] = nil
+		} else {
+			if _, ok := spec.providerVars[providerSpec]; !ok {
+				spec.providerVars[providerSpec] = map[string]interface{}{}
+			}
+			varSpec := strings.Join(components[1:], "://")
+			varNames := strings.Split(varSpec, ",")
+			for _, varName := range varNames {
+				spec.providerVars[providerSpec][varName] = nil
+			}
+		}
+	}
+
+	return &spec
+}
+
+func VariablesFromProviderSpec(providerSpec string) (map[string]string, error) {
+	components := strings.Split(providerSpec, "+")
+	provider := components[0]
+	var providerArgs string
+	if len(components) > 1 {
+		providerArgs = strings.Join(components[1:], "+")
+	}
+	plugin, pluginExists := RegisteredPlugins[provider]
+	if !pluginExists {
+		return map[string]string{}, fmt.Errorf("unregistered provider: %s", provider)
+	}
+	return plugin.Provider(providerArgs)
+}
+
 func main() {
-	for name, plugin := range RegisteredPlugins {
-		pluginInitErr := plugin.Init()
-		pluginEnv, pluginErr := plugin.Provider("")
-		fmt.Printf("Plugin: %s\n", name)
-		fmt.Printf("Help: %s\n", plugin.Help)
-		if pluginInitErr != nil {
-			fmt.Printf("Init error: %s\n", pluginInitErr.Error())
+	pluginsCommand := "plugins"
+	pluginsFlags := flag.NewFlagSet("plugins", flag.ExitOnError)
+	pluginsHelp := pluginsFlags.Bool("h", false, "Use this flag if you want help with this command")
+	pluginsFlags.BoolVar(pluginsHelp, "help", false, "Use this flag if you want help with this command")
+
+	showCommand := "show"
+	showFlags := flag.NewFlagSet("show", flag.ExitOnError)
+	showHelp := showFlags.Bool("h", false, "Use this flag if you want help with this command")
+	showFlags.BoolVar(showHelp, "help", false, "Use this flag if you want help with this command")
+
+	availableCommands := fmt.Sprintf("%s,%s", pluginsCommand, showCommand)
+
+	if len(os.Args) < 2 {
+		fmt.Fprintf(os.Stderr, "Please use one of the subcommands: %s\n", availableCommands)
+		os.Exit(2)
+	}
+
+	command := os.Args[1]
+
+	switch command {
+	case pluginsCommand:
+		pluginsFlags.Parse(os.Args[2:])
+		if *pluginsHelp {
+			fmt.Fprintf(os.Stderr, "Usage: %s %s\nTakes no arguments.\nLists available plugins with a brief description of each one.\n", os.Args[0], os.Args[1])
+			os.Exit(2)
 		}
-		if pluginErr != nil {
-			fmt.Printf("Plugin error: %s\n", pluginErr.Error())
-		} else {
-			fmt.Printf("Env:\n%v\n", pluginEnv)
+		fmt.Println("Available plugins:")
+		for name, plugin := range RegisteredPlugins {
+			fmt.Printf("%s\n\t%s\n", name, plugin.Help)
+		}
+	case showCommand:
+		showFlags.Parse(os.Args[2:])
+		if *showHelp || showFlags.NArg() == 0 {
+			fmt.Fprintf(os.Stderr, "Usage: %s %s [<provider_name>[+<provider_args>] ...] [<provider_name>[+<provider_args>]://<var_name_1>,<var_name_2>,...,<var_name_n> ...]\nShows the environment variables defined by the given providers.\n", os.Args[0], os.Args[1])
+			os.Exit(2)
+		}
+		spec := parseShowSpec(showFlags.Args())
+		providedVars := make(map[string]map[string]string)
+		for providerSpec, _ := range spec.loadFrom {
+			vars, providerErr := VariablesFromProviderSpec(providerSpec)
+			if providerErr != nil {
+				panic(providerErr)
+			}
+			providedVars[providerSpec] = vars
+		}
+		for providerSpec, _ := range spec.providersFull {
+			fmt.Printf("%s - all variables:\n", providerSpec)
+			for k, v := range providedVars[providerSpec] {
+				fmt.Printf("- %s=%s\n", k, v)
+			}
+		}
+		for providerSpec, queriedVars := range spec.providerVars {
+			fmt.Printf("%s - specific variables:\n", providerSpec)
+			definedVars := providedVars[providerSpec]
+			for k, _ := range queriedVars {
+				v, ok := definedVars[k]
+				if !ok {
+					fmt.Printf("- UNDEFINED: %s\n", k)
+				} else {
+					fmt.Printf("- %s=%s\n", k, v)
+				}
+			}
 		}
+	default:
+		fmt.Fprintf(os.Stderr, "Unknown command: %s. Please use one of the subcommands: %s.\n", command, availableCommands)
 	}
 }

env.go

@@ -22,5 +22,6 @@ func CurrentEnvProvider(filter string) (map[string]string, error) {
 }
 
 func init() {
-	RegisterPlugin("env", "", func() error { return nil }, CurrentEnvProvider)
+	helpString := "Provides the environment variables defined in the checkenv process."
+	RegisterPlugin("env", helpString, noop, CurrentEnvProvider)
 }

envfile.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"bufio"
+	"os"
+	"strings"
+)
+
+func EnvFileProvider(filter string) (map[string]string, error) {
+	// TODO(zomglings): For now, we expect the filter to contain the name of the env file. However,
+	// we will later want to add other things, like prefixes that we should strip off of lines (e.g. "export" or "set")
+	// and prefixes that we should ignore (e.g. "#" or "//")
+	vars := map[string]string{}
+	filename := filter
+	ifp, fileErr := os.Open(filename)
+	if fileErr != nil {
+		return vars, fileErr
+	}
+	defer ifp.Close()
+
+	scanner := bufio.NewScanner(ifp)
+	for scanner.Scan() {
+		line := scanner.Text()
+		components := strings.Split(line, "=")
+		name := components[0]
+		var value string
+		if len(components) > 1 {
+			value = strings.Join(components[1:], "=")
+		}
+		vars[name] = value
+	}
+
+	scanErr := scanner.Err()
+	return vars, scanErr
+}
+
+func init() {
+	helpString := "Provides the environment variables defined in the env file with the given path."
+	RegisterPlugin("file", helpString, noop, EnvFileProvider)
+}

plugins.go

@@ -17,6 +17,11 @@ type CheckenvProvider func(string) (map[string]string, error)
 // via SSH or on cloud configuration stores.
 type InitFromEnvFunction func() error
 
+// noop is an InitFromEnvFunction with no effect. It returns nil.
+func noop() error {
+	return nil
+}
+
 // CheckenvPlugin represents all the metadata that checkenv requires about a registered plugin:
 // 1. A Help string to display to users explaining the plugins filter syntax, how it is initialized, and possibly more.
 // 2. An Init function which initializes the plugin when checkenv starts up.