vendor files

vendor/k8s.io/kubernetes/pkg/registry/apps/controllerrevision/BUILD

@@ -0,0 +1,56 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["strategy_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/registry/apps/controllerrevision",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/apis/apps:go_default_library",
+        "//pkg/apis/core:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/endpoints/request:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "strategy.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/registry/apps/controllerrevision",
+    deps = [
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/apis/apps:go_default_library",
+        "//pkg/apis/apps/validation:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/validation/field:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/endpoints/request:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/rest:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/storage/names:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//pkg/registry/apps/controllerrevision/storage:all-srcs",
+    ],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/registry/apps/controllerrevision/doc.go

@@ -0,0 +1,17 @@
+/*
+Copyright 2017 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 controllerrevision // import "k8s.io/kubernetes/pkg/registry/apps/controllerrevision"

vendor/k8s.io/kubernetes/pkg/registry/apps/controllerrevision/storage/BUILD

@@ -0,0 +1,52 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["storage_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/registry/apps/controllerrevision/storage",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/apis/apps:go_default_library",
+        "//pkg/apis/core:go_default_library",
+        "//pkg/registry/registrytest:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/fields:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/generic:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/generic/testing:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/storage/etcd/testing:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["storage.go"],
+    importpath = "k8s.io/kubernetes/pkg/registry/apps/controllerrevision/storage",
+    deps = [
+        "//pkg/apis/apps:go_default_library",
+        "//pkg/registry/apps/controllerrevision:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/generic:go_default_library",
+        "//vendor/k8s.io/apiserver/pkg/registry/generic/registry:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/registry/apps/controllerrevision/storage/storage.go

@@ -0,0 +1,48 @@
+/*
+Copyright 2017 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 storage
+
+import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apiserver/pkg/registry/generic"
+	genericregistry "k8s.io/apiserver/pkg/registry/generic/registry"
+	"k8s.io/kubernetes/pkg/apis/apps"
+	"k8s.io/kubernetes/pkg/registry/apps/controllerrevision"
+)
+
+// REST implements a RESTStorage for ControllerRevision
+type REST struct {
+	*genericregistry.Store
+}
+
+// NewREST returns a RESTStorage object that will work with ControllerRevision objects.
+func NewREST(optsGetter generic.RESTOptionsGetter) *REST {
+	store := &genericregistry.Store{
+		NewFunc:                  func() runtime.Object { return &apps.ControllerRevision{} },
+		NewListFunc:              func() runtime.Object { return &apps.ControllerRevisionList{} },
+		DefaultQualifiedResource: apps.Resource("controllerrevisions"),
+
+		CreateStrategy: controllerrevision.Strategy,
+		UpdateStrategy: controllerrevision.Strategy,
+		DeleteStrategy: controllerrevision.Strategy,
+	}
+	options := &generic.StoreOptions{RESTOptions: optsGetter}
+	if err := store.CompleteWithOptions(options); err != nil {
+		panic(err)
+	}
+	return &REST{store}
+}

vendor/k8s.io/kubernetes/pkg/registry/apps/controllerrevision/storage/storage_test.go

@@ -0,0 +1,183 @@
+/*
+Copyright 2017 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 storage
+
+import (
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/fields"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apiserver/pkg/registry/generic"
+	genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
+	etcdtesting "k8s.io/apiserver/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/apis/apps"
+	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/registry/registrytest"
+)
+
+func TestCreate(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Store.DestroyFunc()
+	test := genericregistrytest.New(t, storage.Store)
+	var (
+		valid       = stripObjectMeta(newControllerRevision("validname", metav1.NamespaceDefault, newObject(), 0))
+		badRevision = stripObjectMeta(newControllerRevision("validname", "validns", newObject(), -1))
+		emptyName   = stripObjectMeta(newControllerRevision("", "validns", newObject(), 0))
+		invalidName = stripObjectMeta(newControllerRevision("NoUppercaseOrSpecialCharsLike=Equals", "validns", newObject(), 0))
+		emptyNs     = stripObjectMeta(newControllerRevision("validname", "", newObject(), 100))
+		invalidNs   = stripObjectMeta(newControllerRevision("validname", "NoUppercaseOrSpecialCharsLike=Equals", newObject(), 100))
+		nilData     = stripObjectMeta(newControllerRevision("validname", "validns", nil, 0))
+	)
+	test.TestCreate(
+		valid,
+		badRevision,
+		emptyName,
+		invalidName,
+		emptyNs,
+		invalidNs,
+		nilData)
+}
+
+func TestUpdate(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Store.DestroyFunc()
+	test := genericregistrytest.New(t, storage.Store)
+
+	addLabel := func(obj runtime.Object) runtime.Object {
+		rev := obj.(*apps.ControllerRevision)
+		update := &apps.ControllerRevision{
+			ObjectMeta: rev.ObjectMeta,
+			Data:       rev.Data,
+			Revision:   rev.Revision,
+		}
+		update.ObjectMeta.Labels = map[string]string{"foo": "bar"}
+		return update
+	}
+
+	updateData := func(obj runtime.Object) runtime.Object {
+		rev := obj.(*apps.ControllerRevision)
+		modified := newObject()
+		ss := modified.(*apps.StatefulSet)
+		ss.Name = "cde"
+		update := &apps.ControllerRevision{
+			ObjectMeta: rev.ObjectMeta,
+			Data:       ss,
+			Revision:   rev.Revision + 1,
+		}
+		return update
+	}
+
+	test.TestUpdate(stripObjectMeta(newControllerRevision("validname", metav1.NamespaceDefault, newObject(), 0)),
+		addLabel,
+		updateData)
+}
+
+func TestGet(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Store.DestroyFunc()
+	test := genericregistrytest.New(t, storage.Store)
+	test.TestGet(newControllerRevision("valid", metav1.NamespaceDefault, newObject(), 0))
+}
+
+func TestList(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Store.DestroyFunc()
+	test := genericregistrytest.New(t, storage.Store)
+	test.TestList(newControllerRevision("valid", metav1.NamespaceDefault, newObject(), 0))
+}
+
+func TestDelete(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Store.DestroyFunc()
+	test := genericregistrytest.New(t, storage.Store)
+	test.TestDelete(newControllerRevision("valid", metav1.NamespaceDefault, newObject(), 0))
+}
+
+func TestWatch(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Store.DestroyFunc()
+	test := genericregistrytest.New(t, storage.Store)
+	test.TestWatch(
+		newControllerRevision("valid", metav1.NamespaceDefault, newObject(), 0),
+		[]labels.Set{
+			{"foo": "bar"},
+		},
+		[]labels.Set{
+			{"hoo": "baz"},
+		},
+		[]fields.Set{
+			{"metadata.name": "valid"},
+		},
+		[]fields.Set{
+			{"metadata.name": "nomatch"},
+		},
+	)
+}
+
+func newControllerRevision(name, namespace string, data runtime.Object, revision int64) *apps.ControllerRevision {
+	return &apps.ControllerRevision{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+			Labels:    map[string]string{"foo": "bar"},
+		},
+		Data:     data,
+		Revision: revision,
+	}
+}
+
+func stripObjectMeta(revision *apps.ControllerRevision) *apps.ControllerRevision {
+	revision.ObjectMeta = metav1.ObjectMeta{}
+	return revision
+}
+
+func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
+	etcdStorage, server := registrytest.NewEtcdStorage(t, apps.GroupName)
+	restOptions := generic.RESTOptions{
+		StorageConfig:           etcdStorage,
+		Decorator:               generic.UndecoratedStorage,
+		DeleteCollectionWorkers: 1,
+		ResourcePrefix:          "controllerrevisions"}
+	storage := NewREST(restOptions)
+	return storage, server
+}
+
+func newObject() runtime.Object {
+	return &apps.StatefulSet{
+		ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
+		Spec: apps.StatefulSetSpec{
+			Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}},
+			Template: api.PodTemplateSpec{
+				Spec: api.PodSpec{
+					RestartPolicy: api.RestartPolicyAlways,
+					DNSPolicy:     api.DNSClusterFirst,
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{"foo": "bar"},
+				},
+			},
+		},
+	}
+}

vendor/k8s.io/kubernetes/pkg/registry/apps/controllerrevision/strategy.go

@@ -0,0 +1,79 @@
+/*
+Copyright 2017 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 controllerrevision
+
+import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
+	"k8s.io/apiserver/pkg/registry/rest"
+	"k8s.io/apiserver/pkg/storage/names"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	"k8s.io/kubernetes/pkg/apis/apps"
+	"k8s.io/kubernetes/pkg/apis/apps/validation"
+)
+
+// strategy implements behavior for ConfigMap objects
+type strategy struct {
+	runtime.ObjectTyper
+	names.NameGenerator
+}
+
+// Strategy is the default logic that applies when creating and updating ControllerRevision
+// objects via the REST API.
+var Strategy = strategy{legacyscheme.Scheme, names.SimpleNameGenerator}
+
+// Strategy should implement rest.RESTCreateStrategy
+var _ rest.RESTCreateStrategy = Strategy
+
+// Strategy should implement rest.RESTUpdateStrategy
+var _ rest.RESTUpdateStrategy = Strategy
+
+func (strategy) NamespaceScoped() bool {
+	return true
+}
+
+func (strategy) Canonicalize(obj runtime.Object) {
+}
+
+func (strategy) AllowCreateOnUpdate() bool {
+	return false
+}
+
+func (strategy) PrepareForCreate(ctx genericapirequest.Context, obj runtime.Object) {
+	_ = obj.(*apps.ControllerRevision)
+}
+
+func (strategy) Validate(ctx genericapirequest.Context, obj runtime.Object) field.ErrorList {
+	revision := obj.(*apps.ControllerRevision)
+
+	return validation.ValidateControllerRevision(revision)
+}
+
+func (strategy) PrepareForUpdate(ctx genericapirequest.Context, newObj, oldObj runtime.Object) {
+	_ = oldObj.(*apps.ControllerRevision)
+	_ = newObj.(*apps.ControllerRevision)
+}
+
+func (strategy) AllowUnconditionalUpdate() bool {
+	return true
+}
+
+func (strategy) ValidateUpdate(ctx genericapirequest.Context, newObj, oldObj runtime.Object) field.ErrorList {
+	oldRevision, newRevision := oldObj.(*apps.ControllerRevision), newObj.(*apps.ControllerRevision)
+	return validation.ValidateControllerRevisionUpdate(newRevision, oldRevision)
+}

vendor/k8s.io/kubernetes/pkg/registry/apps/controllerrevision/strategy_test.go

@@ -0,0 +1,157 @@
+/*
+Copyright 2017 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 controllerrevision
+
+import (
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
+	"k8s.io/kubernetes/pkg/apis/apps"
+	api "k8s.io/kubernetes/pkg/apis/core"
+)
+
+func TestStrategy_NamespaceScoped(t *testing.T) {
+	if !Strategy.NamespaceScoped() {
+		t.Error("ControllerRevision strategy must be namespace scoped")
+	}
+}
+
+func TestStrategy_AllowCreateOnUpdate(t *testing.T) {
+	if Strategy.AllowCreateOnUpdate() {
+		t.Error("ControllerRevision should not be created on update")
+	}
+}
+
+func TestStrategy_Validate(t *testing.T) {
+	ctx := genericapirequest.NewDefaultContext()
+	var (
+		valid       = newControllerRevision("validname", "validns", newObject(), 0)
+		badRevision = newControllerRevision("validname", "validns", newObject(), -1)
+		emptyName   = newControllerRevision("", "validns", newObject(), 0)
+		invalidName = newControllerRevision("NoUppercaseOrSpecialCharsLike=Equals", "validns", newObject(), 0)
+		emptyNs     = newControllerRevision("validname", "", newObject(), 100)
+		invalidNs   = newControllerRevision("validname", "NoUppercaseOrSpecialCharsLike=Equals", newObject(), 100)
+		nilData     = newControllerRevision("validname", "validns", nil, 0)
+	)
+
+	tests := map[string]struct {
+		history *apps.ControllerRevision
+		isValid bool
+	}{
+		"valid":             {valid, true},
+		"negative revision": {badRevision, false},
+		"empty name":        {emptyName, false},
+		"invalid name":      {invalidName, false},
+		"empty namespace":   {emptyNs, false},
+		"invalid namespace": {invalidNs, false},
+		"nil data":          {nilData, false},
+	}
+
+	for name, tc := range tests {
+		errs := Strategy.Validate(ctx, tc.history)
+		if tc.isValid && len(errs) > 0 {
+			t.Errorf("%v: unexpected error: %v", name, errs)
+		}
+		if !tc.isValid && len(errs) == 0 {
+			t.Errorf("%v: unexpected non-error", name)
+		}
+	}
+}
+
+func TestStrategy_ValidateUpdate(t *testing.T) {
+	ctx := genericapirequest.NewDefaultContext()
+	var (
+		valid       = newControllerRevision("validname", "validns", newObject(), 0)
+		changedData = newControllerRevision("validname", "validns",
+			func() runtime.Object {
+				modified := newObject()
+				ss := modified.(*apps.StatefulSet)
+				ss.Name = "cde"
+				return modified
+			}(), 0)
+		changedRevision = newControllerRevision("validname", "validns", newObject(), 1)
+	)
+
+	cases := []struct {
+		name       string
+		newHistory *apps.ControllerRevision
+		oldHistory *apps.ControllerRevision
+		isValid    bool
+	}{
+		{
+			name:       "valid",
+			newHistory: valid,
+			oldHistory: valid,
+			isValid:    true,
+		},
+		{
+			name:       "changed data",
+			newHistory: changedData,
+			oldHistory: valid,
+			isValid:    false,
+		},
+		{
+			name:       "changed revision",
+			newHistory: changedRevision,
+			oldHistory: valid,
+			isValid:    true,
+		},
+	}
+
+	for _, tc := range cases {
+		errs := Strategy.ValidateUpdate(ctx, tc.newHistory, tc.oldHistory)
+		if tc.isValid && len(errs) > 0 {
+			t.Errorf("%v: unexpected error: %v", tc.name, errs)
+		}
+		if !tc.isValid && len(errs) == 0 {
+			t.Errorf("%v: unexpected non-error", tc.name)
+		}
+	}
+}
+
+func newControllerRevision(name, namespace string, data runtime.Object, revision int64) *apps.ControllerRevision {
+	return &apps.ControllerRevision{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:            name,
+			Namespace:       namespace,
+			ResourceVersion: "1",
+			Labels:          map[string]string{"foo": "bar"},
+		},
+		Data:     data,
+		Revision: revision,
+	}
+}
+
+func newObject() runtime.Object {
+	return &apps.StatefulSet{
+		ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
+		Spec: apps.StatefulSetSpec{
+			Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}},
+			Template: api.PodTemplateSpec{
+				Spec: api.PodSpec{
+					RestartPolicy: api.RestartPolicyAlways,
+					DNSPolicy:     api.DNSClusterFirst,
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{"foo": "bar"},
+				},
+			},
+		},
+	}
+}