Add glide.yaml and vendor deps

vendor/k8s.io/kubernetes/pkg/registry/extensions/deployment/BUILD

@@ -0,0 +1,49 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "registry.go",
+        "strategy.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/rest:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/apis/extensions/validation:go_default_library",
+        "//pkg/apis/meta/v1:go_default_library",
+        "//pkg/controller/deployment/util:go_default_library",
+        "//pkg/fields:go_default_library",
+        "//pkg/labels:go_default_library",
+        "//pkg/registry/generic:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/storage:go_default_library",
+        "//pkg/util/validation/field:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["strategy_test.go"],
+    library = "go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/testapi:go_default_library",
+        "//pkg/api/testing:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/runtime:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/registry/extensions/deployment/doc.go

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

vendor/k8s.io/kubernetes/pkg/registry/extensions/deployment/etcd/BUILD

@@ -0,0 +1,55 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["etcd.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/errors:go_default_library",
+        "//pkg/api/errors/storage:go_default_library",
+        "//pkg/api/rest:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/apis/extensions/validation:go_default_library",
+        "//pkg/apis/meta/v1:go_default_library",
+        "//pkg/registry/cachesize:go_default_library",
+        "//pkg/registry/extensions/deployment:go_default_library",
+        "//pkg/registry/generic:go_default_library",
+        "//pkg/registry/generic/registry:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/storage:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["etcd_test.go"],
+    library = "go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/errors:go_default_library",
+        "//pkg/api/errors/storage:go_default_library",
+        "//pkg/api/rest:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/apis/meta/v1:go_default_library",
+        "//pkg/fields:go_default_library",
+        "//pkg/labels:go_default_library",
+        "//pkg/registry/generic:go_default_library",
+        "//pkg/registry/registrytest:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/storage/etcd/testing:go_default_library",
+        "//pkg/util/diff:go_default_library",
+        "//pkg/util/intstr:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/registry/extensions/deployment/etcd/etcd.go

@@ -0,0 +1,288 @@
+/*
+Copyright 2015 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 etcd
+
+import (
+	"fmt"
+	"net/http"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/errors"
+	storeerr "k8s.io/kubernetes/pkg/api/errors/storage"
+	"k8s.io/kubernetes/pkg/api/rest"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	extvalidation "k8s.io/kubernetes/pkg/apis/extensions/validation"
+	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/registry/cachesize"
+	"k8s.io/kubernetes/pkg/registry/extensions/deployment"
+	"k8s.io/kubernetes/pkg/registry/generic"
+	genericregistry "k8s.io/kubernetes/pkg/registry/generic/registry"
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/storage"
+)
+
+// DeploymentStorage includes dummy storage for Deployments and for Scale subresource.
+type DeploymentStorage struct {
+	Deployment *REST
+	Status     *StatusREST
+	Scale      *ScaleREST
+	Rollback   *RollbackREST
+}
+
+func NewStorage(opts generic.RESTOptions) DeploymentStorage {
+	deploymentRest, deploymentStatusRest, deploymentRollbackRest := NewREST(opts)
+	deploymentRegistry := deployment.NewRegistry(deploymentRest)
+
+	return DeploymentStorage{
+		Deployment: deploymentRest,
+		Status:     deploymentStatusRest,
+		Scale:      &ScaleREST{registry: deploymentRegistry},
+		Rollback:   deploymentRollbackRest,
+	}
+}
+
+type REST struct {
+	*genericregistry.Store
+}
+
+// NewREST returns a RESTStorage object that will work against deployments.
+func NewREST(opts generic.RESTOptions) (*REST, *StatusREST, *RollbackREST) {
+	prefix := "/" + opts.ResourcePrefix
+
+	newListFunc := func() runtime.Object { return &extensions.DeploymentList{} }
+	storageInterface, dFunc := opts.Decorator(
+		opts.StorageConfig,
+		cachesize.GetWatchCacheSizeByResource(cachesize.Deployments),
+		&extensions.Deployment{},
+		prefix,
+		deployment.Strategy,
+		newListFunc,
+		deployment.GetAttrs,
+		storage.NoTriggerPublisher,
+	)
+
+	store := &genericregistry.Store{
+		NewFunc: func() runtime.Object { return &extensions.Deployment{} },
+		// NewListFunc returns an object capable of storing results of an etcd list.
+		NewListFunc: newListFunc,
+		// Produces a path that etcd understands, to the root of the resource
+		// by combining the namespace in the context with the given prefix.
+		KeyRootFunc: func(ctx api.Context) string {
+			return genericregistry.NamespaceKeyRootFunc(ctx, prefix)
+		},
+		// Produces a path that etcd understands, to the resource by combining
+		// the namespace in the context with the given prefix.
+		KeyFunc: func(ctx api.Context, name string) (string, error) {
+			return genericregistry.NamespaceKeyFunc(ctx, prefix, name)
+		},
+		// Retrieve the name field of a deployment.
+		ObjectNameFunc: func(obj runtime.Object) (string, error) {
+			return obj.(*extensions.Deployment).Name, nil
+		},
+		// Used to match objects based on labels/fields for list.
+		PredicateFunc:           deployment.MatchDeployment,
+		QualifiedResource:       extensions.Resource("deployments"),
+		EnableGarbageCollection: opts.EnableGarbageCollection,
+		DeleteCollectionWorkers: opts.DeleteCollectionWorkers,
+
+		// Used to validate deployment creation.
+		CreateStrategy: deployment.Strategy,
+
+		// Used to validate deployment updates.
+		UpdateStrategy: deployment.Strategy,
+		DeleteStrategy: deployment.Strategy,
+
+		Storage:     storageInterface,
+		DestroyFunc: dFunc,
+	}
+	statusStore := *store
+	statusStore.UpdateStrategy = deployment.StatusStrategy
+	return &REST{store}, &StatusREST{store: &statusStore}, &RollbackREST{store: store}
+}
+
+// StatusREST implements the REST endpoint for changing the status of a deployment
+type StatusREST struct {
+	store *genericregistry.Store
+}
+
+func (r *StatusREST) New() runtime.Object {
+	return &extensions.Deployment{}
+}
+
+// Get retrieves the object from the storage. It is required to support Patch.
+func (r *StatusREST) Get(ctx api.Context, name string) (runtime.Object, error) {
+	return r.store.Get(ctx, name)
+}
+
+// Update alters the status subset of an object.
+func (r *StatusREST) Update(ctx api.Context, name string, objInfo rest.UpdatedObjectInfo) (runtime.Object, bool, error) {
+	return r.store.Update(ctx, name, objInfo)
+}
+
+// RollbackREST implements the REST endpoint for initiating the rollback of a deployment
+type RollbackREST struct {
+	store *genericregistry.Store
+}
+
+// New creates a rollback
+func (r *RollbackREST) New() runtime.Object {
+	return &extensions.DeploymentRollback{}
+}
+
+var _ = rest.Creater(&RollbackREST{})
+
+func (r *RollbackREST) Create(ctx api.Context, obj runtime.Object) (runtime.Object, error) {
+	rollback, ok := obj.(*extensions.DeploymentRollback)
+	if !ok {
+		return nil, errors.NewBadRequest(fmt.Sprintf("not a DeploymentRollback: %#v", obj))
+	}
+
+	if errs := extvalidation.ValidateDeploymentRollback(rollback); len(errs) != 0 {
+		return nil, errors.NewInvalid(extensions.Kind("DeploymentRollback"), rollback.Name, errs)
+	}
+
+	// Update the Deployment with information in DeploymentRollback to trigger rollback
+	err := r.rollbackDeployment(ctx, rollback.Name, &rollback.RollbackTo, rollback.UpdatedAnnotations)
+	if err != nil {
+		return nil, err
+	}
+	return &metav1.Status{
+		Message: fmt.Sprintf("rollback request for deployment %q succeeded", rollback.Name),
+		Code:    http.StatusOK,
+	}, nil
+}
+
+func (r *RollbackREST) rollbackDeployment(ctx api.Context, deploymentID string, config *extensions.RollbackConfig, annotations map[string]string) error {
+	if _, err := r.setDeploymentRollback(ctx, deploymentID, config, annotations); err != nil {
+		err = storeerr.InterpretGetError(err, extensions.Resource("deployments"), deploymentID)
+		err = storeerr.InterpretUpdateError(err, extensions.Resource("deployments"), deploymentID)
+		if _, ok := err.(*errors.StatusError); !ok {
+			err = errors.NewInternalError(err)
+		}
+		return err
+	}
+	return nil
+}
+
+func (r *RollbackREST) setDeploymentRollback(ctx api.Context, deploymentID string, config *extensions.RollbackConfig, annotations map[string]string) (*extensions.Deployment, error) {
+	dKey, err := r.store.KeyFunc(ctx, deploymentID)
+	if err != nil {
+		return nil, err
+	}
+	var finalDeployment *extensions.Deployment
+	err = r.store.Storage.GuaranteedUpdate(ctx, dKey, &extensions.Deployment{}, false, nil, storage.SimpleUpdate(func(obj runtime.Object) (runtime.Object, error) {
+		d, ok := obj.(*extensions.Deployment)
+		if !ok {
+			return nil, fmt.Errorf("unexpected object: %#v", obj)
+		}
+		if d.Annotations == nil {
+			d.Annotations = make(map[string]string)
+		}
+		for k, v := range annotations {
+			d.Annotations[k] = v
+		}
+		d.Spec.RollbackTo = config
+		finalDeployment = d
+		return d, nil
+	}))
+	return finalDeployment, err
+}
+
+type ScaleREST struct {
+	registry deployment.Registry
+}
+
+// ScaleREST implements Patcher
+var _ = rest.Patcher(&ScaleREST{})
+
+// New creates a new Scale object
+func (r *ScaleREST) New() runtime.Object {
+	return &extensions.Scale{}
+}
+
+func (r *ScaleREST) Get(ctx api.Context, name string) (runtime.Object, error) {
+	deployment, err := r.registry.GetDeployment(ctx, name)
+	if err != nil {
+		return nil, errors.NewNotFound(extensions.Resource("deployments/scale"), name)
+	}
+	scale, err := scaleFromDeployment(deployment)
+	if err != nil {
+		return nil, errors.NewBadRequest(fmt.Sprintf("%v", err))
+	}
+	return scale, nil
+}
+
+func (r *ScaleREST) Update(ctx api.Context, name string, objInfo rest.UpdatedObjectInfo) (runtime.Object, bool, error) {
+	deployment, err := r.registry.GetDeployment(ctx, name)
+	if err != nil {
+		return nil, false, errors.NewNotFound(extensions.Resource("deployments/scale"), name)
+	}
+
+	oldScale, err := scaleFromDeployment(deployment)
+	if err != nil {
+		return nil, false, err
+	}
+
+	obj, err := objInfo.UpdatedObject(ctx, oldScale)
+	if err != nil {
+		return nil, false, err
+	}
+	if obj == nil {
+		return nil, false, errors.NewBadRequest(fmt.Sprintf("nil update passed to Scale"))
+	}
+	scale, ok := obj.(*extensions.Scale)
+	if !ok {
+		return nil, false, errors.NewBadRequest(fmt.Sprintf("expected input object type to be Scale, but %T", obj))
+	}
+
+	if errs := extvalidation.ValidateScale(scale); len(errs) > 0 {
+		return nil, false, errors.NewInvalid(extensions.Kind("Scale"), name, errs)
+	}
+
+	deployment.Spec.Replicas = scale.Spec.Replicas
+	deployment.ResourceVersion = scale.ResourceVersion
+	deployment, err = r.registry.UpdateDeployment(ctx, deployment)
+	if err != nil {
+		return nil, false, err
+	}
+	newScale, err := scaleFromDeployment(deployment)
+	if err != nil {
+		return nil, false, errors.NewBadRequest(fmt.Sprintf("%v", err))
+	}
+	return newScale, false, nil
+}
+
+// scaleFromDeployment returns a scale subresource for a deployment.
+func scaleFromDeployment(deployment *extensions.Deployment) (*extensions.Scale, error) {
+	return &extensions.Scale{
+		// TODO: Create a variant of ObjectMeta type that only contains the fields below.
+		ObjectMeta: api.ObjectMeta{
+			Name:              deployment.Name,
+			Namespace:         deployment.Namespace,
+			UID:               deployment.UID,
+			ResourceVersion:   deployment.ResourceVersion,
+			CreationTimestamp: deployment.CreationTimestamp,
+		},
+		Spec: extensions.ScaleSpec{
+			Replicas: deployment.Spec.Replicas,
+		},
+		Status: extensions.ScaleStatus{
+			Replicas: deployment.Status.Replicas,
+			Selector: deployment.Spec.Selector,
+		},
+	}, nil
+}

vendor/k8s.io/kubernetes/pkg/registry/extensions/deployment/etcd/etcd_test.go

@@ -0,0 +1,387 @@
+/*
+Copyright 2015 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 etcd
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/errors"
+	storeerr "k8s.io/kubernetes/pkg/api/errors/storage"
+	"k8s.io/kubernetes/pkg/api/rest"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/fields"
+	"k8s.io/kubernetes/pkg/labels"
+	"k8s.io/kubernetes/pkg/registry/generic"
+	"k8s.io/kubernetes/pkg/registry/registrytest"
+	"k8s.io/kubernetes/pkg/runtime"
+	etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/util/diff"
+	"k8s.io/kubernetes/pkg/util/intstr"
+)
+
+const defaultReplicas = 100
+
+func newStorage(t *testing.T) (*DeploymentStorage, *etcdtesting.EtcdTestServer) {
+	etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName)
+	restOptions := generic.RESTOptions{StorageConfig: etcdStorage, Decorator: generic.UndecoratedStorage, DeleteCollectionWorkers: 1, ResourcePrefix: "deployments"}
+	deploymentStorage := NewStorage(restOptions)
+	return &deploymentStorage, server
+}
+
+var namespace = "foo-namespace"
+var name = "foo-deployment"
+
+func validNewDeployment() *extensions.Deployment {
+	return &extensions.Deployment{
+		ObjectMeta: api.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+		Spec: extensions.DeploymentSpec{
+			Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"a": "b"}},
+			Strategy: extensions.DeploymentStrategy{
+				Type: extensions.RollingUpdateDeploymentStrategyType,
+				RollingUpdate: &extensions.RollingUpdateDeployment{
+					MaxSurge:       intstr.FromInt(1),
+					MaxUnavailable: intstr.FromInt(1),
+				},
+			},
+			Template: api.PodTemplateSpec{
+				ObjectMeta: api.ObjectMeta{
+					Labels: map[string]string{"a": "b"},
+				},
+				Spec: api.PodSpec{
+					Containers: []api.Container{
+						{
+							Name:            "test",
+							Image:           "test_image",
+							ImagePullPolicy: api.PullIfNotPresent,
+						},
+					},
+					RestartPolicy: api.RestartPolicyAlways,
+					DNSPolicy:     api.DNSClusterFirst,
+				},
+			},
+			Replicas: 7,
+		},
+		Status: extensions.DeploymentStatus{
+			Replicas: 5,
+		},
+	}
+}
+
+var validDeployment = *validNewDeployment()
+
+func TestCreate(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Deployment.Store.DestroyFunc()
+	test := registrytest.New(t, storage.Deployment.Store)
+	deployment := validNewDeployment()
+	deployment.ObjectMeta = api.ObjectMeta{}
+	test.TestCreate(
+		// valid
+		deployment,
+		// invalid (invalid selector)
+		&extensions.Deployment{
+			Spec: extensions.DeploymentSpec{
+				Selector: &metav1.LabelSelector{MatchLabels: map[string]string{}},
+				Template: validDeployment.Spec.Template,
+			},
+		},
+	)
+}
+
+func TestUpdate(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Deployment.Store.DestroyFunc()
+	test := registrytest.New(t, storage.Deployment.Store)
+	test.TestUpdate(
+		// valid
+		validNewDeployment(),
+		// updateFunc
+		func(obj runtime.Object) runtime.Object {
+			object := obj.(*extensions.Deployment)
+			object.Spec.Template.Spec.NodeSelector = map[string]string{"c": "d"}
+			return object
+		},
+		// invalid updateFunc
+		func(obj runtime.Object) runtime.Object {
+			object := obj.(*extensions.Deployment)
+			object.Name = ""
+			return object
+		},
+		func(obj runtime.Object) runtime.Object {
+			object := obj.(*extensions.Deployment)
+			object.Spec.Template.Spec.RestartPolicy = api.RestartPolicyOnFailure
+			return object
+		},
+		func(obj runtime.Object) runtime.Object {
+			object := obj.(*extensions.Deployment)
+			object.Spec.Selector = &metav1.LabelSelector{MatchLabels: map[string]string{}}
+			return object
+		},
+	)
+}
+
+func TestDelete(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Deployment.Store.DestroyFunc()
+	test := registrytest.New(t, storage.Deployment.Store)
+	test.TestDelete(validNewDeployment())
+}
+
+func TestGet(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Deployment.Store.DestroyFunc()
+	test := registrytest.New(t, storage.Deployment.Store)
+	test.TestGet(validNewDeployment())
+}
+
+func TestList(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Deployment.Store.DestroyFunc()
+	test := registrytest.New(t, storage.Deployment.Store)
+	test.TestList(validNewDeployment())
+}
+
+func TestWatch(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Deployment.Store.DestroyFunc()
+	test := registrytest.New(t, storage.Deployment.Store)
+	test.TestWatch(
+		validNewDeployment(),
+		// matching labels
+		[]labels.Set{},
+		// not matching labels
+		[]labels.Set{
+			{"a": "c"},
+			{"foo": "bar"},
+		},
+		// matching fields
+		[]fields.Set{
+			{"metadata.name": name},
+		},
+		// not matchin fields
+		[]fields.Set{
+			{"metadata.name": "bar"},
+			{"name": name},
+		},
+	)
+}
+
+func TestScaleGet(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Deployment.Store.DestroyFunc()
+	var deployment extensions.Deployment
+	ctx := api.WithNamespace(api.NewContext(), namespace)
+	key := "/deployments/" + namespace + "/" + name
+	if err := storage.Deployment.Storage.Create(ctx, key, &validDeployment, &deployment, 0); err != nil {
+		t.Fatalf("error setting new deployment (key: %s) %v: %v", key, validDeployment, err)
+	}
+
+	want := &extensions.Scale{
+		ObjectMeta: api.ObjectMeta{
+			Name:              name,
+			Namespace:         namespace,
+			UID:               deployment.UID,
+			ResourceVersion:   deployment.ResourceVersion,
+			CreationTimestamp: deployment.CreationTimestamp,
+		},
+		Spec: extensions.ScaleSpec{
+			Replicas: validDeployment.Spec.Replicas,
+		},
+		Status: extensions.ScaleStatus{
+			Replicas: validDeployment.Status.Replicas,
+			Selector: validDeployment.Spec.Selector,
+		},
+	}
+	obj, err := storage.Scale.Get(ctx, name)
+	if err != nil {
+		t.Fatalf("error fetching scale for %s: %v", name, err)
+	}
+	got := obj.(*extensions.Scale)
+	if !api.Semantic.DeepEqual(want, got) {
+		t.Errorf("unexpected scale: %s", diff.ObjectDiff(want, got))
+	}
+}
+
+func TestScaleUpdate(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Deployment.Store.DestroyFunc()
+	var deployment extensions.Deployment
+	ctx := api.WithNamespace(api.NewContext(), namespace)
+	key := "/deployments/" + namespace + "/" + name
+	if err := storage.Deployment.Storage.Create(ctx, key, &validDeployment, &deployment, 0); err != nil {
+		t.Fatalf("error setting new deployment (key: %s) %v: %v", key, validDeployment, err)
+	}
+	replicas := int32(12)
+	update := extensions.Scale{
+		ObjectMeta: api.ObjectMeta{Name: name, Namespace: namespace},
+		Spec: extensions.ScaleSpec{
+			Replicas: replicas,
+		},
+	}
+
+	if _, _, err := storage.Scale.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update, api.Scheme)); err != nil {
+		t.Fatalf("error updating scale %v: %v", update, err)
+	}
+	obj, err := storage.Scale.Get(ctx, name)
+	if err != nil {
+		t.Fatalf("error fetching scale for %s: %v", name, err)
+	}
+	scale := obj.(*extensions.Scale)
+	if scale.Spec.Replicas != replicas {
+		t.Errorf("wrong replicas count expected: %d got: %d", replicas, deployment.Spec.Replicas)
+	}
+
+	update.ResourceVersion = deployment.ResourceVersion
+	update.Spec.Replicas = 15
+
+	if _, _, err = storage.Scale.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update, api.Scheme)); err != nil && !errors.IsConflict(err) {
+		t.Fatalf("unexpected error, expecting an update conflict but got %v", err)
+	}
+}
+
+func TestStatusUpdate(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Deployment.Store.DestroyFunc()
+	ctx := api.WithNamespace(api.NewContext(), namespace)
+	key := "/deployments/" + namespace + "/" + name
+	if err := storage.Deployment.Storage.Create(ctx, key, &validDeployment, nil, 0); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	update := extensions.Deployment{
+		ObjectMeta: validDeployment.ObjectMeta,
+		Spec: extensions.DeploymentSpec{
+			Replicas: defaultReplicas,
+		},
+		Status: extensions.DeploymentStatus{
+			Replicas: defaultReplicas,
+		},
+	}
+
+	if _, _, err := storage.Status.Update(ctx, update.Name, rest.DefaultUpdatedObjectInfo(&update, api.Scheme)); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	obj, err := storage.Deployment.Get(ctx, name)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	deployment := obj.(*extensions.Deployment)
+	if deployment.Spec.Replicas != 7 {
+		t.Errorf("we expected .spec.replicas to not be updated but it was updated to %v", deployment.Spec.Replicas)
+	}
+	if deployment.Status.Replicas != defaultReplicas {
+		t.Errorf("we expected .status.replicas to be updated to %d but it was %v", defaultReplicas, deployment.Status.Replicas)
+	}
+}
+
+func TestEtcdCreateDeploymentRollback(t *testing.T) {
+	ctx := api.WithNamespace(api.NewContext(), namespace)
+
+	testCases := map[string]struct {
+		rollback extensions.DeploymentRollback
+		errOK    func(error) bool
+	}{
+		"normal": {
+			rollback: extensions.DeploymentRollback{
+				Name:               name,
+				UpdatedAnnotations: map[string]string{},
+				RollbackTo:         extensions.RollbackConfig{Revision: 1},
+			},
+			errOK: func(err error) bool { return err == nil },
+		},
+		"noAnnotation": {
+			rollback: extensions.DeploymentRollback{
+				Name:       name,
+				RollbackTo: extensions.RollbackConfig{Revision: 1},
+			},
+			errOK: func(err error) bool { return err == nil },
+		},
+		"noName": {
+			rollback: extensions.DeploymentRollback{
+				UpdatedAnnotations: map[string]string{},
+				RollbackTo:         extensions.RollbackConfig{Revision: 1},
+			},
+			errOK: func(err error) bool { return err != nil },
+		},
+	}
+	for k, test := range testCases {
+		storage, server := newStorage(t)
+		rollbackStorage := storage.Rollback
+
+		if _, err := storage.Deployment.Create(ctx, validNewDeployment()); err != nil {
+			t.Fatalf("%s: unexpected error: %v", k, err)
+		}
+		if _, err := rollbackStorage.Create(ctx, &test.rollback); !test.errOK(err) {
+			t.Errorf("%s: unexpected error: %v", k, err)
+		} else if err == nil {
+			// If rollback succeeded, verify Rollback field of deployment
+			d, err := storage.Deployment.Get(ctx, validNewDeployment().ObjectMeta.Name)
+			if err != nil {
+				t.Errorf("%s: unexpected error: %v", k, err)
+			} else if !reflect.DeepEqual(*d.(*extensions.Deployment).Spec.RollbackTo, test.rollback.RollbackTo) {
+				t.Errorf("%s: expected: %v, got: %v", k, *d.(*extensions.Deployment).Spec.RollbackTo, test.rollback.RollbackTo)
+			}
+		}
+		storage.Deployment.Store.DestroyFunc()
+		server.Terminate(t)
+	}
+}
+
+// Ensure that when a deploymentRollback is created for a deployment that has already been deleted
+// by the API server, API server returns not-found error.
+func TestEtcdCreateDeploymentRollbackNoDeployment(t *testing.T) {
+	storage, server := newStorage(t)
+	defer server.Terminate(t)
+	defer storage.Deployment.Store.DestroyFunc()
+	rollbackStorage := storage.Rollback
+	ctx := api.WithNamespace(api.NewContext(), namespace)
+
+	_, err := rollbackStorage.Create(ctx, &extensions.DeploymentRollback{
+		Name:               name,
+		UpdatedAnnotations: map[string]string{},
+		RollbackTo:         extensions.RollbackConfig{Revision: 1},
+	})
+	if err == nil {
+		t.Fatalf("Expected not-found-error but got nothing")
+	}
+	if !errors.IsNotFound(storeerr.InterpretGetError(err, extensions.Resource("deployments"), name)) {
+		t.Fatalf("Unexpected error returned: %#v", err)
+	}
+
+	_, err = storage.Deployment.Get(ctx, name)
+	if err == nil {
+		t.Fatalf("Expected not-found-error but got nothing")
+	}
+	if !errors.IsNotFound(storeerr.InterpretGetError(err, extensions.Resource("deployments"), name)) {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+}

vendor/k8s.io/kubernetes/pkg/registry/extensions/deployment/registry.go

@@ -0,0 +1,84 @@
+/*
+Copyright 2014 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 deployment
+
+import (
+	"fmt"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/rest"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+)
+
+// Registry is an interface for things that know how to store Deployments.
+type Registry interface {
+	ListDeployments(ctx api.Context, options *api.ListOptions) (*extensions.DeploymentList, error)
+	GetDeployment(ctx api.Context, deploymentID string) (*extensions.Deployment, error)
+	CreateDeployment(ctx api.Context, deployment *extensions.Deployment) (*extensions.Deployment, error)
+	UpdateDeployment(ctx api.Context, deployment *extensions.Deployment) (*extensions.Deployment, error)
+	DeleteDeployment(ctx api.Context, deploymentID string) error
+}
+
+// storage puts strong typing around storage calls
+type storage struct {
+	rest.StandardStorage
+}
+
+// NewRegistry returns a new Registry interface for the given Storage. Any mismatched types will panic.
+func NewRegistry(s rest.StandardStorage) Registry {
+	return &storage{s}
+}
+
+func (s *storage) ListDeployments(ctx api.Context, options *api.ListOptions) (*extensions.DeploymentList, error) {
+	if options != nil && options.FieldSelector != nil && !options.FieldSelector.Empty() {
+		return nil, fmt.Errorf("field selector not supported yet")
+	}
+	obj, err := s.List(ctx, options)
+	if err != nil {
+		return nil, err
+	}
+	return obj.(*extensions.DeploymentList), err
+}
+
+func (s *storage) GetDeployment(ctx api.Context, deploymentID string) (*extensions.Deployment, error) {
+	obj, err := s.Get(ctx, deploymentID)
+	if err != nil {
+		return nil, err
+	}
+	return obj.(*extensions.Deployment), nil
+}
+
+func (s *storage) CreateDeployment(ctx api.Context, deployment *extensions.Deployment) (*extensions.Deployment, error) {
+	obj, err := s.Create(ctx, deployment)
+	if err != nil {
+		return nil, err
+	}
+	return obj.(*extensions.Deployment), nil
+}
+
+func (s *storage) UpdateDeployment(ctx api.Context, deployment *extensions.Deployment) (*extensions.Deployment, error) {
+	obj, _, err := s.Update(ctx, deployment.Name, rest.DefaultUpdatedObjectInfo(deployment, api.Scheme))
+	if err != nil {
+		return nil, err
+	}
+	return obj.(*extensions.Deployment), nil
+}
+
+func (s *storage) DeleteDeployment(ctx api.Context, deploymentID string) error {
+	_, err := s.Delete(ctx, deploymentID, nil)
+	return err
+}

vendor/k8s.io/kubernetes/pkg/registry/extensions/deployment/strategy.go

@@ -0,0 +1,149 @@
+/*
+Copyright 2015 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 deployment
+
+import (
+	"fmt"
+	"reflect"
+	"time"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/apis/extensions/validation"
+	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
+	"k8s.io/kubernetes/pkg/controller/deployment/util"
+	"k8s.io/kubernetes/pkg/fields"
+	"k8s.io/kubernetes/pkg/labels"
+	"k8s.io/kubernetes/pkg/registry/generic"
+	"k8s.io/kubernetes/pkg/runtime"
+	apistorage "k8s.io/kubernetes/pkg/storage"
+	"k8s.io/kubernetes/pkg/util/validation/field"
+)
+
+// deploymentStrategy implements behavior for Deployments.
+type deploymentStrategy struct {
+	runtime.ObjectTyper
+	api.NameGenerator
+}
+
+// Strategy is the default logic that applies when creating and updating Deployment
+// objects via the REST API.
+var Strategy = deploymentStrategy{api.Scheme, api.SimpleNameGenerator}
+
+// NamespaceScoped is true for deployment.
+func (deploymentStrategy) NamespaceScoped() bool {
+	return true
+}
+
+// PrepareForCreate clears fields that are not allowed to be set by end users on creation.
+func (deploymentStrategy) PrepareForCreate(ctx api.Context, obj runtime.Object) {
+	deployment := obj.(*extensions.Deployment)
+	deployment.Status = extensions.DeploymentStatus{}
+	deployment.Generation = 1
+}
+
+// Validate validates a new deployment.
+func (deploymentStrategy) Validate(ctx api.Context, obj runtime.Object) field.ErrorList {
+	deployment := obj.(*extensions.Deployment)
+	return validation.ValidateDeployment(deployment)
+}
+
+// Canonicalize normalizes the object after validation.
+func (deploymentStrategy) Canonicalize(obj runtime.Object) {
+}
+
+// AllowCreateOnUpdate is false for deployments.
+func (deploymentStrategy) AllowCreateOnUpdate() bool {
+	return false
+}
+
+// PrepareForUpdate clears fields that are not allowed to be set by end users on update.
+func (deploymentStrategy) PrepareForUpdate(ctx api.Context, obj, old runtime.Object) {
+	newDeployment := obj.(*extensions.Deployment)
+	oldDeployment := old.(*extensions.Deployment)
+	newDeployment.Status = oldDeployment.Status
+
+	// Spec updates bump the generation so that we can distinguish between
+	// scaling events and template changes, annotation updates bump the generation
+	// because annotations are copied from deployments to their replica sets.
+	if !reflect.DeepEqual(newDeployment.Spec, oldDeployment.Spec) ||
+		!reflect.DeepEqual(newDeployment.Annotations, oldDeployment.Annotations) {
+		newDeployment.Generation = oldDeployment.Generation + 1
+	}
+
+	// Records timestamp on selector updates in annotation
+	if !reflect.DeepEqual(newDeployment.Spec.Selector, oldDeployment.Spec.Selector) {
+		if newDeployment.Annotations == nil {
+			newDeployment.Annotations = make(map[string]string)
+		}
+		now := metav1.Now()
+		newDeployment.Annotations[util.SelectorUpdateAnnotation] = now.Format(time.RFC3339)
+	}
+}
+
+// ValidateUpdate is the default update validation for an end user.
+func (deploymentStrategy) ValidateUpdate(ctx api.Context, obj, old runtime.Object) field.ErrorList {
+	return validation.ValidateDeploymentUpdate(obj.(*extensions.Deployment), old.(*extensions.Deployment))
+}
+
+func (deploymentStrategy) AllowUnconditionalUpdate() bool {
+	return true
+}
+
+type deploymentStatusStrategy struct {
+	deploymentStrategy
+}
+
+var StatusStrategy = deploymentStatusStrategy{Strategy}
+
+// PrepareForUpdate clears fields that are not allowed to be set by end users on update of status
+func (deploymentStatusStrategy) PrepareForUpdate(ctx api.Context, obj, old runtime.Object) {
+	newDeployment := obj.(*extensions.Deployment)
+	oldDeployment := old.(*extensions.Deployment)
+	newDeployment.Spec = oldDeployment.Spec
+	newDeployment.Labels = oldDeployment.Labels
+}
+
+// ValidateUpdate is the default update validation for an end user updating status
+func (deploymentStatusStrategy) ValidateUpdate(ctx api.Context, obj, old runtime.Object) field.ErrorList {
+	return validation.ValidateDeploymentStatusUpdate(obj.(*extensions.Deployment), old.(*extensions.Deployment))
+}
+
+// DeploymentToSelectableFields returns a field set that represents the object.
+func DeploymentToSelectableFields(deployment *extensions.Deployment) fields.Set {
+	return generic.ObjectMetaFieldsSet(&deployment.ObjectMeta, true)
+}
+
+// GetAttrs returns labels and fields of a given object for filtering purposes.
+func GetAttrs(obj runtime.Object) (labels.Set, fields.Set, error) {
+	deployment, ok := obj.(*extensions.Deployment)
+	if !ok {
+		return nil, nil, fmt.Errorf("given object is not a deployment.")
+	}
+	return labels.Set(deployment.ObjectMeta.Labels), DeploymentToSelectableFields(deployment), nil
+}
+
+// MatchDeployment is the filter used by the generic etcd backend to route
+// watch events from etcd to clients of the apiserver only interested in specific
+// labels/fields.
+func MatchDeployment(label labels.Selector, field fields.Selector) apistorage.SelectionPredicate {
+	return apistorage.SelectionPredicate{
+		Label:    label,
+		Field:    field,
+		GetAttrs: GetAttrs,
+	}
+}

vendor/k8s.io/kubernetes/pkg/registry/extensions/deployment/strategy_test.go

@@ -0,0 +1,89 @@
+/*
+Copyright 2015 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 deployment
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/testapi"
+	apitesting "k8s.io/kubernetes/pkg/api/testing"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/runtime"
+)
+
+func TestSelectableFieldLabelConversions(t *testing.T) {
+	apitesting.TestSelectableFieldLabelConversionsOfKind(t,
+		testapi.Extensions.GroupVersion().String(),
+		"Deployment",
+		DeploymentToSelectableFields(&extensions.Deployment{}),
+		nil,
+	)
+}
+
+func TestStatusUpdates(t *testing.T) {
+	tests := []struct {
+		old      runtime.Object
+		obj      runtime.Object
+		expected runtime.Object
+	}{
+		{
+			old:      newDeployment(map[string]string{"test": "label"}, map[string]string{"test": "annotation"}),
+			obj:      newDeployment(map[string]string{"test": "label", "sneaky": "label"}, map[string]string{"test": "annotation"}),
+			expected: newDeployment(map[string]string{"test": "label"}, map[string]string{"test": "annotation"}),
+		},
+		{
+			old:      newDeployment(map[string]string{"test": "label"}, map[string]string{"test": "annotation"}),
+			obj:      newDeployment(map[string]string{"test": "label"}, map[string]string{"test": "annotation", "sneaky": "annotation"}),
+			expected: newDeployment(map[string]string{"test": "label"}, map[string]string{"test": "annotation", "sneaky": "annotation"}),
+		},
+	}
+
+	for _, test := range tests {
+		deploymentStatusStrategy{}.PrepareForUpdate(api.NewContext(), test.obj, test.old)
+		if !reflect.DeepEqual(test.expected, test.obj) {
+			t.Errorf("Unexpected object mismatch! Expected:\n%#v\ngot:\n%#v", test.expected, test.obj)
+		}
+	}
+}
+
+func newDeployment(labels, annotations map[string]string) *extensions.Deployment {
+	return &extensions.Deployment{
+		ObjectMeta: api.ObjectMeta{
+			Name:        "test",
+			Labels:      labels,
+			Annotations: annotations,
+		},
+		Spec: extensions.DeploymentSpec{
+			Replicas: 1,
+			Strategy: extensions.DeploymentStrategy{
+				Type: extensions.RecreateDeploymentStrategyType,
+			},
+			Template: api.PodTemplateSpec{
+				Spec: api.PodSpec{
+					Containers: []api.Container{
+						{
+							Name:  "test",
+							Image: "test",
+						},
+					},
+				},
+			},
+		},
+	}
+}