Secret/configmap factory cleanup.

k8sdeps/configmapandsecret/basefactory.go

@@ -22,10 +22,53 @@ import (
 	"strings"
 
 	"github.com/pkg/errors"
+	"k8s.io/apimachinery/pkg/util/validation"
 	"sigs.k8s.io/kustomize/k8sdeps/kv"
 	"sigs.k8s.io/kustomize/pkg/ifc"
+	"sigs.k8s.io/kustomize/pkg/types"
 )
 
+// baseFactory holds code shared by Factory and SecretFactory.
+type baseFactory struct {
+	ldr     ifc.Loader
+	options *types.GeneratorOptions
+}
+
+func (bf baseFactory) loadKvPairs(
+	args types.GeneratorArgs) (all []kv.Pair, err error) {
+	pairs, err := bf.keyValuesFromEnvFile(args.EnvSource)
+	if err != nil {
+		return nil, errors.Wrap(err, fmt.Sprintf(
+			"env source file: %s",
+			args.EnvSource))
+	}
+	all = append(all, pairs...)
+
+	pairs, err = keyValuesFromLiteralSources(args.LiteralSources)
+	if err != nil {
+		return nil, errors.Wrap(err, fmt.Sprintf(
+			"literal sources %v", args.LiteralSources))
+	}
+	all = append(all, pairs...)
+
+	pairs, err = bf.keyValuesFromFileSources(args.FileSources)
+	if err != nil {
+		return nil, errors.Wrap(err, fmt.Sprintf(
+			"file sources: %v", args.FileSources))
+	}
+	return append(all, pairs...), nil
+}
+
+const keyExistsErrorMsg = "cannot add key %s, another key by that name already exists: %v"
+
+func errIfInvalidKey(keyName string) error {
+	if errs := validation.IsConfigMapKey(keyName); len(errs) != 0 {
+		return fmt.Errorf("%q is not a valid key name: %s",
+			keyName, strings.Join(errs, ";"))
+	}
+	return nil
+}
+
 func keyValuesFromLiteralSources(sources []string) ([]kv.Pair, error) {
 	var kvs []kv.Pair
 	for _, s := range sources {
@@ -38,14 +81,14 @@ func keyValuesFromLiteralSources(sources []string) ([]kv.Pair, error) {
 	return kvs, nil
 }
 
-func keyValuesFromFileSources(ldr ifc.Loader, sources []string) ([]kv.Pair, error) {
+func (bf baseFactory) keyValuesFromFileSources(sources []string) ([]kv.Pair, error) {
 	var kvs []kv.Pair
 	for _, s := range sources {
 		k, fPath, err := parseFileSource(s)
 		if err != nil {
 			return nil, err
 		}
-		content, err := ldr.Load(fPath)
+		content, err := bf.ldr.Load(fPath)
 		if err != nil {
 			return nil, err
 		}
@@ -54,11 +97,11 @@ func keyValuesFromFileSources(ldr ifc.Loader, sources []string) ([]kv.Pair, erro
 	return kvs, nil
 }
 
-func keyValuesFromEnvFile(l ifc.Loader, path string) ([]kv.Pair, error) {
+func (bf baseFactory) keyValuesFromEnvFile(path string) ([]kv.Pair, error) {
 	if path == "" {
 		return nil, nil
 	}
-	content, err := l.Load(path)
+	content, err := bf.ldr.Load(path)
 	if err != nil {
 		return nil, err
 	}

k8sdeps/configmapandsecret/basefactory_test.go

@@ -45,8 +45,9 @@ func TestKeyValuesFromFileSources(t *testing.T) {
 
 	fSys := fs.MakeFakeFS()
 	fSys.WriteFile("/files/app-init.ini", []byte("FOO=bar"))
+	bf := baseFactory{loader.NewFileLoaderAtRoot(fSys), nil}
 	for _, tc := range tests {
-		kvs, err := keyValuesFromFileSources(loader.NewFileLoaderAtRoot(fSys), tc.sources)
+		kvs, err := bf.keyValuesFromFileSources(tc.sources)
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}

k8sdeps/configmapandsecret/configmapfactory.go

@@ -19,29 +19,26 @@ package configmapandsecret
 
 import (
 	"fmt"
-	"strings"
 	"unicode/utf8"
 
-	"github.com/pkg/errors"
 	"k8s.io/api/core/v1"
 	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/util/validation"
-	"sigs.k8s.io/kustomize/k8sdeps/kv"
 	"sigs.k8s.io/kustomize/pkg/ifc"
 	"sigs.k8s.io/kustomize/pkg/types"
 )
 
-// ConfigMapFactory makes ConfigMaps.
-type ConfigMapFactory struct {
-	ldr ifc.Loader
+// Factory makes ConfigMaps and Secrets.
+type Factory struct {
+	baseFactory
 }
 
-// NewConfigMapFactory returns a new ConfigMapFactory.
-func NewConfigMapFactory(l ifc.Loader) *ConfigMapFactory {
-	return &ConfigMapFactory{ldr: l}
+// NewFactory returns a new Factory.
+func NewFactory(
+	l ifc.Loader, o *types.GeneratorOptions) *Factory {
+	return &Factory{baseFactory{ldr: l, options: o}}
 }
 
-func (f *ConfigMapFactory) makeFreshConfigMap(
+func makeFreshConfigMap(
 	args *types.ConfigMapArgs) *corev1.ConfigMap {
 	cm := &corev1.ConfigMap{}
 	cm.APIVersion = "v1"
@@ -53,43 +50,22 @@ func (f *ConfigMapFactory) makeFreshConfigMap(
 }
 
 // MakeConfigMap returns a new ConfigMap, or nil and an error.
-func (f *ConfigMapFactory) MakeConfigMap(
-	args *types.ConfigMapArgs, options *types.GeneratorOptions) (*corev1.ConfigMap, error) {
-	var all []kv.Pair
-	var err error
-	cm := f.makeFreshConfigMap(args)
-
-	pairs, err := keyValuesFromEnvFile(f.ldr, args.EnvSource)
+func (f *Factory) MakeConfigMap(
+	args *types.ConfigMapArgs) (*corev1.ConfigMap, error) {
+	all, err := f.loadKvPairs(args.GeneratorArgs)
 	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf(
-			"env source file: %s",
-			args.EnvSource))
+		return nil, err
 	}
-	all = append(all, pairs...)
-
-	pairs, err = keyValuesFromLiteralSources(args.LiteralSources)
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf(
-			"literal sources %v", args.LiteralSources))
-	}
-	all = append(all, pairs...)
-
-	pairs, err = keyValuesFromFileSources(f.ldr, args.FileSources)
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf(
-			"file sources: %v", args.FileSources))
-	}
-	all = append(all, pairs...)
-
+	cm := makeFreshConfigMap(args)
 	for _, p := range all {
 		err = addKvToConfigMap(cm, p.Key, p.Value)
 		if err != nil {
 			return nil, err
 		}
 	}
-	if options != nil {
-		cm.SetLabels(options.Labels)
-		cm.SetAnnotations(options.Annotations)
+	if f.options != nil {
+		cm.SetLabels(f.options.Labels)
+		cm.SetAnnotations(f.options.Annotations)
 	}
 	return cm, nil
 }
@@ -97,13 +73,9 @@ func (f *ConfigMapFactory) MakeConfigMap(
 // addKvToConfigMap adds the given key and data to the given config map.
 // Error if key invalid, or already exists.
 func addKvToConfigMap(configMap *v1.ConfigMap, keyName, data string) error {
-	// Note, the rules for ConfigMap keys are the exact same as the ones for SecretKeys.
-	if errs := validation.IsConfigMapKey(keyName); len(errs) != 0 {
-		return fmt.Errorf("%q is not a valid key name for a ConfigMap: %s", keyName, strings.Join(errs, ";"))
+	if err := errIfInvalidKey(keyName); err != nil {
+		return err
 	}
-
-	keyExistsErrorMsg := "cannot add key %s, another key by that name already exists: %v"
-
 	// If the configmap data contains byte sequences that are all in the UTF-8
 	// range, we will write it to .Data
 	if utf8.Valid([]byte(data)) {
@@ -113,7 +85,6 @@ func addKvToConfigMap(configMap *v1.ConfigMap, keyName, data string) error {
 		configMap.Data[keyName] = data
 		return nil
 	}
-
 	// otherwise, it's BinaryData
 	if configMap.BinaryData == nil {
 		configMap.BinaryData = map[string][]byte{}

k8sdeps/configmapandsecret/configmapfactory_test.go

@@ -141,9 +141,9 @@ func TestConstructConfigMap(t *testing.T) {
 	fSys.WriteFile("/configmap/app.env", []byte("DB_USERNAME=admin\nDB_PASSWORD=somepw\n"))
 	fSys.WriteFile("/configmap/app-init.ini", []byte("FOO=bar\nBAR=baz\n"))
 	fSys.WriteFile("/configmap/app.bin", []byte{0xff, 0xfd})
-	f := NewConfigMapFactory(loader.NewFileLoaderAtRoot(fSys))
 	for _, tc := range testCases {
-		cm, err := f.MakeConfigMap(&tc.input, tc.options)
+		f := NewFactory(loader.NewFileLoaderAtRoot(fSys), tc.options)
+		cm, err := f.MakeConfigMap(&tc.input)
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}

k8sdeps/configmapandsecret/secretfactory.go

@@ -18,27 +18,13 @@ package configmapandsecret
 
 import (
 	"fmt"
-	"strings"
 
-	"github.com/pkg/errors"
 	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/util/validation"
-	"sigs.k8s.io/kustomize/k8sdeps/kv"
-	"sigs.k8s.io/kustomize/pkg/ifc"
 	"sigs.k8s.io/kustomize/pkg/types"
 )
 
-// SecretFactory makes Secrets.
-type SecretFactory struct {
-	ldr ifc.Loader
-}
-
-// NewSecretFactory returns a new SecretFactory.
-func NewSecretFactory(ldr ifc.Loader) *SecretFactory {
-	return &SecretFactory{ldr: ldr}
-}
-
-func (f *SecretFactory) makeFreshSecret(args *types.SecretArgs) *corev1.Secret {
+func makeFreshSecret(
+	args *types.SecretArgs) *corev1.Secret {
 	s := &corev1.Secret{}
 	s.APIVersion = "v1"
 	s.Kind = "Secret"
@@ -53,53 +39,32 @@ func (f *SecretFactory) makeFreshSecret(args *types.SecretArgs) *corev1.Secret {
 }
 
 // MakeSecret returns a new secret.
-func (f *SecretFactory) MakeSecret(args *types.SecretArgs, options *types.GeneratorOptions) (*corev1.Secret, error) {
-	var all []kv.Pair
-	var err error
-	s := f.makeFreshSecret(args)
-
-	pairs, err := keyValuesFromEnvFile(f.ldr, args.EnvSource)
+func (f *Factory) MakeSecret(
+	args *types.SecretArgs) (*corev1.Secret, error) {
+	all, err := f.loadKvPairs(args.GeneratorArgs)
 	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf(
-			"env source file: %s",
-			args.EnvSource))
+		return nil, err
 	}
-	all = append(all, pairs...)
-
-	pairs, err = keyValuesFromLiteralSources(args.LiteralSources)
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf(
-			"literal sources %v", args.LiteralSources))
-	}
-	all = append(all, pairs...)
-
-	pairs, err = keyValuesFromFileSources(f.ldr, args.FileSources)
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf(
-			"file sources: %v", args.FileSources))
-	}
-	all = append(all, pairs...)
-
+	s := makeFreshSecret(args)
 	for _, p := range all {
 		err = addKvToSecret(s, p.Key, p.Value)
 		if err != nil {
 			return nil, err
 		}
 	}
-	if options != nil {
-		s.SetLabels(options.Labels)
-		s.SetAnnotations(options.Annotations)
+	if f.options != nil {
+		s.SetLabels(f.options.Labels)
+		s.SetAnnotations(f.options.Annotations)
 	}
 	return s, nil
 }
 
 func addKvToSecret(secret *corev1.Secret, keyName, data string) error {
-	// Note, the rules for SecretKeys  keys are the exact same as the ones for ConfigMap.
-	if errs := validation.IsConfigMapKey(keyName); len(errs) != 0 {
-		return fmt.Errorf("%q is not a valid key name for a Secret: %s", keyName, strings.Join(errs, ";"))
+	if err := errIfInvalidKey(keyName); err != nil {
+		return err
 	}
 	if _, entryExists := secret.Data[keyName]; entryExists {
-		return fmt.Errorf("cannot add key %s, another key by that name already exists", keyName)
+		return fmt.Errorf(keyExistsErrorMsg, keyName, secret.Data)
 	}
 	secret.Data[keyName] = []byte(data)
 	return nil

k8sdeps/configmapandsecret/secretfactory_test.go

@@ -138,9 +138,9 @@ func TestConstructSecret(t *testing.T) {
 	fSys := fs.MakeFakeFS()
 	fSys.WriteFile("/secret/app.env", []byte("DB_USERNAME=admin\nDB_PASSWORD=somepw\n"))
 	fSys.WriteFile("/secret/app-init.ini", []byte("FOO=bar\nBAR=baz\n"))
-	f := NewSecretFactory(loader.NewFileLoaderAtRoot(fSys))
 	for _, tc := range testCases {
-		cm, err := f.MakeSecret(&tc.input, tc.options)
+		f := NewFactory(loader.NewFileLoaderAtRoot(fSys), tc.options)
+		cm, err := f.MakeSecret(&tc.input)
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}