Merge pull request #1640 from monopole/moveKvStuff

Extract kv loader from file loader, and place in public package.

pkg/ifc/ifc.go

@@ -20,6 +20,12 @@ type Validator interface {
 	IsEnvVarName(k string) error
 }
 
+// KvLoader reads and validates KV pairs.
+type KvLoader interface {
+	Validator() Validator
+	Load(args types.KvPairSources) (all []types.Pair, err error)
+}
+
 // Loader interface exposes methods to read bytes.
 type Loader interface {
 	// Root returns the root location for this Loader.
@@ -30,10 +36,6 @@ type Loader interface {
 	Load(location string) ([]byte, error)
 	// Cleanup cleans the loader
 	Cleanup() error
-	// Validator validates data for use in various k8s fields.
-	Validator() Validator
-	// Loads pairs.
-	LoadKvPairs(args types.GeneratorArgs) ([]types.Pair, error)
 }
 
 // Kunstructured allows manipulation of k8s objects
@@ -74,11 +76,11 @@ type KunstructuredFactory interface {
 	FromMap(m map[string]interface{}) Kunstructured
 	Hasher() KunstructuredHasher
 	MakeConfigMap(
-		ldr Loader,
+		kvLdr KvLoader,
 		options *types.GeneratorOptions,
 		args *types.ConfigMapArgs) (Kunstructured, error)
 	MakeSecret(
-		ldr Loader,
+		kvLdr KvLoader,
 		options *types.GeneratorOptions,
 		args *types.SecretArgs) (Kunstructured, error)
 }

pkg/kusttest/kusttestharness.go

@@ -20,6 +20,7 @@ import (
 	"sigs.k8s.io/kustomize/v3/pkg/target"
 	"sigs.k8s.io/kustomize/v3/pkg/transformers/config/defaultconfig"
 	"sigs.k8s.io/kustomize/v3/pkg/types"
+	"sigs.k8s.io/kustomize/v3/pkg/validators"
 )
 
 // KustTestHarness helps test kustomization generation and transformation.
@@ -59,7 +60,8 @@ func NewKustTestHarnessFull(
 
 func (th *KustTestHarness) MakeKustTarget() *target.KustTarget {
 	kt, err := target.NewKustTarget(
-		th.ldr, th.rf, transformer.NewFactoryImpl(), th.pl)
+		th.ldr, validators.MakeFakeValidator(), th.rf,
+		transformer.NewFactoryImpl(), th.pl)
 	if err != nil {
 		th.t.Fatalf("Unexpected construction error %v", err)
 	}
@@ -113,7 +115,8 @@ func (th *KustTestHarness) LoadAndRunGenerator(
 	if err != nil {
 		th.t.Fatalf("Err: %v", err)
 	}
-	g, err := th.pl.LoadGenerator(th.ldr, res)
+	g, err := th.pl.LoadGenerator(
+		th.ldr, validators.MakeFakeValidator(), res)
 	if err != nil {
 		th.t.Fatalf("Err: %v", err)
 	}
@@ -154,7 +157,8 @@ func (th *KustTestHarness) RunTransformerFromResMap(
 	if err != nil {
 		th.t.Fatalf("Err: %v", err)
 	}
-	g, err := th.pl.LoadTransformer(th.ldr, transConfig)
+	g, err := th.pl.LoadTransformer(
+		th.ldr, validators.MakeFakeValidator(), transConfig)
 	if err != nil {
 		return nil, err
 	}

pkg/loader/fileloader.go

@@ -79,9 +79,6 @@ type fileLoader struct {
 	// Restricts behavior of Load function.
 	loadRestrictor LoadRestrictorFunc
 
-	// Used to validate various k8s data fields.
-	validator ifc.Validator
-
 	// If this is non-nil, the files were
 	// obtained from the given repository.
 	repoSpec *git.RepoSpec
@@ -100,16 +97,16 @@ const CWD = "."
 
 // NewFileLoaderAtCwd returns a loader that loads from ".".
 // A convenience for kustomize edit commands.
-func NewFileLoaderAtCwd(v ifc.Validator, fSys filesys.FileSystem) *fileLoader {
+func NewFileLoaderAtCwd(fSys filesys.FileSystem) *fileLoader {
 	return newLoaderOrDie(
-		RestrictionRootOnly, v, fSys, CWD)
+		RestrictionRootOnly, fSys, CWD)
 }
 
 // NewFileLoaderAtRoot returns a loader that loads from "/".
 // A convenience for tests.
-func NewFileLoaderAtRoot(v ifc.Validator, fSys filesys.FileSystem) *fileLoader {
+func NewFileLoaderAtRoot(fSys filesys.FileSystem) *fileLoader {
 	return newLoaderOrDie(
-		RestrictionRootOnly, v, fSys, string(filepath.Separator))
+		RestrictionRootOnly, fSys, string(filepath.Separator))
 }
 
 // Root returns the absolute path that is prepended to any
@@ -119,25 +116,23 @@ func (fl *fileLoader) Root() string {
 }
 
 func newLoaderOrDie(
-	lr LoadRestrictorFunc, v ifc.Validator,
+	lr LoadRestrictorFunc,
 	fSys filesys.FileSystem, path string) *fileLoader {
 	root, err := demandDirectoryRoot(fSys, path)
 	if err != nil {
 		log.Fatalf("unable to make loader at '%s'; %v", path, err)
 	}
 	return newLoaderAtConfirmedDir(
-		lr, v, root, fSys, nil, git.ClonerUsingGitExec)
+		lr, root, fSys, nil, git.ClonerUsingGitExec)
 }
 
 // newLoaderAtConfirmedDir returns a new fileLoader with given root.
 func newLoaderAtConfirmedDir(
 	lr LoadRestrictorFunc,
-	v ifc.Validator,
 	root filesys.ConfirmedDir, fSys filesys.FileSystem,
 	referrer *fileLoader, cloner git.Cloner) *fileLoader {
 	return &fileLoader{
 		loadRestrictor: lr,
-		validator:      v,
 		root:           root,
 		referrer:       referrer,
 		fSys:           fSys,
@@ -179,7 +174,7 @@ func (fl *fileLoader) New(path string) (ifc.Loader, error) {
 			return nil, err
 		}
 		return newLoaderAtGitClone(
-			repoSpec, fl.validator, fl.fSys, fl, fl.cloner)
+			repoSpec, fl.fSys, fl, fl.cloner)
 	}
 	if filepath.IsAbs(path) {
 		return nil, fmt.Errorf("new root '%s' cannot be absolute", path)
@@ -195,14 +190,13 @@ func (fl *fileLoader) New(path string) (ifc.Loader, error) {
 		return nil, err
 	}
 	return newLoaderAtConfirmedDir(
-		fl.loadRestrictor, fl.validator, root, fl.fSys, fl, fl.cloner), nil
+		fl.loadRestrictor, root, fl.fSys, fl, fl.cloner), nil
 }
 
 // newLoaderAtGitClone returns a new Loader pinned to a temporary
 // directory holding a cloned git repo.
 func newLoaderAtGitClone(
-	repoSpec *git.RepoSpec,
-	v ifc.Validator, fSys filesys.FileSystem,
+	repoSpec *git.RepoSpec, fSys filesys.FileSystem,
 	referrer *fileLoader, cloner git.Cloner) (ifc.Loader, error) {
 	cleaner := repoSpec.Cleaner(fSys)
 	err := cloner(repoSpec)
@@ -228,7 +222,6 @@ func newLoaderAtGitClone(
 	return &fileLoader{
 		// Clones never allowed to escape root.
 		loadRestrictor: RestrictionRootOnly,
-		validator:      v,
 		root:           root,
 		referrer:       referrer,
 		repoSpec:       repoSpec,

pkg/loader/fileloader_test.go

@@ -29,7 +29,6 @@ import (
 	"sigs.k8s.io/kustomize/v3/pkg/git"
 	"sigs.k8s.io/kustomize/v3/pkg/ifc"
 	"sigs.k8s.io/kustomize/v3/pkg/pgmconfig"
-	"sigs.k8s.io/kustomize/v3/pkg/validators"
 )
 
 type testData struct {
@@ -65,7 +64,7 @@ func MakeFakeFs(td []testData) filesys.FileSystem {
 }
 
 func makeLoader() *fileLoader {
-	return NewFileLoaderAtRoot(validators.MakeFakeValidator(), MakeFakeFs(testCases))
+	return NewFileLoaderAtRoot(MakeFakeFs(testCases))
 
 }
 func TestLoaderLoad(t *testing.T) {
@@ -302,8 +301,7 @@ func TestRestrictionRootOnlyInRealLoader(t *testing.T) {
 
 	var l ifc.Loader
 
-	l = newLoaderOrDie(
-		RestrictionRootOnly, validators.MakeFakeValidator(), fSys, dir)
+	l = newLoaderOrDie(RestrictionRootOnly, fSys, dir)
 
 	l = doSanityChecksAndDropIntoBase(t, l)
 
@@ -336,8 +334,7 @@ func TestRestrictionNoneInRealLoader(t *testing.T) {
 
 	var l ifc.Loader
 
-	l = newLoaderOrDie(
-		RestrictionNone, validators.MakeFakeValidator(), fSys, dir)
+	l = newLoaderOrDie(RestrictionNone, fSys, dir)
 
 	l = doSanityChecksAndDropIntoBase(t, l)
 
@@ -400,7 +397,7 @@ whatever
 		t.Fatalf("unexpected err: %v\n", err)
 	}
 	l, err := newLoaderAtGitClone(
-		repoSpec, validators.MakeFakeValidator(), fSys, nil,
+		repoSpec, fSys, nil,
 		git.DoNothingCloner(filesys.ConfirmedDir(coRoot)))
 	if err != nil {
 		t.Fatalf("unexpected err: %v\n", err)
@@ -443,7 +440,7 @@ func TestLoaderDisallowsLocalBaseFromRemoteOverlay(t *testing.T) {
 	// Establish that a local overlay can navigate
 	// to the local bases.
 	l1 = newLoaderOrDie(
-		RestrictionRootOnly, validators.MakeFakeValidator(), fSys, cloneRoot+"/foo/overlay")
+		RestrictionRootOnly, fSys, cloneRoot+"/foo/overlay")
 	if l1.Root() != cloneRoot+"/foo/overlay" {
 		t.Fatalf("unexpected root %s", l1.Root())
 	}
@@ -479,7 +476,7 @@ func TestLoaderDisallowsLocalBaseFromRemoteOverlay(t *testing.T) {
 		t.Fatalf("unexpected err: %v\n", err)
 	}
 	l1, err = newLoaderAtGitClone(
-		repoSpec, validators.MakeFakeValidator(), fSys, nil,
+		repoSpec, fSys, nil,
 		git.DoNothingCloner(filesys.ConfirmedDir(cloneRoot)))
 	if err != nil {
 		t.Fatalf("unexpected err: %v\n", err)
@@ -518,7 +515,7 @@ func TestLocalLoaderReferencingGitBase(t *testing.T) {
 		t.Fatalf("unexpected err:  %v\n", err)
 	}
 	l1 := newLoaderAtConfirmedDir(
-		RestrictionRootOnly, validators.MakeFakeValidator(), root, fSys, nil,
+		RestrictionRootOnly, root, fSys, nil,
 		git.DoNothingCloner(filesys.ConfirmedDir(cloneRoot)))
 	if l1.Root() != topDir {
 		t.Fatalf("unexpected root %s", l1.Root())
@@ -544,7 +541,7 @@ func TestRepoDirectCycleDetection(t *testing.T) {
 		t.Fatalf("unexpected err: %v\n", err)
 	}
 	l1 := newLoaderAtConfirmedDir(
-		RestrictionRootOnly, validators.MakeFakeValidator(), root, fSys, nil,
+		RestrictionRootOnly, root, fSys, nil,
 		git.DoNothingCloner(filesys.ConfirmedDir(cloneRoot)))
 	p1 := "github.com/someOrg/someRepo/foo"
 	rs1, err := git.NewRepoSpecFromUrl(p1)
@@ -573,7 +570,7 @@ func TestRepoIndirectCycleDetection(t *testing.T) {
 		t.Fatalf("unexpected err: %v", err)
 	}
 	l0 := newLoaderAtConfirmedDir(
-		RestrictionRootOnly, validators.MakeFakeValidator(), root, fSys, nil,
+		RestrictionRootOnly, root, fSys, nil,
 		git.DoNothingCloner(filesys.ConfirmedDir(cloneRoot)))
 
 	p1 := "github.com/someOrg/someRepo1"

pkg/loader/kv.go

@@ -1,200 +0,0 @@
-// Copyright 2019 The Kubernetes Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package loader
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"os"
-	"path"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-
-	"github.com/pkg/errors"
-	"sigs.k8s.io/kustomize/v3/pkg/ifc"
-	"sigs.k8s.io/kustomize/v3/pkg/types"
-)
-
-var utf8bom = []byte{0xEF, 0xBB, 0xBF}
-
-func (fl *fileLoader) Validator() ifc.Validator {
-	return fl.validator
-}
-
-func (fl *fileLoader) LoadKvPairs(
-	args types.GeneratorArgs) (all []types.Pair, err error) {
-	pairs, err := fl.keyValuesFromEnvFiles(args.EnvSources)
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf(
-			"env source files: %v",
-			args.EnvSources))
-	}
-	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 = fl.keyValuesFromFileSources(args.FileSources)
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf(
-			"file sources: %v", args.FileSources))
-	}
-	return append(all, pairs...), nil
-}
-
-func keyValuesFromLiteralSources(sources []string) ([]types.Pair, error) {
-	var kvs []types.Pair
-	for _, s := range sources {
-		k, v, err := parseLiteralSource(s)
-		if err != nil {
-			return nil, err
-		}
-		kvs = append(kvs, types.Pair{Key: k, Value: v})
-	}
-	return kvs, nil
-}
-
-func (fl *fileLoader) keyValuesFromFileSources(sources []string) ([]types.Pair, error) {
-	var kvs []types.Pair
-	for _, s := range sources {
-		k, fPath, err := parseFileSource(s)
-		if err != nil {
-			return nil, err
-		}
-		content, err := fl.Load(fPath)
-		if err != nil {
-			return nil, err
-		}
-		kvs = append(kvs, types.Pair{Key: k, Value: string(content)})
-	}
-	return kvs, nil
-}
-
-func (fl *fileLoader) keyValuesFromEnvFiles(paths []string) ([]types.Pair, error) {
-	var kvs []types.Pair
-	for _, p := range paths {
-		content, err := fl.Load(p)
-		if err != nil {
-			return nil, err
-		}
-		more, err := fl.keyValuesFromLines(content)
-		if err != nil {
-			return nil, err
-		}
-		kvs = append(kvs, more...)
-	}
-	return kvs, nil
-}
-
-// keyValuesFromLines parses given content in to a list of key-value pairs.
-func (fl *fileLoader) keyValuesFromLines(content []byte) ([]types.Pair, error) {
-	var kvs []types.Pair
-
-	scanner := bufio.NewScanner(bytes.NewReader(content))
-	currentLine := 0
-	for scanner.Scan() {
-		// Process the current line, retrieving a key/value pair if
-		// possible.
-		scannedBytes := scanner.Bytes()
-		kv, err := fl.keyValuesFromLine(scannedBytes, currentLine)
-		if err != nil {
-			return nil, err
-		}
-		currentLine++
-
-		if len(kv.Key) == 0 {
-			// no key means line was empty or a comment
-			continue
-		}
-
-		kvs = append(kvs, kv)
-	}
-	return kvs, nil
-}
-
-// KeyValuesFromLine returns a kv with blank key if the line is empty or a comment.
-// The value will be retrieved from the environment if necessary.
-func (fl *fileLoader) keyValuesFromLine(line []byte, currentLine int) (types.Pair, error) {
-	kv := types.Pair{}
-
-	if !utf8.Valid(line) {
-		return kv, fmt.Errorf("line %d has invalid utf8 bytes : %v", line, string(line))
-	}
-
-	// We trim UTF8 BOM from the first line of the file but no others
-	if currentLine == 0 {
-		line = bytes.TrimPrefix(line, utf8bom)
-	}
-
-	// trim the line from all leading whitespace first
-	line = bytes.TrimLeftFunc(line, unicode.IsSpace)
-
-	// If the line is empty or a comment, we return a blank key/value pair.
-	if len(line) == 0 || line[0] == '#' {
-		return kv, nil
-	}
-
-	data := strings.SplitN(string(line), "=", 2)
-	key := data[0]
-	if err := fl.validator.IsEnvVarName(key); err != nil {
-		return kv, err
-	}
-
-	if len(data) == 2 {
-		kv.Value = data[1]
-	} else {
-		// No value (no `=` in the line) is a signal to obtain the value
-		// from the environment.
-		kv.Value = os.Getenv(key)
-	}
-	kv.Key = key
-	return kv, nil
-}
-
-// ParseFileSource parses the source given.
-//
-//  Acceptable formats include:
-//   1.  source-path: the basename will become the key name
-//   2.  source-name=source-path: the source-name will become the key name and
-//       source-path is the path to the key file.
-//
-// Key names cannot include '='.
-func parseFileSource(source string) (keyName, filePath string, err error) {
-	numSeparators := strings.Count(source, "=")
-	switch {
-	case numSeparators == 0:
-		return path.Base(source), source, nil
-	case numSeparators == 1 && strings.HasPrefix(source, "="):
-		return "", "", fmt.Errorf("key name for file path %v missing", strings.TrimPrefix(source, "="))
-	case numSeparators == 1 && strings.HasSuffix(source, "="):
-		return "", "", fmt.Errorf("file path for key name %v missing", strings.TrimSuffix(source, "="))
-	case numSeparators > 1:
-		return "", "", errors.New("key names or file paths cannot contain '='")
-	default:
-		components := strings.Split(source, "=")
-		return components[0], components[1], nil
-	}
-}
-
-// ParseLiteralSource parses the source key=val pair into its component pieces.
-// This functionality is distinguished from strings.SplitN(source, "=", 2) since
-// it returns an error in the case of empty keys, values, or a missing equals sign.
-func parseLiteralSource(source string) (keyName, value string, err error) {
-	// leading equal is invalid
-	if strings.Index(source, "=") == 0 {
-		return "", "", fmt.Errorf("invalid literal source %v, expected key=value", source)
-	}
-	// split after the first equal (so values can have the = character)
-	items := strings.SplitN(source, "=", 2)
-	if len(items) != 2 {
-		return "", "", fmt.Errorf("invalid literal source %v, expected key=value", source)
-	}
-	return items[0], strings.Trim(items[1], "\"'"), nil
-}

pkg/loader/kv_test.go

@@ -1,91 +0,0 @@
-// Copyright 2019 The Kubernetes Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package loader
-
-import (
-	"reflect"
-	"testing"
-
-	"sigs.k8s.io/kustomize/v3/filesys"
-	"sigs.k8s.io/kustomize/v3/pkg/types"
-	"sigs.k8s.io/kustomize/v3/pkg/validators"
-)
-
-func TestKeyValuesFromLines(t *testing.T) {
-	tests := []struct {
-		desc          string
-		content       string
-		expectedPairs []types.Pair
-		expectedErr   bool
-	}{
-		{
-			desc: "valid kv content parse",
-			content: `
-		k1=v1
-		k2=v2
-		`,
-			expectedPairs: []types.Pair{
-				{Key: "k1", Value: "v1"},
-				{Key: "k2", Value: "v2"},
-			},
-			expectedErr: false,
-		},
-		{
-			desc: "content with comments",
-			content: `
-		k1=v1
-		#k2=v2
-		`,
-			expectedPairs: []types.Pair{
-				{Key: "k1", Value: "v1"},
-			},
-			expectedErr: false,
-		},
-		// TODO: add negative testcases
-	}
-
-	l := NewFileLoaderAtRoot(
-		validators.MakeFakeValidator(), filesys.MakeFsInMemory())
-	for _, test := range tests {
-		pairs, err := l.keyValuesFromLines([]byte(test.content))
-		if test.expectedErr && err == nil {
-			t.Fatalf("%s should not return error", test.desc)
-		}
-		if !reflect.DeepEqual(pairs, test.expectedPairs) {
-			t.Errorf("%s should succeed, got:%v exptected:%v", test.desc, pairs, test.expectedPairs)
-		}
-	}
-}
-
-func TestKeyValuesFromFileSources(t *testing.T) {
-	tests := []struct {
-		description string
-		sources     []string
-		expected    []types.Pair
-	}{
-		{
-			description: "create kvs from file sources",
-			sources:     []string{"files/app-init.ini"},
-			expected: []types.Pair{
-				{
-					Key:   "app-init.ini",
-					Value: "FOO=bar",
-				},
-			},
-		},
-	}
-
-	fSys := filesys.MakeFsInMemory()
-	fSys.WriteFile("/files/app-init.ini", []byte("FOO=bar"))
-	l := NewFileLoaderAtRoot(validators.MakeFakeValidator(), fSys)
-	for _, tc := range tests {
-		kvs, err := l.keyValuesFromFileSources(tc.sources)
-		if err != nil {
-			t.Fatalf("unexpected error: %v", err)
-		}
-		if !reflect.DeepEqual(kvs, tc.expected) {
-			t.Fatalf("in testcase: %q updated:\n%#v\ndoesn't match expected:\n%#v\n", tc.description, kvs, tc.expected)
-		}
-	}
-}

pkg/loader/loader.go

@@ -18,18 +18,17 @@ import (
 // the remote bases will all be root-only restricted.
 func NewLoader(
 	lr LoadRestrictorFunc,
-	v ifc.Validator,
 	target string, fSys filesys.FileSystem) (ifc.Loader, error) {
 	repoSpec, err := git.NewRepoSpecFromUrl(target)
 	if err == nil {
 		// The target qualifies as a remote git target.
 		return newLoaderAtGitClone(
-			repoSpec, v, fSys, nil, git.ClonerUsingGitExec)
+			repoSpec, fSys, nil, git.ClonerUsingGitExec)
 	}
 	root, err := demandDirectoryRoot(fSys, target)
 	if err != nil {
 		return nil, err
 	}
 	return newLoaderAtConfirmedDir(
-		lr, v, root, fSys, nil, git.ClonerUsingGitExec), nil
+		lr, root, fSys, nil, git.ClonerUsingGitExec), nil
 }

pkg/plugins/execplugin_test.go

@@ -13,6 +13,7 @@ import (
 	"sigs.k8s.io/kustomize/v3/pkg/resmap"
 	"sigs.k8s.io/kustomize/v3/pkg/resource"
 	"sigs.k8s.io/kustomize/v3/pkg/types"
+	"sigs.k8s.io/kustomize/v3/pkg/validators"
 )
 
 func TestExecPluginConfig(t *testing.T) {
@@ -21,6 +22,7 @@ func TestExecPluginConfig(t *testing.T) {
 		resource.NewFactory(
 			kunstruct.NewKunstructuredFactoryImpl()), nil)
 	ldr := loadertest.NewFakeLoader(path)
+	v := validators.MakeFakeValidator()
 	pluginConfig := rf.RF().FromMap(
 		map[string]interface{}{
 			"apiVersion": "someteam.example.com/v1",
@@ -47,7 +49,7 @@ s/$BAR/bar/g
 	if err != nil {
 		t.Fatalf("unexpected err: %v", err)
 	}
-	p.Config(resmap.NewPluginHelpers(ldr, rf), yaml)
+	p.Config(resmap.NewPluginHelpers(ldr, v, rf), yaml)
 
 	expected := "/kustomize/plugin/someteam.example.com/v1/sedtransformer/SedTransformer"
 	if !strings.HasSuffix(p.path, expected) {

pkg/plugins/loader.go

@@ -30,10 +30,10 @@ func NewLoader(
 }
 
 func (l *Loader) LoadGenerators(
-	ldr ifc.Loader, rm resmap.ResMap) ([]resmap.Generator, error) {
+	ldr ifc.Loader, v ifc.Validator, rm resmap.ResMap) ([]resmap.Generator, error) {
 	var result []resmap.Generator
 	for _, res := range rm.Resources() {
-		g, err := l.LoadGenerator(ldr, res)
+		g, err := l.LoadGenerator(ldr, v, res)
 		if err != nil {
 			return nil, err
 		}
@@ -43,8 +43,8 @@ func (l *Loader) LoadGenerators(
 }
 
 func (l *Loader) LoadGenerator(
-	ldr ifc.Loader, res *resource.Resource) (resmap.Generator, error) {
-	c, err := l.loadAndConfigurePlugin(ldr, res)
+	ldr ifc.Loader, v ifc.Validator, res *resource.Resource) (resmap.Generator, error) {
+	c, err := l.loadAndConfigurePlugin(ldr, v, res)
 	if err != nil {
 		return nil, err
 	}
@@ -56,10 +56,10 @@ func (l *Loader) LoadGenerator(
 }
 
 func (l *Loader) LoadTransformers(
-	ldr ifc.Loader, rm resmap.ResMap) ([]resmap.Transformer, error) {
+	ldr ifc.Loader, v ifc.Validator, rm resmap.ResMap) ([]resmap.Transformer, error) {
 	var result []resmap.Transformer
 	for _, res := range rm.Resources() {
-		t, err := l.LoadTransformer(ldr, res)
+		t, err := l.LoadTransformer(ldr, v, res)
 		if err != nil {
 			return nil, err
 		}
@@ -69,8 +69,8 @@ func (l *Loader) LoadTransformers(
 }
 
 func (l *Loader) LoadTransformer(
-	ldr ifc.Loader, res *resource.Resource) (resmap.Transformer, error) {
-	c, err := l.loadAndConfigurePlugin(ldr, res)
+	ldr ifc.Loader, v ifc.Validator, res *resource.Resource) (resmap.Transformer, error) {
+	c, err := l.loadAndConfigurePlugin(ldr, v, res)
 	if err != nil {
 		return nil, err
 	}
@@ -104,7 +104,7 @@ func isBuiltinPlugin(res *resource.Resource) bool {
 }
 
 func (l *Loader) loadAndConfigurePlugin(
-	ldr ifc.Loader, res *resource.Resource) (c resmap.Configurable, err error) {
+	ldr ifc.Loader, v ifc.Validator, res *resource.Resource) (c resmap.Configurable, err error) {
 	if isBuiltinPlugin(res) {
 		// Instead of looking for and loading a .so file, just
 		// instantiate the plugin from a generated factory
@@ -123,7 +123,7 @@ func (l *Loader) loadAndConfigurePlugin(
 	if err != nil {
 		return nil, errors.Wrapf(err, "marshalling yaml from res %s", res.OrgId())
 	}
-	err = c.Config(resmap.NewPluginHelpers(ldr, l.rf), yaml)
+	err = c.Config(resmap.NewPluginHelpers(ldr, v, l.rf), yaml)
 	if err != nil {
 		return nil, errors.Wrapf(
 			err, "plugin %s fails configuration", res.OrgId())

pkg/plugins/loader_test.go

@@ -6,13 +6,13 @@ package plugins_test
 import (
 	"testing"
 
-	"sigs.k8s.io/kustomize/v3/pluglib"
-
 	"sigs.k8s.io/kustomize/v3/internal/loadertest"
 	"sigs.k8s.io/kustomize/v3/k8sdeps/kunstruct"
 	. "sigs.k8s.io/kustomize/v3/pkg/plugins"
 	"sigs.k8s.io/kustomize/v3/pkg/resmap"
 	"sigs.k8s.io/kustomize/v3/pkg/resource"
+	"sigs.k8s.io/kustomize/v3/pkg/validators"
+	"sigs.k8s.io/kustomize/v3/pluglib"
 )
 
 const (
@@ -54,20 +54,20 @@ func TestLoader(t *testing.T) {
 	rmF := resmap.NewFactory(resource.NewFactory(
 		kunstruct.NewKunstructuredFactoryImpl()), nil)
 
-	l := NewLoader(ActivePluginConfig(), rmF)
-	if l == nil {
+	ldr := loadertest.NewFakeLoader("/foo")
+
+	pLdr := NewLoader(ActivePluginConfig(), rmF)
+	if pLdr == nil {
 		t.Fatal("expect non-nil loader")
 	}
 
-	ldr := loadertest.NewFakeLoader("/foo")
-
 	m, err := rmF.NewResMapFromBytes([]byte(
 		someServiceGenerator + "---\n" + secretGenerator))
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	_, err = l.LoadGenerators(ldr, m)
+	_, err = pLdr.LoadGenerators(ldr, validators.MakeFakeValidator(), m)
 	if err != nil {
 		t.Fatal(err)
 	}

pkg/resmap/factory.go

@@ -66,12 +66,12 @@ func (rmF *Factory) NewResMapFromBytes(b []byte) (ResMap, error) {
 // NewResMapFromConfigMapArgs returns a Resource slice given
 // a configmap metadata slice from kustomization file.
 func (rmF *Factory) NewResMapFromConfigMapArgs(
-	ldr ifc.Loader,
+	kvLdr ifc.KvLoader,
 	options *types.GeneratorOptions,
 	argList []types.ConfigMapArgs) (ResMap, error) {
 	var resources []*resource.Resource
 	for _, args := range argList {
-		res, err := rmF.resF.MakeConfigMap(ldr, options, &args)
+		res, err := rmF.resF.MakeConfigMap(kvLdr, options, &args)
 		if err != nil {
 			return nil, errors.Wrap(err, "NewResMapFromConfigMapArgs")
 		}
@@ -81,10 +81,10 @@ func (rmF *Factory) NewResMapFromConfigMapArgs(
 }
 
 func (rmF *Factory) FromConfigMapArgs(
-	ldr ifc.Loader,
+	kvLdr ifc.KvLoader,
 	options *types.GeneratorOptions,
 	args types.ConfigMapArgs) (ResMap, error) {
-	res, err := rmF.resF.MakeConfigMap(ldr, options, &args)
+	res, err := rmF.resF.MakeConfigMap(kvLdr, options, &args)
 	if err != nil {
 		return nil, err
 	}
@@ -94,12 +94,12 @@ func (rmF *Factory) FromConfigMapArgs(
 // NewResMapFromSecretArgs takes a SecretArgs slice, generates
 // secrets from each entry, and accumulates them in a ResMap.
 func (rmF *Factory) NewResMapFromSecretArgs(
-	ldr ifc.Loader,
+	kvLdr ifc.KvLoader,
 	options *types.GeneratorOptions,
 	argsList []types.SecretArgs) (ResMap, error) {
 	var resources []*resource.Resource
 	for _, args := range argsList {
-		res, err := rmF.resF.MakeSecret(ldr, options, &args)
+		res, err := rmF.resF.MakeSecret(kvLdr, options, &args)
 		if err != nil {
 			return nil, errors.Wrap(err, "NewResMapFromSecretArgs")
 		}
@@ -109,10 +109,10 @@ func (rmF *Factory) NewResMapFromSecretArgs(
 }
 
 func (rmF *Factory) FromSecretArgs(
-	ldr ifc.Loader,
+	kvLdr ifc.KvLoader,
 	options *types.GeneratorOptions,
 	args types.SecretArgs) (ResMap, error) {
-	res, err := rmF.resF.MakeSecret(ldr, options, &args)
+	res, err := rmF.resF.MakeSecret(kvLdr, options, &args)
 	if err != nil {
 		return nil, err
 	}

pkg/resmap/factory_test.go

@@ -10,6 +10,7 @@ import (
 
 	"sigs.k8s.io/kustomize/v3/filesys"
 	"sigs.k8s.io/kustomize/v3/internal/loadertest"
+	"sigs.k8s.io/kustomize/v3/kv"
 	"sigs.k8s.io/kustomize/v3/pkg/gvk"
 	"sigs.k8s.io/kustomize/v3/pkg/ifc"
 	"sigs.k8s.io/kustomize/v3/pkg/loader"
@@ -119,6 +120,7 @@ func TestNewFromConfigMaps(t *testing.T) {
 	}
 
 	l := loadertest.NewFakeLoader("/whatever/project")
+	kvLdr := kv.NewLoader(l, validators.MakeFakeValidator())
 	testCases := []testCase{
 		{
 			description: "construct config map from env",
@@ -206,10 +208,10 @@ BAR=baz
 		// files/literal/env etc.
 	}
 	for _, tc := range testCases {
-		if ferr := l.AddFile(tc.filepath, []byte(tc.content)); ferr != nil {
-			t.Fatalf("Error adding fake file: %v\n", ferr)
+		if fErr := l.AddFile(tc.filepath, []byte(tc.content)); fErr != nil {
+			t.Fatalf("Error adding fake file: %v\n", fErr)
 		}
-		r, err := rmF.NewResMapFromConfigMapArgs(l, nil, tc.input)
+		r, err := rmF.NewResMapFromConfigMapArgs(kvLdr, nil, tc.input)
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
@@ -236,8 +238,11 @@ func TestNewResMapFromSecretArgs(t *testing.T) {
 	}
 	fSys := filesys.MakeFsInMemory()
 	fSys.Mkdir(".")
+
 	actual, err := rmF.NewResMapFromSecretArgs(
-		loader.NewFileLoaderAtRoot(validators.MakeFakeValidator(), fSys), nil, secrets)
+		kv.NewLoader(
+			loader.NewFileLoaderAtRoot(fSys),
+			validators.MakeFakeValidator()), nil, secrets)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}

pkg/resmap/resmap.go

@@ -38,8 +38,8 @@ type Configurable interface {
 }
 
 // NewPluginHelpers makes an instance of PluginHelpers.
-func NewPluginHelpers(ldr ifc.Loader, rf *Factory) *PluginHelpers {
-	return &PluginHelpers{ldr: ldr, rf: rf}
+func NewPluginHelpers(ldr ifc.Loader, v ifc.Validator, rf *Factory) *PluginHelpers {
+	return &PluginHelpers{ldr: ldr, v: v, rf: rf}
 }
 
 // PluginHelpers holds things that any or all plugins might need.
@@ -47,6 +47,7 @@ func NewPluginHelpers(ldr ifc.Loader, rf *Factory) *PluginHelpers {
 // any plugin-specific configuration.
 type PluginHelpers struct {
 	ldr ifc.Loader
+	v   ifc.Validator
 	rf  *Factory
 }
 
@@ -58,6 +59,10 @@ func (c *PluginHelpers) ResmapFactory() *Factory {
 	return c.rf
 }
 
+func (c *PluginHelpers) Validator() ifc.Validator {
+	return c.v
+}
+
 type GeneratorPlugin interface {
 	Generator
 	Configurable

pkg/resource/factory.go

@@ -148,10 +148,10 @@ func (rf *Factory) SliceFromBytes(in []byte) ([]*Resource, error) {
 
 // MakeConfigMap makes an instance of Resource for ConfigMap
 func (rf *Factory) MakeConfigMap(
-	ldr ifc.Loader,
+	kvLdr ifc.KvLoader,
 	options *types.GeneratorOptions,
 	args *types.ConfigMapArgs) (*Resource, error) {
-	u, err := rf.kf.MakeConfigMap(ldr, options, args)
+	u, err := rf.kf.MakeConfigMap(kvLdr, options, args)
 	if err != nil {
 		return nil, err
 	}
@@ -164,10 +164,10 @@ func (rf *Factory) MakeConfigMap(
 
 // MakeSecret makes an instance of Resource for Secret
 func (rf *Factory) MakeSecret(
-	ldr ifc.Loader,
+	kvLdr ifc.KvLoader,
 	options *types.GeneratorOptions,
 	args *types.SecretArgs) (*Resource, error) {
-	u, err := rf.kf.MakeSecret(ldr, options, args)
+	u, err := rf.kf.MakeSecret(kvLdr, options, args)
 	if err != nil {
 		return nil, err
 	}

pkg/target/kusttarget.go

@@ -29,6 +29,7 @@ import (
 type KustTarget struct {
 	kustomization *types.Kustomization
 	ldr           ifc.Loader
+	validator     ifc.Validator
 	rFactory      *resmap.Factory
 	tFactory      resmap.PatchFactory
 	pLdr          *plugins.Loader
@@ -37,6 +38,7 @@ type KustTarget struct {
 // NewKustTarget returns a new instance of KustTarget primed with a Loader.
 func NewKustTarget(
 	ldr ifc.Loader,
+	validator ifc.Validator,
 	rFactory *resmap.Factory,
 	tFactory resmap.PatchFactory,
 	pLdr *plugins.Loader) (*KustTarget, error) {
@@ -60,6 +62,7 @@ func NewKustTarget(
 	return &KustTarget{
 		kustomization: &k,
 		ldr:           ldr,
+		validator:     validator,
 		rFactory:      rFactory,
 		tFactory:      tFactory,
 		pLdr:          pLdr,
@@ -281,7 +284,7 @@ func (kt *KustTarget) configureExternalGenerators() ([]resmap.Generator, error)
 	if err != nil {
 		return nil, err
 	}
-	return kt.pLdr.LoadGenerators(kt.ldr, ra.ResMap())
+	return kt.pLdr.LoadGenerators(kt.ldr, kt.validator, ra.ResMap())
 }
 
 func (kt *KustTarget) runTransformers(ra *accumulator.ResAccumulator) error {
@@ -307,7 +310,7 @@ func (kt *KustTarget) configureExternalTransformers() ([]resmap.Transformer, err
 	if err != nil {
 		return nil, err
 	}
-	return kt.pLdr.LoadTransformers(kt.ldr, ra.ResMap())
+	return kt.pLdr.LoadTransformers(kt.ldr, kt.validator, ra.ResMap())
 }
 
 // accumulateResources fills the given resourceAccumulator
@@ -337,7 +340,7 @@ func (kt *KustTarget) accumulateDirectory(
 	ra *accumulator.ResAccumulator, ldr ifc.Loader, path string) error {
 	defer ldr.Cleanup()
 	subKt, err := NewKustTarget(
-		ldr, kt.rFactory, kt.tFactory, kt.pLdr)
+		ldr, kt.validator, kt.rFactory, kt.tFactory, kt.pLdr)
 	if err != nil {
 		return errors.Wrapf(err, "couldn't make target for path '%s'", path)
 	}
@@ -377,7 +380,7 @@ func (kt *KustTarget) configureBuiltinPlugin(
 				err, "builtin %s marshal", bpt)
 		}
 	}
-	err = p.Config(resmap.NewPluginHelpers(kt.ldr, kt.rFactory), y)
+	err = p.Config(resmap.NewPluginHelpers(kt.ldr, kt.validator, kt.rFactory), y)
 	if err != nil {
 		return errors.Wrapf(err, "builtin %s config: %v", bpt, y)
 	}

pkg/target/kusttarget_test.go

@@ -17,6 +17,7 @@ import (
 	"sigs.k8s.io/kustomize/v3/pkg/resource"
 	. "sigs.k8s.io/kustomize/v3/pkg/target"
 	"sigs.k8s.io/kustomize/v3/pkg/types"
+	"sigs.k8s.io/kustomize/v3/pkg/validators"
 )
 
 const (
@@ -184,7 +185,8 @@ func TestResources(t *testing.T) {
 
 func TestKustomizationNotFound(t *testing.T) {
 	_, err := NewKustTarget(
-		loadertest.NewFakeLoader("/foo"), nil, nil, nil)
+		loadertest.NewFakeLoader("/foo"),
+		validators.MakeFakeValidator(), nil, nil, nil)
 	if err == nil {
 		t.Fatalf("expected an error")
 	}

pkg/target/plugindir_test.go

@@ -59,7 +59,7 @@ metadata:
 	}
 
 	ldr, err := loader.NewLoader(
-		loader.RestrictionRootOnly, validators.MakeFakeValidator(), dir, fSys)
+		loader.RestrictionRootOnly, dir, fSys)
 	if err != nil {
 		t.Fatalf("Err: %v", err)
 	}
@@ -67,7 +67,8 @@ metadata:
 		kunstruct.NewKunstructuredFactoryImpl()), nil)
 
 	pl := plugins.NewLoader(plugins.ActivePluginConfig(), rf)
-	tg, err := target.NewKustTarget(ldr, rf, transformer.NewFactoryImpl(), pl)
+	tg, err := target.NewKustTarget(
+		ldr, validators.MakeFakeValidator(), rf, transformer.NewFactoryImpl(), pl)
 	if err != nil {
 		t.Fatalf("err %v", err)
 	}

pkg/types/kustomization.go

@@ -182,12 +182,6 @@ type PluginConfig struct {
 	Enabled bool
 }
 
-// Pair is a key value pair.
-type Pair struct {
-	Key   string
-	Value string
-}
-
 type PluginType string
 
 func (p PluginType) IsUndefined() bool {

pkg/types/kvpairsources.go

@@ -3,7 +3,7 @@
 
 package types
 
-// KvPairSources contains some generic sources for generators.
+// KvPairSources defines places to obtain key value pairs.
 type KvPairSources struct {
 	// LiteralSources is a list of literal
 	// pair sources. Each literal source should

pkg/types/pair.go

@@ -0,0 +1,10 @@
+// Copyright 2019 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package types
+
+// Pair is a key value pair.
+type Pair struct {
+	Key   string
+	Value string
+}