2015-09-24 18:16:17 +00:00
|
|
|
/*
|
|
|
|
Copyright 2015 The Kubernetes Authors All rights reserved.
|
|
|
|
|
|
|
|
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 e2e
|
|
|
|
|
|
|
|
import (
|
2015-09-29 23:55:06 +00:00
|
|
|
"fmt"
|
2016-01-21 10:12:58 +00:00
|
|
|
"time"
|
2015-10-26 23:20:43 +00:00
|
|
|
|
2015-09-24 18:16:17 +00:00
|
|
|
"k8s.io/kubernetes/pkg/api"
|
2015-10-09 22:04:41 +00:00
|
|
|
"k8s.io/kubernetes/pkg/apis/extensions"
|
2016-02-03 21:04:58 +00:00
|
|
|
clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_2"
|
2016-02-04 23:26:06 +00:00
|
|
|
"k8s.io/kubernetes/pkg/kubectl"
|
2016-01-21 10:12:58 +00:00
|
|
|
"k8s.io/kubernetes/pkg/labels"
|
2015-10-19 21:08:35 +00:00
|
|
|
deploymentutil "k8s.io/kubernetes/pkg/util/deployment"
|
2015-12-01 23:55:13 +00:00
|
|
|
"k8s.io/kubernetes/pkg/util/intstr"
|
2015-09-24 18:16:17 +00:00
|
|
|
|
|
|
|
. "github.com/onsi/ginkgo"
|
|
|
|
. "github.com/onsi/gomega"
|
|
|
|
)
|
|
|
|
|
2016-01-14 21:06:37 +00:00
|
|
|
var _ = Describe("Deployment [Feature:Deployment]", func() {
|
2015-09-24 18:16:17 +00:00
|
|
|
f := NewFramework("deployment")
|
|
|
|
|
|
|
|
It("deployment should create new pods", func() {
|
|
|
|
testNewDeployment(f)
|
|
|
|
})
|
2016-01-29 03:08:19 +00:00
|
|
|
It("RollingUpdateDeployment should delete old pods and create new ones", func() {
|
2015-09-29 23:55:06 +00:00
|
|
|
testRollingUpdateDeployment(f)
|
|
|
|
})
|
2016-01-29 03:08:19 +00:00
|
|
|
It("RollingUpdateDeployment should scale up and down in the right order", func() {
|
2015-09-29 23:55:06 +00:00
|
|
|
testRollingUpdateDeploymentEvents(f)
|
2015-09-24 18:16:17 +00:00
|
|
|
})
|
2016-01-14 03:11:03 +00:00
|
|
|
It("RecreateDeployment should delete old pods and create new ones", func() {
|
2016-01-13 03:27:26 +00:00
|
|
|
testRecreateDeployment(f)
|
|
|
|
})
|
2016-01-28 06:13:07 +00:00
|
|
|
It("deployment should delete old rcs", func() {
|
|
|
|
testDeploymentCleanUpPolicy(f)
|
|
|
|
})
|
2016-01-29 03:08:19 +00:00
|
|
|
It("deployment should support rollover", func() {
|
2015-12-01 23:55:13 +00:00
|
|
|
testRolloverDeployment(f)
|
|
|
|
})
|
2016-01-21 10:12:58 +00:00
|
|
|
It("paused deployment should be ignored by the controller", func() {
|
|
|
|
testPausedDeployment(f)
|
|
|
|
})
|
2016-01-15 02:04:05 +00:00
|
|
|
It("deployment should support rollback", func() {
|
|
|
|
testRollbackDeployment(f)
|
|
|
|
})
|
|
|
|
It("deployment should support rollback when there's RC with no revision", func() {
|
|
|
|
testRollbackDeploymentRCNoRevision(f)
|
|
|
|
})
|
2015-09-24 18:16:17 +00:00
|
|
|
})
|
|
|
|
|
2015-12-01 23:55:13 +00:00
|
|
|
func newRC(rcName string, replicas int, rcPodLabels map[string]string, imageName string, image string) *api.ReplicationController {
|
|
|
|
return &api.ReplicationController{
|
|
|
|
ObjectMeta: api.ObjectMeta{
|
|
|
|
Name: rcName,
|
|
|
|
},
|
|
|
|
Spec: api.ReplicationControllerSpec{
|
|
|
|
Replicas: replicas,
|
|
|
|
Selector: rcPodLabels,
|
|
|
|
Template: &api.PodTemplateSpec{
|
|
|
|
ObjectMeta: api.ObjectMeta{
|
|
|
|
Labels: rcPodLabels,
|
|
|
|
},
|
|
|
|
Spec: api.PodSpec{
|
|
|
|
Containers: []api.Container{
|
|
|
|
{
|
|
|
|
Name: imageName,
|
|
|
|
Image: image,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-28 06:13:07 +00:00
|
|
|
func newDeployment(deploymentName string, replicas int, podLabels map[string]string, imageName string, image string, strategyType extensions.DeploymentStrategyType, revisionHistoryLimit *int) *extensions.Deployment {
|
2015-12-01 23:55:13 +00:00
|
|
|
return &extensions.Deployment{
|
2015-09-24 18:16:17 +00:00
|
|
|
ObjectMeta: api.ObjectMeta{
|
|
|
|
Name: deploymentName,
|
|
|
|
},
|
2015-10-09 22:49:10 +00:00
|
|
|
Spec: extensions.DeploymentSpec{
|
2016-01-13 03:27:26 +00:00
|
|
|
Replicas: replicas,
|
|
|
|
Selector: podLabels,
|
|
|
|
Strategy: extensions.DeploymentStrategy{
|
|
|
|
Type: strategyType,
|
|
|
|
},
|
2016-01-28 06:13:07 +00:00
|
|
|
RevisionHistoryLimit: revisionHistoryLimit,
|
|
|
|
UniqueLabelKey: extensions.DefaultDeploymentUniqueLabelKey,
|
2015-10-26 23:20:43 +00:00
|
|
|
Template: api.PodTemplateSpec{
|
2015-09-24 18:16:17 +00:00
|
|
|
ObjectMeta: api.ObjectMeta{
|
|
|
|
Labels: podLabels,
|
|
|
|
},
|
|
|
|
Spec: api.PodSpec{
|
|
|
|
Containers: []api.Container{
|
|
|
|
{
|
2015-12-01 23:55:13 +00:00
|
|
|
Name: imageName,
|
|
|
|
Image: image,
|
2015-09-24 18:16:17 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2015-12-01 23:55:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-15 02:04:05 +00:00
|
|
|
func newDeploymentRollback(name string, annotations map[string]string, revision int64) *extensions.DeploymentRollback {
|
|
|
|
return &extensions.DeploymentRollback{
|
|
|
|
Name: name,
|
|
|
|
UpdatedAnnotations: annotations,
|
|
|
|
RollbackTo: extensions.RollbackConfig{Revision: revision},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// checkDeploymentRevision checks if the input deployment's and its new RC's revision and images are as expected.
|
2016-01-15 05:00:58 +00:00
|
|
|
func checkDeploymentRevision(c *clientset.Clientset, ns, deploymentName, revision, imageName, image string) (*extensions.Deployment, *api.ReplicationController) {
|
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
// Check revision of the new RC of this deployment
|
|
|
|
newRC, err := deploymentutil.GetNewRC(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
Expect(newRC.Annotations).NotTo(Equal(nil))
|
|
|
|
Expect(newRC.Annotations[deploymentutil.RevisionAnnotation]).Should(Equal(revision))
|
|
|
|
// Check revision of This deployment
|
|
|
|
Expect(deployment.Annotations).NotTo(Equal(nil))
|
|
|
|
Expect(deployment.Annotations[deploymentutil.RevisionAnnotation]).Should(Equal(revision))
|
|
|
|
if len(imageName) > 0 {
|
|
|
|
// Check the image the new RC creates
|
|
|
|
Expect(newRC.Spec.Template.Spec.Containers[0].Name).Should(Equal(imageName))
|
|
|
|
Expect(newRC.Spec.Template.Spec.Containers[0].Image).Should(Equal(image))
|
|
|
|
// Check the image the deployment creates
|
|
|
|
Expect(deployment.Spec.Template.Spec.Containers[0].Name).Should(Equal(imageName))
|
|
|
|
Expect(deployment.Spec.Template.Spec.Containers[0].Image).Should(Equal(image))
|
|
|
|
}
|
|
|
|
return deployment, newRC
|
|
|
|
}
|
|
|
|
|
2015-12-01 23:55:13 +00:00
|
|
|
func testNewDeployment(f *Framework) {
|
|
|
|
ns := f.Namespace.Name
|
2016-01-15 05:00:58 +00:00
|
|
|
// TODO: remove unversionedClient when the refactoring is done. Currently some
|
|
|
|
// functions like verifyPod still expects a unversioned#Client.
|
|
|
|
unversionedClient := f.Client
|
|
|
|
c := clientset.FromUnversionedClient(f.Client)
|
|
|
|
|
2015-12-01 23:55:13 +00:00
|
|
|
deploymentName := "nginx-deployment"
|
|
|
|
podLabels := map[string]string{"name": "nginx"}
|
|
|
|
replicas := 1
|
|
|
|
Logf("Creating simple deployment %s", deploymentName)
|
2016-02-02 01:34:48 +00:00
|
|
|
d := newDeployment(deploymentName, replicas, podLabels, "nginx", "nginx", extensions.RollingUpdateDeploymentStrategyType, nil)
|
2016-02-04 23:26:06 +00:00
|
|
|
d.Annotations = map[string]string{"test": "should-copy-to-RC", kubectl.LastAppliedConfigAnnotation: "should-not-copy-to-RC"}
|
2016-02-02 01:34:48 +00:00
|
|
|
_, err := c.Extensions().Deployments(ns).Create(d)
|
2015-09-24 18:16:17 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2015-11-18 23:12:11 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2015-09-24 18:16:17 +00:00
|
|
|
Logf("deleting deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
Expect(c.Extensions().Deployments(ns).Delete(deploymentName, nil)).NotTo(HaveOccurred())
|
2015-11-18 23:12:11 +00:00
|
|
|
// TODO: remove this once we can delete rcs with deployment
|
|
|
|
newRC, err := deploymentutil.GetNewRC(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(newRC.Name, nil)).NotTo(HaveOccurred())
|
2015-09-24 18:16:17 +00:00
|
|
|
}()
|
|
|
|
// Check that deployment is created fine.
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2015-09-24 18:16:17 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// Verify that the required pods have come up.
|
2016-01-15 05:00:58 +00:00
|
|
|
err = verifyPods(unversionedClient, ns, "nginx", false, replicas)
|
2015-09-24 18:16:17 +00:00
|
|
|
if err != nil {
|
|
|
|
Logf("error in waiting for pods to come up: %s", err)
|
2015-09-29 23:55:06 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2015-09-24 18:16:17 +00:00
|
|
|
}
|
|
|
|
// DeploymentStatus should be appropriately updated.
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err = c.Extensions().Deployments(ns).Get(deploymentName)
|
2015-09-24 18:16:17 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2015-12-01 23:55:13 +00:00
|
|
|
Expect(deployment.Status.Replicas).Should(Equal(replicas))
|
|
|
|
Expect(deployment.Status.UpdatedReplicas).Should(Equal(replicas))
|
2016-01-15 02:04:05 +00:00
|
|
|
|
|
|
|
// Check if it's updated to revision 1 correctly
|
2016-02-02 01:34:48 +00:00
|
|
|
_, newRC := checkDeploymentRevision(c, ns, deploymentName, "1", "nginx", "nginx")
|
2016-02-04 23:26:06 +00:00
|
|
|
// Check other annotations
|
|
|
|
Expect(newRC.Annotations["test"]).Should(Equal("should-copy-to-RC"))
|
|
|
|
Expect(newRC.Annotations[kubectl.LastAppliedConfigAnnotation]).Should(Equal(""))
|
|
|
|
Expect(deployment.Annotations["test"]).Should(Equal("should-copy-to-RC"))
|
|
|
|
Expect(deployment.Annotations[kubectl.LastAppliedConfigAnnotation]).Should(Equal("should-not-copy-to-RC"))
|
2015-09-24 18:16:17 +00:00
|
|
|
}
|
|
|
|
|
2015-09-29 23:55:06 +00:00
|
|
|
func testRollingUpdateDeployment(f *Framework) {
|
2015-09-24 18:16:17 +00:00
|
|
|
ns := f.Namespace.Name
|
2016-01-15 05:00:58 +00:00
|
|
|
// TODO: remove unversionedClient when the refactoring is done. Currently some
|
|
|
|
// functions like verifyPod still expects a unversioned#Client.
|
|
|
|
unversionedClient := f.Client
|
|
|
|
c := clientset.FromUnversionedClient(unversionedClient)
|
2015-09-29 23:55:06 +00:00
|
|
|
// Create nginx pods.
|
2015-10-03 01:27:37 +00:00
|
|
|
deploymentPodLabels := map[string]string{"name": "sample-pod"}
|
|
|
|
rcPodLabels := map[string]string{
|
|
|
|
"name": "sample-pod",
|
|
|
|
"pod": "nginx",
|
|
|
|
}
|
|
|
|
|
2015-09-29 23:55:06 +00:00
|
|
|
rcName := "nginx-controller"
|
2015-12-01 23:55:13 +00:00
|
|
|
replicas := 3
|
2016-02-03 21:21:05 +00:00
|
|
|
_, err := c.Core().ReplicationControllers(ns).Create(newRC(rcName, replicas, rcPodLabels, "nginx", "nginx"))
|
2015-09-29 23:55:06 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
|
|
|
Logf("deleting replication controller %s", rcName)
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(rcName, nil)).NotTo(HaveOccurred())
|
2015-09-29 23:55:06 +00:00
|
|
|
}()
|
|
|
|
// Verify that the required pods have come up.
|
2016-01-15 05:00:58 +00:00
|
|
|
err = verifyPods(unversionedClient, ns, "sample-pod", false, 3)
|
2015-09-29 23:55:06 +00:00
|
|
|
if err != nil {
|
|
|
|
Logf("error in waiting for pods to come up: %s", err)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a deployment to delete nginx pods and instead bring up redis pods.
|
|
|
|
deploymentName := "redis-deployment"
|
|
|
|
Logf("Creating deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
_, err = c.Extensions().Deployments(ns).Create(newDeployment(deploymentName, replicas, deploymentPodLabels, "redis", "redis", extensions.RollingUpdateDeploymentStrategyType, nil))
|
2015-09-29 23:55:06 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2015-11-18 23:12:11 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2015-09-29 23:55:06 +00:00
|
|
|
Logf("deleting deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
Expect(c.Extensions().Deployments(ns).Delete(deploymentName, nil)).NotTo(HaveOccurred())
|
2015-11-18 23:12:11 +00:00
|
|
|
// TODO: remove this once we can delete rcs with deployment
|
|
|
|
newRC, err := deploymentutil.GetNewRC(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(newRC.Name, nil)).NotTo(HaveOccurred())
|
2015-09-29 23:55:06 +00:00
|
|
|
}()
|
|
|
|
|
2015-12-01 23:55:13 +00:00
|
|
|
err = waitForDeploymentStatus(c, ns, deploymentName, replicas, replicas-1, replicas+1, 0)
|
2015-10-03 01:27:37 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-01-13 01:52:18 +00:00
|
|
|
|
2016-01-15 02:04:05 +00:00
|
|
|
// Check if it's updated to revision 1 correctly
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "1", "redis", "redis")
|
2015-09-29 23:55:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func testRollingUpdateDeploymentEvents(f *Framework) {
|
|
|
|
ns := f.Namespace.Name
|
2016-01-15 05:00:58 +00:00
|
|
|
// TODO: remove unversionedClient when the refactoring is done. Currently some
|
|
|
|
// functions like verifyPod still expects a unversioned#Client.
|
|
|
|
unversionedClient := f.Client
|
|
|
|
c := clientset.FromUnversionedClient(unversionedClient)
|
2015-09-29 23:55:06 +00:00
|
|
|
// Create nginx pods.
|
2015-12-17 02:47:50 +00:00
|
|
|
deploymentPodLabels := map[string]string{"name": "sample-pod-2"}
|
2015-10-03 01:27:37 +00:00
|
|
|
rcPodLabels := map[string]string{
|
2015-12-17 02:47:50 +00:00
|
|
|
"name": "sample-pod-2",
|
2015-10-03 01:27:37 +00:00
|
|
|
"pod": "nginx",
|
|
|
|
}
|
2015-09-29 23:55:06 +00:00
|
|
|
rcName := "nginx-controller"
|
2015-12-01 23:55:13 +00:00
|
|
|
replicas := 1
|
2016-01-13 01:52:18 +00:00
|
|
|
|
2016-01-15 02:04:05 +00:00
|
|
|
rcRevision := "3546343826724305832"
|
2016-01-13 01:52:18 +00:00
|
|
|
annotations := make(map[string]string)
|
|
|
|
annotations[deploymentutil.RevisionAnnotation] = rcRevision
|
|
|
|
rc := newRC(rcName, replicas, rcPodLabels, "nginx", "nginx")
|
|
|
|
rc.Annotations = annotations
|
|
|
|
|
2016-02-03 21:21:05 +00:00
|
|
|
_, err := c.Core().ReplicationControllers(ns).Create(rc)
|
2015-09-24 18:16:17 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
|
|
|
Logf("deleting replication controller %s", rcName)
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(rcName, nil)).NotTo(HaveOccurred())
|
2015-09-24 18:16:17 +00:00
|
|
|
}()
|
|
|
|
// Verify that the required pods have come up.
|
2016-01-15 05:00:58 +00:00
|
|
|
err = verifyPods(unversionedClient, ns, "sample-pod-2", false, 1)
|
2015-09-24 18:16:17 +00:00
|
|
|
if err != nil {
|
|
|
|
Logf("error in waiting for pods to come up: %s", err)
|
2015-09-29 23:55:06 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2015-09-24 18:16:17 +00:00
|
|
|
}
|
|
|
|
|
2015-09-29 23:55:06 +00:00
|
|
|
// Create a deployment to delete nginx pods and instead bring up redis pods.
|
2015-12-17 02:47:50 +00:00
|
|
|
deploymentName := "redis-deployment-2"
|
2015-09-24 18:16:17 +00:00
|
|
|
Logf("Creating deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
_, err = c.Extensions().Deployments(ns).Create(newDeployment(deploymentName, replicas, deploymentPodLabels, "redis", "redis", extensions.RollingUpdateDeploymentStrategyType, nil))
|
2015-09-24 18:16:17 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2015-11-18 23:12:11 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2015-09-24 18:16:17 +00:00
|
|
|
Logf("deleting deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
Expect(c.Extensions().Deployments(ns).Delete(deploymentName, nil)).NotTo(HaveOccurred())
|
2015-11-18 23:12:11 +00:00
|
|
|
// TODO: remove this once we can delete rcs with deployment
|
|
|
|
newRC, err := deploymentutil.GetNewRC(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(newRC.Name, nil)).NotTo(HaveOccurred())
|
2015-09-24 18:16:17 +00:00
|
|
|
}()
|
|
|
|
|
2015-12-01 23:55:13 +00:00
|
|
|
err = waitForDeploymentStatus(c, ns, deploymentName, replicas, replicas-1, replicas+1, 0)
|
2015-10-03 01:27:37 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2015-09-29 23:55:06 +00:00
|
|
|
// Verify that the pods were scaled up and down as expected. We use events to verify that.
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2015-09-24 18:16:17 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-01-15 05:00:58 +00:00
|
|
|
waitForEvents(unversionedClient, ns, deployment, 2)
|
2016-02-03 21:21:05 +00:00
|
|
|
events, err := c.Core().Events(ns).Search(deployment)
|
2015-09-29 23:55:06 +00:00
|
|
|
if err != nil {
|
|
|
|
Logf("error in listing events: %s", err)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
}
|
|
|
|
// There should be 2 events, one to scale up the new RC and then to scale down the old RC.
|
|
|
|
Expect(len(events.Items)).Should(Equal(2))
|
2015-10-19 21:08:35 +00:00
|
|
|
newRC, err := deploymentutil.GetNewRC(*deployment, c)
|
2015-09-29 23:55:06 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
Expect(newRC).NotTo(Equal(nil))
|
|
|
|
Expect(events.Items[0].Message).Should(Equal(fmt.Sprintf("Scaled up rc %s to 1", newRC.Name)))
|
|
|
|
Expect(events.Items[1].Message).Should(Equal(fmt.Sprintf("Scaled down rc %s to 0", rcName)))
|
2016-01-15 02:04:05 +00:00
|
|
|
|
|
|
|
// Check if it's updated to revision 3546343826724305833 correctly
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "3546343826724305833", "redis", "redis")
|
2015-09-24 18:16:17 +00:00
|
|
|
}
|
2015-12-01 23:55:13 +00:00
|
|
|
|
2016-01-13 03:27:26 +00:00
|
|
|
func testRecreateDeployment(f *Framework) {
|
|
|
|
ns := f.Namespace.Name
|
2016-01-15 05:00:58 +00:00
|
|
|
// TODO: remove unversionedClient when the refactoring is done. Currently some
|
|
|
|
// functions like verifyPod still expects a unversioned#Client.
|
|
|
|
unversionedClient := f.Client
|
|
|
|
c := clientset.FromUnversionedClient(unversionedClient)
|
2016-01-13 03:27:26 +00:00
|
|
|
// Create nginx pods.
|
|
|
|
deploymentPodLabels := map[string]string{"name": "sample-pod-3"}
|
|
|
|
rcPodLabels := map[string]string{
|
|
|
|
"name": "sample-pod-3",
|
|
|
|
"pod": "nginx",
|
|
|
|
}
|
|
|
|
|
|
|
|
rcName := "nginx-controller"
|
|
|
|
replicas := 3
|
2016-02-03 21:21:05 +00:00
|
|
|
_, err := c.Core().ReplicationControllers(ns).Create(newRC(rcName, replicas, rcPodLabels, "nginx", "nginx"))
|
2016-01-13 03:27:26 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
|
|
|
Logf("deleting replication controller %s", rcName)
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(rcName, nil)).NotTo(HaveOccurred())
|
2016-01-13 03:27:26 +00:00
|
|
|
}()
|
|
|
|
// Verify that the required pods have come up.
|
2016-01-15 05:00:58 +00:00
|
|
|
err = verifyPods(unversionedClient, ns, "sample-pod-3", false, 3)
|
2016-01-13 03:27:26 +00:00
|
|
|
if err != nil {
|
|
|
|
Logf("error in waiting for pods to come up: %s", err)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a deployment to delete nginx pods and instead bring up redis pods.
|
|
|
|
deploymentName := "redis-deployment-3"
|
|
|
|
Logf("Creating deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
_, err = c.Extensions().Deployments(ns).Create(newDeployment(deploymentName, replicas, deploymentPodLabels, "redis", "redis", extensions.RecreateDeploymentStrategyType, nil))
|
2016-01-13 03:27:26 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-13 03:27:26 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
Logf("deleting deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
Expect(c.Extensions().Deployments(ns).Delete(deploymentName, nil)).NotTo(HaveOccurred())
|
2016-01-13 03:27:26 +00:00
|
|
|
// TODO: remove this once we can delete rcs with deployment
|
|
|
|
newRC, err := deploymentutil.GetNewRC(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(newRC.Name, nil)).NotTo(HaveOccurred())
|
2016-01-13 03:27:26 +00:00
|
|
|
}()
|
|
|
|
|
|
|
|
err = waitForDeploymentStatus(c, ns, deploymentName, replicas, 0, replicas, 0)
|
2016-01-16 00:00:46 +00:00
|
|
|
if err != nil {
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, _ := c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-16 00:00:46 +00:00
|
|
|
Logf("deployment = %+v", deployment)
|
|
|
|
}
|
2016-01-13 03:27:26 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// Verify that the pods were scaled up and down as expected. We use events to verify that.
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-13 03:27:26 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-01-15 05:00:58 +00:00
|
|
|
waitForEvents(unversionedClient, ns, deployment, 2)
|
2016-02-03 21:21:05 +00:00
|
|
|
events, err := c.Core().Events(ns).Search(deployment)
|
2016-01-13 03:27:26 +00:00
|
|
|
if err != nil {
|
|
|
|
Logf("error in listing events: %s", err)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
}
|
|
|
|
// There should be 2 events, one to scale up the new RC and then to scale down the old RC.
|
|
|
|
Expect(len(events.Items)).Should(Equal(2))
|
|
|
|
newRC, err := deploymentutil.GetNewRC(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
Expect(newRC).NotTo(Equal(nil))
|
|
|
|
Expect(events.Items[0].Message).Should(Equal(fmt.Sprintf("Scaled down rc %s to 0", rcName)))
|
|
|
|
Expect(events.Items[1].Message).Should(Equal(fmt.Sprintf("Scaled up rc %s to 3", newRC.Name)))
|
2016-01-15 02:04:05 +00:00
|
|
|
|
|
|
|
// Check if it's updated to revision 1 correctly
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "1", "redis", "redis")
|
2016-01-13 03:27:26 +00:00
|
|
|
}
|
|
|
|
|
2016-01-28 06:13:07 +00:00
|
|
|
// testDeploymentCleanUpPolicy tests that deployment supports cleanup policy
|
|
|
|
func testDeploymentCleanUpPolicy(f *Framework) {
|
|
|
|
ns := f.Namespace.Name
|
2016-01-15 05:00:58 +00:00
|
|
|
unversionedClient := f.Client
|
|
|
|
c := clientset.FromUnversionedClient(unversionedClient)
|
2016-01-28 06:13:07 +00:00
|
|
|
// Create nginx pods.
|
|
|
|
deploymentPodLabels := map[string]string{"name": "cleanup-pod"}
|
|
|
|
rcPodLabels := map[string]string{
|
|
|
|
"name": "cleanup-pod",
|
|
|
|
"pod": "nginx",
|
|
|
|
}
|
|
|
|
rcName := "nginx-controller"
|
|
|
|
replicas := 1
|
|
|
|
revisionHistoryLimit := new(int)
|
|
|
|
*revisionHistoryLimit = 0
|
2016-02-03 21:21:05 +00:00
|
|
|
_, err := c.Core().ReplicationControllers(ns).Create(newRC(rcName, replicas, rcPodLabels, "nginx", "nginx"))
|
2016-01-28 06:13:07 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// Verify that the required pods have come up.
|
2016-01-15 05:00:58 +00:00
|
|
|
err = verifyPods(unversionedClient, ns, "cleanup-pod", false, 1)
|
2016-01-28 06:13:07 +00:00
|
|
|
if err != nil {
|
|
|
|
Logf("error in waiting for pods to come up: %s", err)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a deployment to delete nginx pods and instead bring up redis pods.
|
|
|
|
deploymentName := "redis-deployment"
|
|
|
|
Logf("Creating deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
_, err = c.Extensions().Deployments(ns).Create(newDeployment(deploymentName, replicas, deploymentPodLabels, "redis", "redis", extensions.RollingUpdateDeploymentStrategyType, revisionHistoryLimit))
|
2016-01-28 06:13:07 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-28 06:13:07 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
Logf("deleting deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
Expect(c.Extensions().Deployments(ns).Delete(deploymentName, nil)).NotTo(HaveOccurred())
|
2016-01-28 06:13:07 +00:00
|
|
|
// TODO: remove this once we can delete rcs with deployment
|
|
|
|
newRC, err := deploymentutil.GetNewRC(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(newRC.Name, nil)).NotTo(HaveOccurred())
|
2016-01-28 06:13:07 +00:00
|
|
|
}()
|
|
|
|
|
|
|
|
err = waitForDeploymentOldRCsNum(c, ns, deploymentName, *revisionHistoryLimit)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
}
|
|
|
|
|
2015-12-01 23:55:13 +00:00
|
|
|
// testRolloverDeployment tests that deployment supports rollover.
|
|
|
|
// i.e. we can change desired state and kick off rolling update, then change desired state again before it finishes.
|
|
|
|
func testRolloverDeployment(f *Framework) {
|
|
|
|
ns := f.Namespace.Name
|
2016-01-15 05:00:58 +00:00
|
|
|
// TODO: remove unversionedClient when the refactoring is done. Currently some
|
|
|
|
// functions like verifyPod still expects a unversioned#Client.
|
|
|
|
unversionedClient := f.Client
|
|
|
|
c := clientset.FromUnversionedClient(unversionedClient)
|
2015-12-01 23:55:13 +00:00
|
|
|
podName := "rollover-pod"
|
|
|
|
deploymentPodLabels := map[string]string{"name": podName}
|
|
|
|
rcPodLabels := map[string]string{
|
|
|
|
"name": podName,
|
|
|
|
"pod": "nginx",
|
|
|
|
}
|
|
|
|
|
|
|
|
rcName := "nginx-controller"
|
|
|
|
rcReplicas := 4
|
2016-02-03 21:21:05 +00:00
|
|
|
_, err := c.Core().ReplicationControllers(ns).Create(newRC(rcName, rcReplicas, rcPodLabels, "nginx", "nginx"))
|
2015-12-01 23:55:13 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
|
|
|
Logf("deleting replication controller %s", rcName)
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(rcName, nil)).NotTo(HaveOccurred())
|
2015-12-01 23:55:13 +00:00
|
|
|
}()
|
|
|
|
// Verify that the required pods have come up.
|
2016-01-15 05:00:58 +00:00
|
|
|
err = verifyPods(unversionedClient, ns, podName, false, rcReplicas)
|
2015-12-01 23:55:13 +00:00
|
|
|
if err != nil {
|
|
|
|
Logf("error in waiting for pods to come up: %s", err)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a deployment to delete nginx pods and instead bring up redis-slave pods.
|
|
|
|
deploymentName, deploymentImageName := "redis-deployment", "redis-slave"
|
|
|
|
deploymentReplicas := 4
|
|
|
|
deploymentImage := "gcr.io/google_samples/gb-redisslave:v1"
|
|
|
|
deploymentMinReadySeconds := 5
|
2016-01-13 03:27:26 +00:00
|
|
|
deploymentStrategyType := extensions.RollingUpdateDeploymentStrategyType
|
2015-12-01 23:55:13 +00:00
|
|
|
Logf("Creating deployment %s", deploymentName)
|
2016-01-28 06:13:07 +00:00
|
|
|
newDeployment := newDeployment(deploymentName, deploymentReplicas, deploymentPodLabels, deploymentImageName, deploymentImage, deploymentStrategyType, nil)
|
2016-01-31 13:59:58 +00:00
|
|
|
newDeployment.Spec.MinReadySeconds = deploymentMinReadySeconds
|
2015-12-01 23:55:13 +00:00
|
|
|
newDeployment.Spec.Strategy.RollingUpdate = &extensions.RollingUpdateDeployment{
|
2016-01-31 13:59:58 +00:00
|
|
|
MaxUnavailable: intstr.FromInt(1),
|
|
|
|
MaxSurge: intstr.FromInt(1),
|
2015-12-01 23:55:13 +00:00
|
|
|
}
|
2016-01-15 05:00:58 +00:00
|
|
|
_, err = c.Extensions().Deployments(ns).Create(newDeployment)
|
2015-12-01 23:55:13 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2015-12-01 23:55:13 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
Logf("deleting deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
Expect(c.Extensions().Deployments(ns).Delete(deploymentName, nil)).NotTo(HaveOccurred())
|
2015-12-01 23:55:13 +00:00
|
|
|
// TODO: remove this once we can delete rcs with deployment
|
|
|
|
newRC, err := deploymentutil.GetNewRC(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(newRC.Name, nil)).NotTo(HaveOccurred())
|
2015-12-01 23:55:13 +00:00
|
|
|
}()
|
|
|
|
// Verify that the pods were scaled up and down as expected. We use events to verify that.
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-13 01:52:18 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2015-12-01 23:55:13 +00:00
|
|
|
// Make sure the deployment starts to scale up and down RCs
|
2016-01-15 05:00:58 +00:00
|
|
|
waitForPartialEvents(unversionedClient, ns, deployment, 2)
|
2016-01-15 02:04:05 +00:00
|
|
|
// Check if it's updated to revision 1 correctly
|
|
|
|
_, newRC := checkDeploymentRevision(c, ns, deploymentName, "1", deploymentImageName, deploymentImage)
|
2015-12-01 23:55:13 +00:00
|
|
|
|
|
|
|
// Before the deployment finishes, update the deployment to rollover the above 2 rcs and bring up redis pods.
|
|
|
|
// If the deployment already finished here, the test would fail. When this happens, increase its minReadySeconds or replicas to prevent it.
|
2016-01-06 00:56:12 +00:00
|
|
|
Expect(newRC.Spec.Replicas).Should(BeNumerically("<", deploymentReplicas))
|
2015-12-01 23:55:13 +00:00
|
|
|
updatedDeploymentImage := "redis"
|
|
|
|
newDeployment.Spec.Template.Spec.Containers[0].Name = updatedDeploymentImage
|
|
|
|
newDeployment.Spec.Template.Spec.Containers[0].Image = updatedDeploymentImage
|
|
|
|
Logf("updating deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
_, err = c.Extensions().Deployments(ns).Update(newDeployment)
|
2015-12-01 23:55:13 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
err = waitForDeploymentStatus(c, ns, deploymentName, deploymentReplicas, deploymentReplicas-1, deploymentReplicas+1, deploymentMinReadySeconds)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
2016-01-15 02:04:05 +00:00
|
|
|
// Check if it's updated to revision 2 correctly
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "2", updatedDeploymentImage, updatedDeploymentImage)
|
2015-12-01 23:55:13 +00:00
|
|
|
}
|
2016-01-21 10:12:58 +00:00
|
|
|
|
|
|
|
func testPausedDeployment(f *Framework) {
|
|
|
|
ns := f.Namespace.Name
|
2016-01-15 05:00:58 +00:00
|
|
|
// TODO: remove unversionedClient when the refactoring is done. Currently some
|
|
|
|
// functions like verifyPod still expects a unversioned#Client.
|
|
|
|
unversionedClient := f.Client
|
|
|
|
c := clientset.FromUnversionedClient(unversionedClient)
|
2016-01-21 10:12:58 +00:00
|
|
|
deploymentName := "nginx"
|
|
|
|
podLabels := map[string]string{"name": "nginx"}
|
2016-01-28 06:13:07 +00:00
|
|
|
d := newDeployment(deploymentName, 1, podLabels, "nginx", "nginx", extensions.RollingUpdateDeploymentStrategyType, nil)
|
2016-01-21 10:12:58 +00:00
|
|
|
d.Spec.Paused = true
|
|
|
|
Logf("Creating paused deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
_, err := c.Extensions().Deployments(ns).Create(d)
|
2016-01-21 10:12:58 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
2016-01-15 05:00:58 +00:00
|
|
|
_, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-21 10:12:58 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
Logf("deleting deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
Expect(c.Extensions().Deployments(ns).Delete(deploymentName, nil)).NotTo(HaveOccurred())
|
2016-01-21 10:12:58 +00:00
|
|
|
}()
|
|
|
|
// Check that deployment is created fine.
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-21 10:12:58 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// Verify that there is no latest state realized for the new deployment.
|
|
|
|
rc, err := deploymentutil.GetNewRC(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
if rc != nil {
|
|
|
|
err = fmt.Errorf("unexpected new rc/%s for deployment/%s", rc.Name, deployment.Name)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update the deployment to run
|
|
|
|
deployment.Spec.Paused = false
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err = c.Extensions().Deployments(ns).Update(deployment)
|
2016-01-21 10:12:58 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
opts := api.ListOptions{LabelSelector: labels.Set(deployment.Spec.Selector).AsSelector()}
|
2016-02-03 21:21:05 +00:00
|
|
|
w, err := c.Core().ReplicationControllers(ns).Watch(opts)
|
2016-01-21 10:12:58 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-w.ResultChan():
|
|
|
|
// this is it
|
|
|
|
case <-time.After(time.Minute):
|
|
|
|
err = fmt.Errorf("expected a new rc to be created")
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Pause the deployment and delete the replication controller.
|
|
|
|
// The paused deployment shouldn't recreate a new one.
|
|
|
|
deployment.Spec.Paused = true
|
|
|
|
deployment.ResourceVersion = ""
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err = c.Extensions().Deployments(ns).Update(deployment)
|
2016-01-21 10:12:58 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
newRC, err := deploymentutil.GetNewRC(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(newRC.Name, nil)).NotTo(HaveOccurred())
|
2016-01-21 10:12:58 +00:00
|
|
|
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err = c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-21 10:12:58 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
if !deployment.Spec.Paused {
|
|
|
|
err = fmt.Errorf("deployment %q should be paused", deployment.Name)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
}
|
|
|
|
shouldBeNil, err := deploymentutil.GetNewRC(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
if shouldBeNil != nil {
|
|
|
|
err = fmt.Errorf("deployment %q shouldn't have a rc but there is %q", deployment.Name, shouldBeNil.Name)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
}
|
|
|
|
}
|
2016-01-15 02:04:05 +00:00
|
|
|
|
|
|
|
// testRollbackDeployment tests that a deployment is created (revision 1) and updated (revision 2), and
|
|
|
|
// then rollback to revision 1 (should update template to revision 1, and then update revision 1 to 3),
|
|
|
|
// and then rollback to last revision.
|
|
|
|
func testRollbackDeployment(f *Framework) {
|
|
|
|
ns := f.Namespace.Name
|
2016-01-15 05:00:58 +00:00
|
|
|
unversionedClient := f.Client
|
|
|
|
c := clientset.FromUnversionedClient(unversionedClient)
|
2016-01-15 02:04:05 +00:00
|
|
|
podName := "nginx"
|
|
|
|
deploymentPodLabels := map[string]string{"name": podName}
|
|
|
|
|
|
|
|
// Create a deployment to create nginx pods.
|
|
|
|
deploymentName, deploymentImageName := "nginx-deployment", "nginx"
|
|
|
|
deploymentReplicas := 1
|
|
|
|
deploymentImage := "nginx"
|
|
|
|
deploymentStrategyType := extensions.RollingUpdateDeploymentStrategyType
|
|
|
|
Logf("Creating deployment %s", deploymentName)
|
|
|
|
d := newDeployment(deploymentName, deploymentReplicas, deploymentPodLabels, deploymentImageName, deploymentImage, deploymentStrategyType, nil)
|
2016-01-15 05:00:58 +00:00
|
|
|
_, err := c.Extensions().Deployments(ns).Create(d)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
Logf("deleting deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
Expect(c.Extensions().Deployments(ns).Delete(deploymentName, nil)).NotTo(HaveOccurred())
|
2016-01-15 02:04:05 +00:00
|
|
|
// TODO: remove this once we can delete rcs with deployment
|
|
|
|
newRC, err := deploymentutil.GetNewRC(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(newRC.Name, nil)).NotTo(HaveOccurred())
|
2016-01-15 02:04:05 +00:00
|
|
|
oldRCs, _, err := deploymentutil.GetOldRCs(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
for _, oldRC := range oldRCs {
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(oldRC.Name, nil)).NotTo(HaveOccurred())
|
2016-01-15 02:04:05 +00:00
|
|
|
}
|
|
|
|
}()
|
|
|
|
// Check that deployment is created fine.
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// Verify that the required pods have come up.
|
2016-01-15 05:00:58 +00:00
|
|
|
err = verifyPods(unversionedClient, ns, "nginx", false, deploymentReplicas)
|
2016-01-15 02:04:05 +00:00
|
|
|
if err != nil {
|
|
|
|
Logf("error in waiting for pods to come up: %s", err)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
}
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err = c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
// DeploymentStatus should be appropriately updated.
|
|
|
|
Expect(deployment.Status.Replicas).Should(Equal(deploymentReplicas))
|
|
|
|
Expect(deployment.Status.UpdatedReplicas).Should(Equal(deploymentReplicas))
|
|
|
|
|
|
|
|
// Check if it's updated to revision 1 correctly
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "1", deploymentImageName, deploymentImage)
|
|
|
|
|
|
|
|
// Update the deployment to create redis pods.
|
|
|
|
updatedDeploymentImage := "redis"
|
|
|
|
updatedDeploymentImageName := "redis"
|
|
|
|
d.Spec.Template.Spec.Containers[0].Name = updatedDeploymentImageName
|
|
|
|
d.Spec.Template.Spec.Containers[0].Image = updatedDeploymentImage
|
|
|
|
Logf("updating deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
_, err = c.Extensions().Deployments(ns).Update(d)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
err = waitForDeploymentStatus(c, ns, deploymentName, deploymentReplicas, deploymentReplicas-1, deploymentReplicas+1, 0)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// Check if it's updated to revision 2 correctly
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "2", updatedDeploymentImageName, updatedDeploymentImage)
|
|
|
|
|
|
|
|
// Update the deploymentRollback to rollback to revision 1
|
|
|
|
revision := int64(1)
|
|
|
|
Logf("rolling back deployment %s to revision %d", deploymentName, revision)
|
|
|
|
rollback := newDeploymentRollback(deploymentName, nil, revision)
|
2016-01-15 05:00:58 +00:00
|
|
|
err = c.Extensions().Deployments(ns).Rollback(rollback)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
err = waitForDeploymentStatus(c, ns, deploymentName, deploymentReplicas, deploymentReplicas-1, deploymentReplicas+1, 0)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// Check if it's updated to revision 3 correctly
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "3", deploymentImageName, deploymentImage)
|
|
|
|
|
|
|
|
// Update the deploymentRollback to rollback to last revision
|
|
|
|
revision = 0
|
|
|
|
Logf("rolling back deployment %s to last revision", deploymentName)
|
|
|
|
rollback = newDeploymentRollback(deploymentName, nil, revision)
|
2016-01-15 05:00:58 +00:00
|
|
|
err = c.Extensions().Deployments(ns).Rollback(rollback)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
err = waitForDeploymentStatus(c, ns, deploymentName, deploymentReplicas, deploymentReplicas-1, deploymentReplicas+1, 0)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// Check if it's updated to revision 4 correctly
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "4", updatedDeploymentImageName, updatedDeploymentImage)
|
|
|
|
}
|
|
|
|
|
|
|
|
// testRollbackDeploymentRCNoRevision tests that deployment supports rollback even when there's old RC without revision.
|
|
|
|
// An old RC without revision is created, and then a deployment is created (v1). The deployment shouldn't add revision
|
|
|
|
// annotation to the old RC. Then rollback the deployment to last revision, and it should fail and emit related event.
|
|
|
|
// Then update the deployment to v2 and rollback it to v1 should succeed and emit related event, now the deployment
|
|
|
|
// becomes v3. Then rollback the deployment to v10 (doesn't exist in history) should fail and emit related event.
|
|
|
|
// Finally, rollback the deployment (v3) to v3 should be no-op and emit related event.
|
|
|
|
func testRollbackDeploymentRCNoRevision(f *Framework) {
|
|
|
|
ns := f.Namespace.Name
|
2016-01-15 05:00:58 +00:00
|
|
|
unversionedClient := f.Client
|
|
|
|
c := clientset.FromUnversionedClient(f.Client)
|
2016-01-15 02:04:05 +00:00
|
|
|
podName := "nginx"
|
|
|
|
deploymentPodLabels := map[string]string{"name": podName}
|
|
|
|
rcPodLabels := map[string]string{
|
|
|
|
"name": podName,
|
|
|
|
"pod": "nginx",
|
|
|
|
}
|
|
|
|
|
|
|
|
rcName := "nginx-controller"
|
|
|
|
rcReplicas := 0
|
|
|
|
rc := newRC(rcName, rcReplicas, rcPodLabels, "nginx", "nginx")
|
|
|
|
rc.Annotations = make(map[string]string)
|
|
|
|
rc.Annotations["make"] = "difference"
|
2016-02-03 21:21:05 +00:00
|
|
|
_, err := c.Core().ReplicationControllers(ns).Create(rc)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
|
|
|
Logf("deleting replication controller %s", rcName)
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(rcName, nil)).NotTo(HaveOccurred())
|
2016-01-15 02:04:05 +00:00
|
|
|
}()
|
|
|
|
|
|
|
|
// Create a deployment to create nginx pods, which have different template than the rc created above.
|
|
|
|
deploymentName, deploymentImageName := "nginx-deployment", "nginx"
|
|
|
|
deploymentReplicas := 1
|
|
|
|
deploymentImage := "nginx"
|
|
|
|
deploymentStrategyType := extensions.RollingUpdateDeploymentStrategyType
|
|
|
|
Logf("Creating deployment %s", deploymentName)
|
|
|
|
d := newDeployment(deploymentName, deploymentReplicas, deploymentPodLabels, deploymentImageName, deploymentImage, deploymentStrategyType, nil)
|
2016-01-15 05:00:58 +00:00
|
|
|
_, err = c.Extensions().Deployments(ns).Create(d)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
defer func() {
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
Logf("deleting deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
Expect(c.Extensions().Deployments(ns).Delete(deploymentName, nil)).NotTo(HaveOccurred())
|
2016-01-15 02:04:05 +00:00
|
|
|
// TODO: remove this once we can delete rcs with deployment
|
|
|
|
newRC, err := deploymentutil.GetNewRC(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(newRC.Name, nil)).NotTo(HaveOccurred())
|
2016-01-15 02:04:05 +00:00
|
|
|
oldRCs, _, err := deploymentutil.GetOldRCs(*deployment, c)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
for _, oldRC := range oldRCs {
|
2016-02-03 21:21:05 +00:00
|
|
|
Expect(c.Core().ReplicationControllers(ns).Delete(oldRC.Name, nil)).NotTo(HaveOccurred())
|
2016-01-15 02:04:05 +00:00
|
|
|
}
|
|
|
|
}()
|
|
|
|
// Check that deployment is created fine.
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// Verify that the required pods have come up.
|
2016-01-15 05:00:58 +00:00
|
|
|
err = verifyPods(unversionedClient, ns, "nginx", false, deploymentReplicas)
|
2016-01-15 02:04:05 +00:00
|
|
|
if err != nil {
|
|
|
|
Logf("error in waiting for pods to come up: %s", err)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
}
|
2016-01-15 05:00:58 +00:00
|
|
|
deployment, err = c.Extensions().Deployments(ns).Get(deploymentName)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
// DeploymentStatus should be appropriately updated.
|
|
|
|
Expect(deployment.Status.Replicas).Should(Equal(deploymentReplicas))
|
|
|
|
Expect(deployment.Status.UpdatedReplicas).Should(Equal(deploymentReplicas))
|
|
|
|
|
|
|
|
// Check if it's updated to revision 1 correctly
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "1", deploymentImageName, deploymentImage)
|
|
|
|
|
|
|
|
// Check that the rc we created still doesn't contain revision information
|
2016-02-03 21:21:05 +00:00
|
|
|
rc, err = c.Core().ReplicationControllers(ns).Get(rcName)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(rc.Annotations[deploymentutil.RevisionAnnotation]).Should(Equal(""))
|
|
|
|
|
|
|
|
// Update the deploymentRollback to rollback to last revision
|
|
|
|
// Since there's only 1 revision in history, it should stay as revision 1
|
|
|
|
revision := int64(0)
|
|
|
|
Logf("rolling back deployment %s to last revision", deploymentName)
|
|
|
|
rollback := newDeploymentRollback(deploymentName, nil, revision)
|
2016-01-15 05:00:58 +00:00
|
|
|
err = c.Extensions().Deployments(ns).Rollback(rollback)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// There should be revision not found event since there's no last revision
|
2016-01-15 05:00:58 +00:00
|
|
|
waitForEvents(unversionedClient, ns, deployment, 2)
|
2016-01-15 02:04:05 +00:00
|
|
|
events, err := c.Events(ns).Search(deployment)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-01-19 22:50:03 +00:00
|
|
|
Expect(events.Items[1].Reason).Should(Equal(deploymentutil.RollbackRevisionNotFound))
|
2016-01-15 02:04:05 +00:00
|
|
|
|
|
|
|
// Check if it's still revision 1
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "1", deploymentImageName, deploymentImage)
|
|
|
|
|
|
|
|
// Update the deployment to create redis pods.
|
|
|
|
updatedDeploymentImage := "redis"
|
|
|
|
updatedDeploymentImageName := "redis"
|
|
|
|
d.Spec.Template.Spec.Containers[0].Name = updatedDeploymentImageName
|
|
|
|
d.Spec.Template.Spec.Containers[0].Image = updatedDeploymentImage
|
|
|
|
Logf("updating deployment %s", deploymentName)
|
2016-01-15 05:00:58 +00:00
|
|
|
_, err = c.Extensions().Deployments(ns).Update(d)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
err = waitForDeploymentStatus(c, ns, deploymentName, deploymentReplicas, deploymentReplicas-1, deploymentReplicas+1, 0)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// Check if it's updated to revision 2 correctly
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "2", updatedDeploymentImageName, updatedDeploymentImage)
|
|
|
|
|
|
|
|
// Update the deploymentRollback to rollback to revision 1
|
|
|
|
revision = 1
|
|
|
|
Logf("rolling back deployment %s to revision %d", deploymentName, revision)
|
|
|
|
rollback = newDeploymentRollback(deploymentName, nil, revision)
|
2016-01-15 05:00:58 +00:00
|
|
|
err = c.Extensions().Deployments(ns).Rollback(rollback)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
err = waitForDeploymentStatus(c, ns, deploymentName, deploymentReplicas, deploymentReplicas-1, deploymentReplicas+1, 0)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// There should be rollback event after we rollback to revision 1
|
2016-01-15 05:00:58 +00:00
|
|
|
waitForEvents(unversionedClient, ns, deployment, 5)
|
2016-01-15 02:04:05 +00:00
|
|
|
events, err = c.Events(ns).Search(deployment)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-01-19 22:50:03 +00:00
|
|
|
Expect(events.Items[4].Reason).Should(Equal(deploymentutil.RollbackDone))
|
2016-01-15 02:04:05 +00:00
|
|
|
|
|
|
|
// Check if it's updated to revision 3 correctly
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "3", deploymentImageName, deploymentImage)
|
|
|
|
|
|
|
|
// Update the deploymentRollback to rollback to revision 10
|
|
|
|
// Since there's no revision 10 in history, it should stay as revision 3, and emit an event
|
|
|
|
revision = 10
|
|
|
|
Logf("rolling back deployment %s to revision %d", deploymentName, revision)
|
|
|
|
rollback = newDeploymentRollback(deploymentName, nil, revision)
|
2016-01-15 05:00:58 +00:00
|
|
|
err = c.Extensions().Deployments(ns).Rollback(rollback)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// There should be revision not found event since there's no revision 10
|
2016-01-15 05:00:58 +00:00
|
|
|
waitForEvents(unversionedClient, ns, deployment, 7)
|
2016-01-15 02:04:05 +00:00
|
|
|
events, err = c.Events(ns).Search(deployment)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-01-19 22:50:03 +00:00
|
|
|
Expect(events.Items[6].Reason).Should(Equal(deploymentutil.RollbackRevisionNotFound))
|
2016-01-15 02:04:05 +00:00
|
|
|
|
|
|
|
// Check if it's still revision 3
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "3", deploymentImageName, deploymentImage)
|
|
|
|
|
|
|
|
// Update the deploymentRollback to rollback to revision 3
|
|
|
|
// Since it's already revision 3, it should be no-op and emit an event
|
|
|
|
revision = 3
|
|
|
|
Logf("rolling back deployment %s to revision %d", deploymentName, revision)
|
|
|
|
rollback = newDeploymentRollback(deploymentName, nil, revision)
|
2016-01-15 05:00:58 +00:00
|
|
|
err = c.Extensions().Deployments(ns).Rollback(rollback)
|
2016-01-15 02:04:05 +00:00
|
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
|
|
|
|
// There should be revision template unchanged event since it's already revision 3
|
2016-01-15 05:00:58 +00:00
|
|
|
waitForEvents(unversionedClient, ns, deployment, 8)
|
2016-01-15 02:04:05 +00:00
|
|
|
events, err = c.Events(ns).Search(deployment)
|
|
|
|
Expect(err).NotTo(HaveOccurred())
|
2016-01-19 22:50:03 +00:00
|
|
|
Expect(events.Items[7].Reason).Should(Equal(deploymentutil.RollbackTemplateUnchanged))
|
2016-01-15 02:04:05 +00:00
|
|
|
|
|
|
|
// Check if it's still revision 3
|
|
|
|
checkDeploymentRevision(c, ns, deploymentName, "3", deploymentImageName, deploymentImage)
|
|
|
|
}
|