fix: add more docs

Author: dnitsch

Makefile

@@ -1,8 +1,8 @@
 
 OWNER := dnitsch
 NAME := configmanager
-GIT_TAG := "1.2.0"
-VERSION := "v1.2.0"
+GIT_TAG := "1.3.0"
+VERSION := "v1.3.0"
 # VERSION := "$(shell git describe --tags --abbrev=0)"
 REVISION := $(shell git rev-parse --short HEAD)
 

README.md

@@ -82,66 +82,67 @@ The token is made up of 3 parts:
 
 If contents of the `AWSSECRETS#/appxyz/service1-password` are a string then `service1-password` will be the key and converted to UPPERCASE e.g. `SERVICE1_PASSWORD=som3V4lue`
 
+### Special AZKVSECRETS
 
+For Azure KeyVault the first part of the token needs to be the name of the vault. 
+
+> Azure Go SDK (v2) requires the vault Uri on initializing the client
+
+`AZKVSECRET#/test-vault//token/1` ==> will use KeyVault implementation to retrieve the `/token/1` from a `test-vault`.
+
+`AZKVSECRET#/test-vault/no-slash-token-1` ==> will use KeyVault implementation to retrieve the `no-slash-token-1` from a `test-vault`.
 
 ## Go API
 
+latest api [here](https://pkg.go.dev/github.com/dnitsch/configmanager)
+
 ### Sample Use case
 
 One of the sample use cases includes implementation in a K8s controller.
 
 E.g. your Custom CRD stores some values in plain text that should really be secrets/nonpublic config parameters - something like this can be invoked from inside the controller code using the generator pkg API.
 
-```go
-func replaceTokens(in string, t *v1alpha.CustomFooCrdSpec) error {
-
-	tokens := []string{}
+See [examples](./examples/examples.go) for more examples and tests for sample input/usage
 
-	for k := range generator.VarPrefix {
-		matches := regexp.MustCompile(`(?s)`+regexp.QuoteMeta(k)+`.([^\"]+)`).FindAllString(in, -1)
-		tokens = append(tokens, matches...)
-	}
-
-	cnf := generator.GenVarsConfig{}
-	m, err := configmanager.Retrieve(tokens, cnf)
+```go
+import (
+	"context"
+	"fmt"
+
+	"github.com/dnitsch/configmanager/pkg/generator"
+	"github.com/dnitsch/configmanager"
+)
+
+func main() {
+	cm := &configmanager.ConfigManager{}
+	cnf := generator.NewConfig()
+	// JSON Marshal K8s CRD into
+	exampleK8sCrdMarshalled := `apiVersion: crd.foo.custom/v1alpha1
+kind: CustomFooCrd
+metadata:
+	name: foo
+	namespace: bar
+spec:
+	name: baz
+	secret_val: AWSSECRETS#/customfoo/secret-val
+	owner: [email protected]
+`
+	pm, err := cm.RetrieveWithInputReplaced(exampleK8sCrdMarshalled, *cnf)
 
 	if err != nil {
-		return err
-	}
-
-	if err := json.Unmarshal(replaceString(m, in), &t); err != nil {
-		return err
-	}
-	return nil
-}
-
-func replaceString(inputMap generator.ParsedMap, inputString string) []byte {
-	for oldVal, newVal := range inputMap {
-		inputString = strings.ReplaceAll(inputString, oldVal, fmt.Sprint(newVal))
+		panic(err)
 	}
-	return []byte(inputString)
+	fmt.Println(pm)
 }
 ```
 
-```yaml
-apiVersion: crd.foo.custom/v1alpha1
-kind: CustomFooCrd
-metadata:
-  name: foo
-  namespace: bar
-spec:
-  name: baz
-  secret_val: AWSSECRETS#/customfoo/secret-val
-  owner: [email protected]
-```
-
 Above example would ensure that you can safely store config/secret values on a CRD in plain text.
 
 > Beware logging out the CRD after tokens have been replaced.
 
 ## Help
 
-- More implementations should be easily added with a specific implementation under the strategy interface 
+- More implementations should be easily added with a specific implementation under the strategy interface
     - e.g. AzureKMS or GCP equivalent
 
 - maybe run as cron in the background to perform a periodic sync in case values change?

cmd/configmanager/fromfileinput.go

@@ -0,0 +1,40 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/dnitsch/configmanager/cmd/utils"
+	"github.com/dnitsch/configmanager/pkg/generator"
+	"github.com/spf13/cobra"
+)
+
+var (
+	input                string
+	retrieveFromStrInput = &cobra.Command{
+		Use:     "string-input",
+		Aliases: []string{"fromstr", "getfromstr"},
+		Short:   `Retrieves all found token values in a specified string input`,
+		Long:    `Retrieves all found token values in a specified string input and optionally writes to a file or to stdout in a bash compliant`,
+		RunE:    retrieveFromStr,
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			// if len(input) < 1 && !getStdIn() {
+			if len(input) < 1 {
+				return fmt.Errorf("must include input")
+			}
+			return nil
+		},
+	}
+)
+
+func init() {
+	retrieveFromStrInput.PersistentFlags().StringVarP(&input, "input", "i", "", "Contents of a string inside a variable to be searched for tokens. e.g. -i $(cat /som/file)")
+	retrieveFromStrInput.MarkPersistentFlagRequired("input")
+	retrieveFromStrInput.PersistentFlags().StringVarP(&path, "path", "p", "./app.env", "Path where to write out the replaced a config/secret variables. Special value of stdout can be used to return the output to stdout e.g. -p stdout, unix style output only")
+	configmanagerCmd.AddCommand(retrieveFromStrInput)
+}
+
+func retrieveFromStr(cmd *cobra.Command, args []string) error {
+	conf := generator.NewConfig().WithTokenSeparator(tokenSeparator).WithOutputPath(path)
+	gv := generator.NewGenerator().WithConfig(conf)
+	return utils.GenerateStrOut(gv, input)
+}

