change kinflate to kustomize

util/diff.go

@@ -0,0 +1,104 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package util
+
+import (
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/ghodss/yaml"
+
+	"k8s.io/utils/exec"
+)
+
+// DiffProgram finds and run the diff program. The value of
+// KUBERNETES_EXTERNAL_DIFF environment variable will be used a diff
+// program. By default, `diff(1)` will be used.
+type DiffProgram struct {
+	Exec   exec.Interface
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+func (d *DiffProgram) getCommand(args ...string) exec.Cmd {
+	diff := ""
+	if envDiff := os.Getenv("KUBERNETES_EXTERNAL_DIFF"); envDiff != "" {
+		diff = envDiff
+	} else {
+		diff = "diff"
+		args = append([]string{"-u", "-N"}, args...)
+	}
+
+	cmd := d.Exec.Command(diff, args...)
+	cmd.SetStdout(d.Stdout)
+	cmd.SetStderr(d.Stderr)
+
+	return cmd
+}
+
+// Run runs the detected diff program. `from` and `to` are the directory to diff.
+func (d *DiffProgram) Run(from, to string) error {
+	d.getCommand(from, to).Run() // Ignore diff return code
+	return nil
+}
+
+// Printer is used to print an object.
+type Printer struct{}
+
+// Print the object inside the writer w.
+func (p *Printer) Print(obj interface{}, w io.Writer) error {
+	if obj == nil {
+		return nil
+	}
+	data, err := yaml.Marshal(obj)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(data)
+	return err
+
+}
+
+// Directory creates a new temp directory, and allows to easily create new files.
+type Directory struct {
+	Name string
+}
+
+// CreateDirectory does create the actual disk directory, and return a
+// new representation of it.
+func CreateDirectory(prefix string) (*Directory, error) {
+	name, err := ioutil.TempDir("", prefix+"-")
+	if err != nil {
+		return nil, err
+	}
+
+	return &Directory{
+		Name: name,
+	}, nil
+}
+
+// NewFile creates a new file in the directory.
+func (d *Directory) NewFile(name string) (*os.File, error) {
+	return os.OpenFile(filepath.Join(d.Name, name), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0700)
+}
+
+// Delete removes the directory recursively.
+func (d *Directory) Delete() error {
+	return os.RemoveAll(d.Name)
+}

util/fs/fakefile.go

@@ -0,0 +1,74 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fs
+
+import (
+	"bytes"
+	"os"
+)
+
+var _ File = &FakeFile{}
+
+// FakeFile implements File in-memory for tests.
+type FakeFile struct {
+	name    string
+	content []byte
+	dir     bool
+	open    bool
+}
+
+// makeFile makes a fake file.
+func makeFile() *FakeFile {
+	return &FakeFile{}
+}
+
+// makeDir makes a fake directory.
+func makeDir(name string) *FakeFile {
+	return &FakeFile{name: name, dir: true}
+}
+
+// Close marks the fake file closed.
+func (f *FakeFile) Close() error {
+	f.open = false
+	return nil
+}
+
+// Read never fails, and doesn't mutate p.
+func (f *FakeFile) Read(p []byte) (n int, err error) {
+	return len(p), nil
+}
+
+// Write saves the contents of the argument to memory.
+func (f *FakeFile) Write(p []byte) (n int, err error) {
+	f.content = p
+	return len(p), nil
+}
+
+// ContentMatches returns true if v matches fake file's content.
+func (f *FakeFile) ContentMatches(v []byte) bool {
+	return bytes.Equal(v, f.content)
+}
+
+// GetContent the content of a fake file.
+func (f *FakeFile) GetContent() []byte {
+	return f.content
+}
+
+// Stat returns nil.
+func (f *FakeFile) Stat() (os.FileInfo, error) {
+	return nil, nil
+}

util/fs/fakefileinfo.go

@@ -0,0 +1,47 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fs
+
+import (
+	"os"
+	"time"
+)
+
+var _ os.FileInfo = &Fakefileinfo{}
+
+// Fakefileinfo implements Fakefileinfo using a fake in-memory filesystem.
+type Fakefileinfo struct {
+	*FakeFile
+}
+
+// Name returns the name of the file
+func (fi *Fakefileinfo) Name() string { return fi.name }
+
+// Size returns the size of the file
+func (fi *Fakefileinfo) Size() int64 { return int64(len(fi.content)) }
+
+// Mode returns the file mode
+func (fi *Fakefileinfo) Mode() os.FileMode { return 0777 }
+
+// ModTime returns the modification time
+func (fi *Fakefileinfo) ModTime() time.Time { return time.Time{} }
+
+// IsDir returns if it is a directory
+func (fi *Fakefileinfo) IsDir() bool { return fi.dir }
+
+// Sys should return underlying data source, but it now returns nil
+func (fi *Fakefileinfo) Sys() interface{} { return nil }

util/fs/fakefs.go

@@ -0,0 +1,80 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fs
+
+import (
+	"fmt"
+	"os"
+)
+
+var _ FileSystem = &FakeFS{}
+
+// FakeFS implements FileSystem using a fake in-memory filesystem.
+type FakeFS struct {
+	m map[string]*FakeFile
+}
+
+// MakeFakeFS returns an instance of FakeFS with no files in it.
+func MakeFakeFS() *FakeFS {
+	return &FakeFS{m: map[string]*FakeFile{}}
+}
+
+// Create assures a fake file appears in the in-memory file system.
+func (fs *FakeFS) Create(name string) (File, error) {
+	f := &FakeFile{}
+	f.open = true
+	fs.m[name] = f
+	return fs.m[name], nil
+}
+
+// Mkdir assures a fake directory appears in the in-memory file system.
+func (fs *FakeFS) Mkdir(name string, perm os.FileMode) error {
+	fs.m[name] = makeDir(name)
+	return nil
+}
+
+// Open returns a fake file in the open state.
+func (fs *FakeFS) Open(name string) (File, error) {
+	if _, found := fs.m[name]; !found {
+		return nil, fmt.Errorf("file %q cannot be opened", name)
+	}
+	return fs.m[name], nil
+}
+
+// Stat always returns nil FileInfo, and returns an error if file does not exist.
+func (fs *FakeFS) Stat(name string) (os.FileInfo, error) {
+	if f, found := fs.m[name]; found {
+		return &Fakefileinfo{f}, nil
+	}
+	return nil, fmt.Errorf("file %q does not exist", name)
+}
+
+// ReadFile always returns an empty bytes and error depending on content of m.
+func (fs *FakeFS) ReadFile(name string) ([]byte, error) {
+	if ff, found := fs.m[name]; found {
+		return ff.content, nil
+	}
+	return nil, fmt.Errorf("cannot read file %q", name)
+}
+
+// WriteFile always succeeds and does nothing.
+func (fs *FakeFS) WriteFile(name string, c []byte) error {
+	ff := &FakeFile{}
+	ff.Write(c)
+	fs.m[name] = ff
+	return nil
+}

util/fs/fakefs_test.go

@@ -0,0 +1,105 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fs
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestStatNotExist(t *testing.T) {
+	x := MakeFakeFS()
+	info, err := x.Stat("foo")
+	if info != nil {
+		t.Fatalf("expected nil info")
+	}
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+}
+
+func TestStat(t *testing.T) {
+	x := MakeFakeFS()
+	expectedName := "my-dir"
+	err := x.Mkdir(expectedName, 0666)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	info, err := x.Stat(expectedName)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	name := info.Name()
+	if name != expectedName {
+		t.Fatalf("expected %v but got %v", expectedName, name)
+	}
+	if !info.IsDir() {
+		t.Fatalf("expected IsDir() return true")
+	}
+}
+
+func TestCreate(t *testing.T) {
+	x := MakeFakeFS()
+	f, err := x.Create("foo")
+	if f == nil {
+		t.Fatalf("expected file")
+	}
+	if err != nil {
+		t.Fatalf("unexpected error")
+	}
+	info, err := x.Stat("foo")
+	if info == nil {
+		t.Fatalf("expected non-nil info")
+	}
+	if err != nil {
+		t.Fatalf("expected no error")
+	}
+}
+
+func TestReadFile(t *testing.T) {
+	x := MakeFakeFS()
+	f, err := x.Create("foo")
+	if f == nil {
+		t.Fatalf("expected file")
+	}
+	if err != nil {
+		t.Fatalf("unexpected error")
+	}
+	content, err := x.ReadFile("foo")
+	if len(content) != 0 {
+		t.Fatalf("expected no content")
+	}
+	if err != nil {
+		t.Fatalf("expected no error")
+	}
+}
+
+func TestWriteFile(t *testing.T) {
+	x := MakeFakeFS()
+	c := []byte("heybuddy")
+	err := x.WriteFile("foo", c)
+	if err != nil {
+		t.Fatalf("expected no error")
+	}
+	content, err := x.ReadFile("foo")
+	if err != nil {
+		t.Fatalf("expected read to work: %v", err)
+	}
+	if bytes.Compare(c, content) != 0 {
+		t.Fatalf("incorrect content: %v", content)
+	}
+}

util/fs/fs.go

@@ -0,0 +1,38 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fs
+
+import (
+	"io"
+	"os"
+)
+
+// FileSystem groups basic os filesystem methods.
+type FileSystem interface {
+	Create(name string) (File, error)
+	Mkdir(name string, perm os.FileMode) error
+	Open(name string) (File, error)
+	Stat(name string) (os.FileInfo, error)
+	ReadFile(name string) ([]byte, error)
+	WriteFile(name string, data []byte) error
+}
+
+// File groups the basic os.File methods.
+type File interface {
+	io.ReadWriteCloser
+	Stat() (os.FileInfo, error)
+}

util/fs/realfile.go

@@ -0,0 +1,49 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fs
+
+import (
+	"errors"
+	"os"
+)
+
+var _ File = &realFile{}
+
+// realFile implements File using the local filesystem.
+type realFile struct {
+	file *os.File
+}
+
+// MakeRealFile makes an instance of realFile.
+func MakeRealFile(f *os.File) (File, error) {
+	if f == nil {
+		return nil, errors.New("file argument may not be nil")
+	}
+	return &realFile{file: f}, nil
+}
+
+// Close closes a file.
+func (f *realFile) Close() error { return f.file.Close() }
+
+// Read reads a file's content.
+func (f *realFile) Read(p []byte) (n int, err error) { return f.file.Read(p) }
+
+// Write writes bytes to a file
+func (f *realFile) Write(p []byte) (n int, err error) { return f.file.Write(p) }
+
+// Stat returns an interface which has all the information regarding the file.
+func (f *realFile) Stat() (os.FileInfo, error) { return f.file.Stat() }

util/fs/realfs.go

@@ -0,0 +1,52 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fs
+
+import (
+	"io/ioutil"
+	"os"
+)
+
+var _ FileSystem = realFS{}
+
+// realFS implements FileSystem using the local filesystem.
+type realFS struct{}
+
+// MakeRealFS makes an instance of realFS.
+func MakeRealFS() FileSystem {
+	return realFS{}
+}
+
+// Create delegates to os.Create.
+func (realFS) Create(name string) (File, error) { return os.Create(name) }
+
+// Mkdir delegates to os.Mkdir.
+func (realFS) Mkdir(name string, perm os.FileMode) error { return os.Mkdir(name, perm) }
+
+// Open delegates to os.Open.
+func (realFS) Open(name string) (File, error) { return os.Open(name) }
+
+// Stat delegates to os.Stat.
+func (realFS) Stat(name string) (os.FileInfo, error) { return os.Stat(name) }
+
+// ReadFile delegates to ioutil.ReadFile.
+func (realFS) ReadFile(name string) ([]byte, error) { return ioutil.ReadFile(name) }
+
+// WriteFile delegates to ioutil.WriteFile with read/write permissions.
+func (realFS) WriteFile(name string, c []byte) error {
+	return ioutil.WriteFile(name, c, 0666)
+}

util/util.go

@@ -0,0 +1,80 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package util
+
+import (
+	"bytes"
+	"sort"
+
+	"github.com/ghodss/yaml"
+
+	"k8s.io/kubectl/pkg/kustomize/resource"
+	"k8s.io/kubectl/pkg/kustomize/types"
+)
+
+// Encode encodes the map `in` and output the encoded objects separated by `---`.
+func Encode(in resource.ResourceCollection) ([]byte, error) {
+	gvknList := []types.GroupVersionKindName{}
+	for gvkn := range in {
+		gvknList = append(gvknList, gvkn)
+	}
+	sort.Sort(types.ByGVKN(gvknList))
+
+	firstObj := true
+	var b []byte
+	buf := bytes.NewBuffer(b)
+	for _, gvkn := range gvknList {
+		obj := in[gvkn].Data
+		out, err := yaml.Marshal(obj)
+		if err != nil {
+			return nil, err
+		}
+		if !firstObj {
+			_, err = buf.WriteString("---\n")
+			if err != nil {
+				return nil, err
+			}
+		}
+		_, err = buf.Write(out)
+		if err != nil {
+			return nil, err
+		}
+		firstObj = false
+	}
+	return buf.Bytes(), nil
+}
+
+// WriteToDir write each object in ResourceCollection to a file named with GroupVersionKindName.
+func WriteToDir(in resource.ResourceCollection, dirName string, printer Printer) (*Directory, error) {
+	dir, err := CreateDirectory(dirName)
+	if err != nil {
+		return &Directory{}, err
+	}
+
+	for gvkn, obj := range in {
+		f, err := dir.NewFile(gvkn.String())
+		if err != nil {
+			return &Directory{}, err
+		}
+		defer f.Close()
+		err = printer.Print(obj.Data, f)
+		if err != nil {
+			return &Directory{}, err
+		}
+	}
+	return dir, nil
+}

util/util_test.go

@@ -0,0 +1,102 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package util
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kubectl/pkg/kustomize/resource"
+	"k8s.io/kubectl/pkg/kustomize/types"
+)
+
+func TestEncode(t *testing.T) {
+	encoded := []byte(`apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: cm1
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: cm2
+`)
+	input := resource.ResourceCollection{
+		{
+			GVK:  schema.GroupVersionKind{Version: "v1", Kind: "ConfigMap"},
+			Name: "cm1",
+		}: &resource.Resource{
+			Data: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "v1",
+					"kind":       "ConfigMap",
+					"metadata": map[string]interface{}{
+						"name": "cm1",
+					},
+				},
+			},
+		},
+		{
+			GVK:  schema.GroupVersionKind{Version: "v1", Kind: "ConfigMap"},
+			Name: "cm2",
+		}: &resource.Resource{
+			Data: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "v1",
+					"kind":       "ConfigMap",
+					"metadata": map[string]interface{}{
+						"name": "cm2",
+					},
+				},
+			},
+		},
+	}
+	out, err := Encode(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !reflect.DeepEqual(out, encoded) {
+		t.Fatalf("%s doesn't match expected %s", out, encoded)
+	}
+}
+
+func compareMap(m1, m2 resource.ResourceCollection) error {
+	if len(m1) != len(m2) {
+		keySet1 := []types.GroupVersionKindName{}
+		keySet2 := []types.GroupVersionKindName{}
+		for GVKn := range m1 {
+			keySet1 = append(keySet1, GVKn)
+		}
+		for GVKn := range m1 {
+			keySet2 = append(keySet2, GVKn)
+		}
+		return fmt.Errorf("maps has different number of entries: %#v doesn't equals %#v", keySet1, keySet2)
+	}
+	for GVKn, obj1 := range m1 {
+		obj2, found := m2[GVKn]
+		if !found {
+			return fmt.Errorf("%#v doesn't exist in %#v", GVKn, m2)
+		}
+		if !reflect.DeepEqual(obj1, obj2) {
+			return fmt.Errorf("%#v doesn't match %#v", obj1, obj2)
+		}
+	}
+	return nil
+}