kubernetes-sigs/kustomize
1
0
Fork 0
mirror of https://github.com/kubernetes-sigs/kustomize.git synced 2026-06-12 01:14:22 +00:00
Code Issues Packages Projects Releases 1 Wiki Activity

Delete some code.

Browse Source
This commit is contained in:
Jeff Regan
2018-07-23 14:02:47 -07:00
committed by Jeffrey Regan
parent 5715f4bab4 969f4f28fa
commit fdc46fb0b1
9 changed files with 115 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
pkg/configmapandsecret/configmapfactory.go
View File

@@ -19,7 +19,6 @@ package configmapandsecret
import (
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"path"
@@ -29,6 +28,7 @@ import (
"github.com/kubernetes-sigs/kustomize/pkg/hash"
"github.com/kubernetes-sigs/kustomize/pkg/loader"
"github.com/kubernetes-sigs/kustomize/pkg/types"
"github.com/pkg/errors"
"k8s.io/api/core/v1"
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -38,22 +38,20 @@ import (
// ConfigMapFactory makes ConfigMaps.
type ConfigMapFactory struct {
args *types.ConfigMapArgs
fSys fs.FileSystem
ldr loader.Loader
}
// NewConfigMapFactory returns a new ConfigMapFactory.
func NewConfigMapFactory(
args *types.ConfigMapArgs,
l loader.Loader,
fSys fs.FileSystem) *ConfigMapFactory {
return &ConfigMapFactory{args: args, ldr: l, fSys: fSys}
fSys fs.FileSystem, l loader.Loader) *ConfigMapFactory {
return &ConfigMapFactory{fSys: fSys, ldr: l}
}
// MakeUnstructAndGenerateName returns an configmap and the name appended with a hash.
func (f *ConfigMapFactory) MakeUnstructAndGenerateName() (*unstructured.Unstructured, string, error) {
cm, err := f.MakeConfigMap1()
func (f *ConfigMapFactory) MakeUnstructAndGenerateName(
args *types.ConfigMapArgs) (*unstructured.Unstructured, string, error) {
cm, err := f.MakeConfigMap1(args)
if err != nil {
return nil, "", err
}
@@ -76,31 +74,32 @@ func objectToUnstructured(in runtime.Object) (*unstructured.Unstructured, error)
return &out, err
}
func (f *ConfigMapFactory) makeFreshConfigMap() *corev1.ConfigMap {
func (f *ConfigMapFactory) makeFreshConfigMap(
args *types.ConfigMapArgs) *corev1.ConfigMap {
cm := &corev1.ConfigMap{}
cm.APIVersion = "v1"
cm.Kind = "ConfigMap"
cm.Name = f.args.Name
cm.Name = args.Name
cm.Data = map[string]string{}
return cm
}
// MakeConfigMap1 returns a new ConfigMap, or nil and an error.
func (f *ConfigMapFactory) MakeConfigMap1() (*corev1.ConfigMap, error) {
cm := f.makeFreshConfigMap()
if f.args.EnvSource != "" {
if err := f.handleConfigMapFromEnvFileSource(cm); err != nil {
func (f *ConfigMapFactory) MakeConfigMap1(
args *types.ConfigMapArgs) (*corev1.ConfigMap, error) {
cm := f.makeFreshConfigMap(args)
if args.EnvSource != "" {
if err := f.handleConfigMapFromEnvFileSource(cm, args); err != nil {
return nil, err
}
}
if f.args.FileSources != nil {
if err := f.handleConfigMapFromFileSources(cm); err != nil {
if args.FileSources != nil {
if err := f.handleConfigMapFromFileSources(cm, args); err != nil {
return nil, err
}
}
if f.args.LiteralSources != nil {
if err := f.handleConfigMapFromLiteralSources(cm); err != nil {
if args.LiteralSources != nil {
if err := f.handleConfigMapFromLiteralSources(cm, args.LiteralSources); err != nil {
return nil, err
}
}
@@ -109,40 +108,38 @@ func (f *ConfigMapFactory) MakeConfigMap1() (*corev1.ConfigMap, error) {
// MakeConfigMap2 returns a new ConfigMap, or nil and an error.
// TODO: Get rid of the nearly duplicated code in MakeConfigMap1 vs MakeConfigMap2
func (f *ConfigMapFactory) MakeConfigMap2() (*corev1.ConfigMap, error) {
var envPairs, literalPairs, filePairs []kvPair
func (f *ConfigMapFactory) MakeConfigMap2(
args *types.ConfigMapArgs) (*corev1.ConfigMap, error) {
var all []kvPair
var err error
cm := f.makeFreshConfigMap(args)
cm := f.makeFreshConfigMap()
if f.args.EnvSource != "" {
envPairs, err = keyValuesFromEnvFile(f.ldr, f.args.EnvSource)
if err != nil {
return nil, fmt.Errorf(
"error reading keys from env source file: %s %v",
f.args.EnvSource, err)
}
}
literalPairs, err = keyValuesFromLiteralSources(f.args.LiteralSources)
pairs, err := keyValuesFromEnvFile(f.ldr, args.EnvSource)
if err != nil {
return nil, fmt.Errorf(
"error reading key values from literal sources: %v", err)
return nil, errors.Wrap(err, fmt.Sprintf(
"env source file: %s",
args.EnvSource))
}
all = append(all, pairs...)
filePairs, err = keyValuesFromFileSources(f.ldr, f.args.FileSources)
pairs, err = keyValuesFromLiteralSources(args.LiteralSources)
if err != nil {
return nil, fmt.Errorf(
"error reading key values from file sources: %v", err)
return nil, errors.Wrap(err, fmt.Sprintf(
"literal sources %v", args.LiteralSources))
}
all = append(all, pairs...)
allPairs := append(append(envPairs, literalPairs...), filePairs...)
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...)
// merge key value pairs from all the sources
for _, kv := range allPairs {
err = addKV(cm.Data, kv)
for _, kv := range all {
err = addKeyFromLiteralToConfigMap(cm, kv.key, kv.value)
if err != nil {
return nil, fmt.Errorf("error adding key in configmap: %v", err)
return nil, err
}
}
return cm, nil
@@ -163,13 +160,13 @@ func keyValuesFromLiteralSources(sources []string) ([]kvPair, error) {
// handleConfigMapFromLiteralSources adds the specified literal source
// information into the provided configMap.
func (f *ConfigMapFactory) handleConfigMapFromLiteralSources(
configMap *v1.ConfigMap) error {
for _, literalSource := range f.args.LiteralSources {
keyName, value, err := ParseLiteralSource(literalSource)
configMap *v1.ConfigMap, sources []string) error {
for _, s := range sources {
k, v, err := ParseLiteralSource(s)
if err != nil {
return err
}
err = addKeyFromLiteralToConfigMap(configMap, keyName, value)
err = addKeyFromLiteralToConfigMap(configMap, k, v)
if err != nil {
return err
}
@@ -195,8 +192,9 @@ func keyValuesFromFileSources(ldr loader.Loader, sources []string) ([]kvPair, er
// handleConfigMapFromFileSources adds the specified file source information
// into the provided configMap
func (f *ConfigMapFactory) handleConfigMapFromFileSources(configMap *v1.ConfigMap) error {
for _, fileSource := range f.args.FileSources {
func (f *ConfigMapFactory) handleConfigMapFromFileSources(
configMap *v1.ConfigMap, args *types.ConfigMapArgs) error {
for _, fileSource := range args.FileSources {
keyName, filePath, err := ParseFileSource(fileSource)
if err != nil {
return err
@@ -232,6 +230,9 @@ func (f *ConfigMapFactory) handleConfigMapFromFileSources(configMap *v1.ConfigMa
}
func keyValuesFromEnvFile(l loader.Loader, path string) ([]kvPair, error) {
if path == "" {
return nil, nil
}
content, err := l.Load(path)
if err != nil {
return nil, err
@@ -241,14 +242,15 @@ func keyValuesFromEnvFile(l loader.Loader, path string) ([]kvPair, error) {
// HandleConfigMapFromEnvFileSource adds the specified env file source information
// into the provided configMap
func (f *ConfigMapFactory) handleConfigMapFromEnvFileSource(configMap *v1.ConfigMap) error {
if !f.fSys.Exists(f.args.EnvSource) {
return fmt.Errorf("unable to read configmap env file %s", f.args.EnvSource)
func (f *ConfigMapFactory) handleConfigMapFromEnvFileSource(
configMap *v1.ConfigMap, args *types.ConfigMapArgs) error {
if !f.fSys.Exists(args.EnvSource) {
return fmt.Errorf("unable to read configmap env file %s", args.EnvSource)
}
if f.fSys.IsDir(f.args.EnvSource) {
return fmt.Errorf("env config file %s cannot be a directory", f.args.EnvSource)
if f.fSys.IsDir(args.EnvSource) {
return fmt.Errorf("env config file %s cannot be a directory", args.EnvSource)
}
return addFromEnvFile(f.args.EnvSource, func(key, value string) error {
return addFromEnvFile(args.EnvSource, func(key, value string) error {
return addKeyFromLiteralToConfigMap(configMap, key, value)
})
}
@@ -318,18 +320,3 @@ func ParseLiteralSource(source string) (keyName, value string, err error) {
return items[0], items[1], nil
}
// addKV adds key-value pair to the provided map.
func addKV(m map[string]string, kv kvPair) error {
if errs := validation.IsConfigMapKey(kv.key); len(errs) != 0 {
return fmt.Errorf(
"%q is not a valid key name: %s",
kv.key, strings.Join(errs, ";"))
}
if _, exists := m[kv.key]; exists {
return fmt.Errorf(
"key %s already exists: %v", kv.key, m)
}
m[kv.key] = kv.value
return nil
}

7
pkg/configmapandsecret/configmapfactory_test.go
View File

@@ -133,11 +133,10 @@ func TestConstructConfigMap(t *testing.T) {
},
}
// TODO: all tests should use a FakeFs
f := NewConfigMapFactory(fs.MakeRealFS(), nil)
for _, tc := range testCases {
// TODO: all tests should use a FakeFs
fSys := fs.MakeRealFS()
f := NewConfigMapFactory(&tc.input, nil, fSys)
cm, err := f.MakeConfigMap1()
cm, err := f.MakeConfigMap1(&tc.input)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}

35
pkg/configmapandsecret/secretfactory.go
View File

@@ -2,39 +2,40 @@ package configmapandsecret
import (
"context"
"os/exec"
"path/filepath"
"time"
"github.com/kubernetes-sigs/kustomize/pkg/fs"
"github.com/kubernetes-sigs/kustomize/pkg/types"
"github.com/pkg/errors"
corev1 "k8s.io/api/core/v1"
"os/exec"
"path/filepath"
"time"
)
// SecretFactory makes Secrets.
type SecretFactory struct {
args types.SecretArgs
fSys fs.FileSystem
wd string
}
// NewSecretFactory returns a new SecretFactory.
func NewSecretFactory(args types.SecretArgs, fSys fs.FileSystem) *SecretFactory {
return &SecretFactory{args: args, fSys: fSys}
func NewSecretFactory(fSys fs.FileSystem, wd string) *SecretFactory {
return &SecretFactory{fSys: fSys, wd: wd}
}
// MakeSecret returns a new secret.
func (f *SecretFactory) MakeSecret(wd string) (*corev1.Secret, error) {
func (f *SecretFactory) MakeSecret(args types.SecretArgs) (*corev1.Secret, error) {
s := &corev1.Secret{}
s.APIVersion = "v1"
s.Kind = "Secret"
s.Name = f.args.Name
s.Type = corev1.SecretType(f.args.Type)
s.Name = args.Name
s.Type = corev1.SecretType(args.Type)
if s.Type == "" {
s.Type = corev1.SecretTypeOpaque
}
s.Data = map[string][]byte{}
for k, v := range f.args.Commands {
out, err := f.createSecretKey(wd, v)
for k, v := range args.Commands {
out, err := f.createSecretKey(v)
if err != nil {
return nil, errors.Wrap(err, "createSecretKey")
}
@@ -44,16 +45,16 @@ func (f *SecretFactory) MakeSecret(wd string) (*corev1.Secret, error) {
}
// Run a command, return its output as the secret.
func (f *SecretFactory) createSecretKey(wd string, command string) ([]byte, error) {
if !f.fSys.IsDir(wd) {
wd = filepath.Dir(wd)
if !f.fSys.IsDir(wd) {
return nil, errors.New("not a directory: " + wd)
func (f *SecretFactory) createSecretKey(command string) ([]byte, error) {
if !f.fSys.IsDir(f.wd) {
f.wd = filepath.Dir(f.wd)
if !f.fSys.IsDir(f.wd) {
return nil, errors.New("not a directory: " + f.wd)
}
}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, "sh", "-c", command)
cmd.Dir = wd
cmd.Dir = f.wd
return cmd.Output()
}