cmd/configmanager/retrieve.go

@@ -3,6 +3,7 @@ package cmd
 import (
 	"fmt"
 
+	"github.com/dnitsch/configmanager/cmd/utils"
 	"github.com/dnitsch/configmanager/pkg/generator"
 	"github.com/spf13/cobra"
 )
@@ -11,10 +12,9 @@ import (
 var tokenArray []string
 
 var (
-	tokens         []string
-	path           string
-	tokenSeparator string
-	retrieveCmd    = &cobra.Command{
+	tokens      []string
+	path        string
+	retrieveCmd = &cobra.Command{
 		Use:     "retrieve",
 		Aliases: []string{"r", "fetch", "get"},
 		Short:   `Retrieves a value for token(s) specified`,
@@ -33,16 +33,11 @@ func init() {
 	retrieveCmd.PersistentFlags().StringArrayVarP(&tokens, "token", "t", tokenArray, "Token pointing to a config/secret variable. This can be specified multiple times.")
 	retrieveCmd.MarkPersistentFlagRequired("token")
 	retrieveCmd.PersistentFlags().StringVarP(&path, "path", "p", "./app.env", "Path where to write out the replaced a config/secret variables. Special value of stdout can be used to return the output to stdout e.g. -p stdout, unix style output only")
-	retrieveCmd.PersistentFlags().StringVarP(&tokenSeparator, "token-separator", "s", "#", "Separator to use to mark concrete store and the key within it")
 	configmanagerCmd.AddCommand(retrieveCmd)
 }
 
 func retrieveRun(cmd *cobra.Command, args []string) error {
 	conf := generator.NewConfig().WithTokenSeparator(tokenSeparator).WithOutputPath(path)
 	gv := generator.NewGenerator().WithConfig(conf)
-	err := gv.GenerateFromCmd(tokens)
-	if err != nil {
-		return err
-	}
-	return nil
+	return utils.GenerateFromCmd(gv, tokens)
 }

cmd/configmanager/root.go

@@ -10,6 +10,8 @@ import (
 
 var (
 	verbose          bool
+	tokenSeparator   string
+	keySeparator     string
 	configmanagerCmd = &cobra.Command{
 		Use:   config.SELF_NAME,
 		Short: fmt.Sprintf("%s CLI for retrieving and inserting config or secret variables", config.SELF_NAME),
@@ -28,4 +30,6 @@ func Execute() {
 
 func init() {
 	configmanagerCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "Verbosity level")
+	configmanagerCmd.PersistentFlags().StringVarP(&tokenSeparator, "token-separator", "s", "#", "Separator to use to mark concrete store and the key within it")
+	configmanagerCmd.PersistentFlags().StringVarP(&keySeparator, "key-separator", "k", "|", "Separator to use to mark a key look up in a map. e.g. AWSSECRETS#/token/map|key1")
 }

cmd/utils/utils.go

@@ -0,0 +1,38 @@
+// command line utils
+package utils
+
+import (
+	"fmt"
+
+	"github.com/dnitsch/configmanager"
+	"github.com/dnitsch/configmanager/pkg/generator"
+	"github.com/dnitsch/configmanager/pkg/log"
+)
+
+// GenerateFromTokens is a helper cmd method to call from retrieveCmd
+func GenerateFromCmd(gv *generator.GenVars, tokens []string) error {
+	_, err := gv.Generate(tokens)
+	if err != nil {
+		log.Errorf("%e", err)
+		return err
+	}
+	// Conver to ExportVars
+	gv.ConvertToExportVar()
+	return gv.FlushToFile()
+}
+
+func GenerateStrOut(gv *generator.GenVars, input string) error {
+	c := configmanager.ConfigManager{}
+
+	str, err := c.RetrieveWithInputReplaced(input, *gv.Config())
+	if err != nil {
+		return err
+	}
+
+	return gv.StrToFile(str)
+}
+
+//UploadTokensWithVals takes in a map of key/value pairs and uploads them
+func UploadTokensWithVals(tokens map[string]string) error {
+	return fmt.Errorf("notYetImplemented")
+}

configmanager_test.go

@@ -20,11 +20,16 @@ func (m *mockGenVars) Generate(tokens []string) (generator.ParsedMap, error) {
 	return pm, nil
 }
 
-func (m *mockGenVars) ConvertToExportVar() {
+func (m *mockGenVars) ConvertToExportVar() []string {
+	return []string{}
 }
 
-func (m *mockGenVars) FlushToFile() (string, error) {
-	return "", nil
+func (m *mockGenVars) FlushToFile() error {
+	return nil
+}
+
+func (m *mockGenVars) StrToFile(str string) error {
+	return nil
 }
 
 func Test_retrieve(t *testing.T) {
@@ -60,3 +65,63 @@ func Test_retrieve(t *testing.T) {
 		})
 	}
 }
+
+var strT1 = `
+space: preserved
+	indents: preserved
+	arr: [ "FOO#/test" ]
+	// comments preserved
+	arr:
+		- "FOO#/test"
+`
+
+var strT2 = `
+// TOML
+[[somestuff]]
+key = "FOO#/test" 
+`
+
+func Test_retrieveWithInputReplaced(t *testing.T) {
+	tests := []struct {
+		name   string
+		input  string
+		genvar generator.Generatoriface
+		expect string
+	}{
+		{
+			name:   "strYaml",
+			input:  strT1,
+			genvar: &mockGenVars{},
+			expect: `
+space: preserved
+	indents: preserved
+	arr: [ "val1" ]
+	// comments preserved
+	arr:
+		- "val1"
+`,
+		},
+		{
+			name:   "strToml",
+			input:  strT2,
+			genvar: &mockGenVars{},
+			expect: `
+// TOML
+[[somestuff]]
+key = "val1" 
+`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := retrieveWithInputReplaced(tt.input, tt.genvar)
+			if err != nil {
+				t.Errorf("failed with %v", err)
+			}
+			if got != tt.expect {
+				t.Errorf(testutils.TestPhrase, tt.expect, got)
+			}
+		})
+	}
+}

examples/examples.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/dnitsch/configmanager"
+	"github.com/dnitsch/configmanager/pkg/generator"
+)
+
+const DO_STUFF_WITH_VALS_HERE = "connstring:user@%v:host=%s/someschema..."
+
+func main() {
+	retrieveExample()
+	retrieveStringOut()
+}
+
+// retrieveExample uses the standard Retrieve method on the API
+// this will return generator.ParsedMap which can be later used for more complex use cases
+func retrieveExample() {
+	cm := &configmanager.ConfigManager{}
+	cnf := generator.NewConfig()
+
+	pm, err := cm.Retrieve([]string{"token1", "token2"}, *cnf)
+
+	if err != nil {
+		panic(err)
+	}
+
+	// put in a loop for many config params
+	if pwd, ok := pm["token1"]; ok {
+		if host, ok := pm["token2"]; ok {
+			fmt.Println(fmt.Sprintf(DO_STUFF_WITH_VALS_HERE, pwd, fmt.Sprintf("%s", host)))
+		}
+	}
+}
+
+// retrieveStringOut accepts a string as an input
+func retrieveStringOut() {
+	cm := &configmanager.ConfigManager{}
+	cnf := generator.NewConfig()
+	// JSON Marshal K8s CRD into
+	exampleK8sCrdMarshalled := `apiVersion: crd.foo.custom/v1alpha1
+kind: CustomFooCrd
+metadata:
+	name: foo
+	namespace: bar
+spec:
+	name: baz
+	secret_val: AWSSECRETS#/customfoo/secret-val
+	owner: [email protected]
+`
+	pm, err := cm.RetrieveWithInputReplaced(exampleK8sCrdMarshalled, *cnf)
+
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(pm)
+}