// Describe returns the description of a DeploymentConfig
func (d *DeploymentConfigDescriber) Describe(namespace, name string) (string, error) {
deploymentConfig, err := d.client.getDeploymentConfig(namespace, name)
if err != nil {
return "", err
}
events, err := d.client.listEvents(deploymentConfig)
if err != nil {
return "", err
}
return tabbedString(func(out *tabwriter.Writer) error {
formatMeta(out, deploymentConfig.ObjectMeta)
if deploymentConfig.LatestVersion == 0 {
formatString(out, "Latest Version", "Not deployed")
} else {
formatString(out, "Latest Version", strconv.Itoa(deploymentConfig.LatestVersion))
}
printTriggers(deploymentConfig.Triggers, out)
formatString(out, "Strategy", deploymentConfig.Template.Strategy.Type)
printStrategy(deploymentConfig.Template.Strategy, out)
printReplicationControllerSpec(deploymentConfig.Template.ControllerTemplate, out)
deploymentName := deployutil.LatestDeploymentNameForConfig(deploymentConfig)
deployment, err := d.client.getDeployment(namespace, deploymentName)
if err != nil {
if kerrors.IsNotFound(err) {
formatString(out, "Latest Deployment", "<none>")
} else {
formatString(out, "Latest Deployment", fmt.Sprintf("error: %v", err))
}
} else {
header := fmt.Sprintf("Deployment #%d (latest)", deployutil.DeploymentVersionFor(deployment))
printDeploymentRc(deployment, d.client, out, header, true)
}
deploymentsHistory, err := d.client.listDeployments(namespace, labels.Everything())
if err == nil {
sorted := rcSorter{}
sorted = append(sorted, deploymentsHistory.Items...)
sort.Sort(sorted)
for _, item := range sorted {
if item.Name != deploymentName && deploymentConfig.Name == deployutil.DeploymentConfigNameFor(&item) {
header := fmt.Sprintf("Deployment #%d", deployutil.DeploymentVersionFor(&item))
printDeploymentRc(&item, d.client, out, header, false)
}
}
}
if events != nil {
kctl.DescribeEvents(events, out)
}
return nil
})
}
func TestTriggers_manual(t *testing.T) {
testutil.DeleteAllEtcdKeys()
openshift := NewTestDeployOpenshift(t)
defer openshift.Close()
config := deploytest.OkDeploymentConfig(0)
config.Namespace = testutil.Namespace()
config.Triggers = []deployapi.DeploymentTriggerPolicy{
{
Type: deployapi.DeploymentTriggerManual,
},
}
var err error
dc, err := openshift.Client.DeploymentConfigs(testutil.Namespace()).Create(config)
if err != nil {
t.Fatalf("Couldn't create DeploymentConfig: %v %#v", err, config)
}
watch, err := openshift.KubeClient.ReplicationControllers(testutil.Namespace()).Watch(labels.Everything(), fields.Everything(), dc.ResourceVersion)
if err != nil {
t.Fatalf("Couldn't subscribe to Deployments: %v", err)
}
defer watch.Stop()
config, err = openshift.Client.DeploymentConfigs(testutil.Namespace()).Generate(config.Name)
if err != nil {
t.Fatalf("Error generating config: %v", err)
}
if config.LatestVersion != 1 {
t.Fatalf("Generated deployment should have version 1: %#v", config)
}
glog.Infof("config(1): %#v", config)
new, err := openshift.Client.DeploymentConfigs(testutil.Namespace()).Update(config)
if err != nil {
t.Fatalf("Couldn't create updated DeploymentConfig: %v %#v", err, config)
}
glog.Infof("config(2): %#v", new)
event := <-watch.ResultChan()
if e, a := watchapi.Added, event.Type; e != a {
t.Fatalf("expected watch event type %s, got %s", e, a)
}
deployment := event.Object.(*kapi.ReplicationController)
if e, a := config.Name, deployutil.DeploymentConfigNameFor(deployment); e != a {
t.Fatalf("Expected deployment annotated with deploymentConfig '%s', got '%s'", e, a)
}
if e, a := 1, deployutil.DeploymentVersionFor(deployment); e != a {
t.Fatalf("Deployment annotation version does not match: %#v", deployment)
}
}
// cancel cancels any deployment process in progress for config.
func (c *cancelDeploymentCommand) cancel(config *deployapi.DeploymentConfig, out io.Writer) error {
deployments, err := c.client.ListDeploymentsForConfig(config.Namespace, config.Name)
if err != nil {
return err
}
if len(deployments.Items) == 0 {
fmt.Fprintln(out, "no deployments found to cancel")
return nil
}
failedCancellations := []string{}
for _, deployment := range deployments.Items {
status := deployutil.DeploymentStatusFor(&deployment)
switch status {
case deployapi.DeploymentStatusNew,
deployapi.DeploymentStatusPending,
deployapi.DeploymentStatusRunning:
if deployutil.IsDeploymentCancelled(&deployment) {
continue
}
deployment.Annotations[deployapi.DeploymentCancelledAnnotation] = deployapi.DeploymentCancelledAnnotationValue
deployment.Annotations[deployapi.DeploymentStatusReasonAnnotation] = deployapi.DeploymentCancelledByUser
_, err := c.client.UpdateDeployment(&deployment)
if err == nil {
fmt.Fprintf(out, "cancelled #%d\n", config.LatestVersion)
} else {
fmt.Fprintf(out, "couldn't cancel deployment %d (status: %s): %v\n", deployutil.DeploymentVersionFor(&deployment), status, err)
failedCancellations = append(failedCancellations, strconv.Itoa(deployutil.DeploymentVersionFor(&deployment)))
}
default:
fmt.Fprintln(out, "no active deployments to cancel")
}
}
if len(failedCancellations) == 0 {
return nil
} else {
return fmt.Errorf("couldn't cancel deployment %s", strings.Join(failedCancellations, ", "))
}
}
func JoinDeployments(node *DeploymentConfigNode, deploys []kapi.ReplicationController) {
matches := []*kapi.ReplicationController{}
for i := range deploys {
if belongsToDeploymentConfig(node.DeploymentConfig, &deploys[i]) {
matches = append(matches, &deploys[i])
}
}
if len(matches) == 0 {
return
}
sort.Sort(RecentDeploymentReferences(matches))
if node.DeploymentConfig.LatestVersion == deployutil.DeploymentVersionFor(matches[0]) {
node.ActiveDeployment = matches[0]
node.Deployments = matches[1:]
return
}
node.Deployments = matches
}
func describeDeploymentStatus(deploy *kapi.ReplicationController, first bool) string {
timeAt := strings.ToLower(formatRelativeTime(deploy.CreationTimestamp.Time))
status := deployutil.DeploymentStatusFor(deploy)
version := deployutil.DeploymentVersionFor(deploy)
switch status {
case deployapi.DeploymentStatusFailed:
reason := deployutil.DeploymentStatusReasonFor(deploy)
if len(reason) > 0 {
reason = fmt.Sprintf(": %s", reason)
}
// TODO: encode fail time in the rc
return fmt.Sprintf("#%d deployment failed %s ago%s%s", version, timeAt, reason, describeDeploymentPodSummaryInline(deploy, false))
case deployapi.DeploymentStatusComplete:
// TODO: pod status output
return fmt.Sprintf("#%d deployed %s ago%s", version, timeAt, describeDeploymentPodSummaryInline(deploy, first))
case deployapi.DeploymentStatusRunning:
return fmt.Sprintf("#%d deployment running for %s%s", version, timeAt, describeDeploymentPodSummaryInline(deploy, false))
default:
return fmt.Sprintf("#%d deployment %s %s ago%s", version, strings.ToLower(string(status)), timeAt, describeDeploymentPodSummaryInline(deploy, false))
}
}
func (m RecentDeploymentReferences) Less(i, j int) bool {
return deployutil.DeploymentVersionFor(m[i]) > deployutil.DeploymentVersionFor(m[j])
}
func TestDeployer_deployScenarios(t *testing.T) {
mkd := func(version int, status deployapi.DeploymentStatus, replicas int, desired int) *kapi.ReplicationController {
deployment := mkdeployment(version, status)
deployment.Spec.Replicas = replicas
if desired > 0 {
deployment.Annotations[deployapi.DesiredReplicasAnnotation] = strconv.Itoa(desired)
}
return deployment
}
type scaleEvent struct {
version int
size int
}
scenarios := []struct {
name string
deployments []*kapi.ReplicationController
fromVersion int
toVersion int
scaleEvents []scaleEvent
}{
{
"initial deployment",
// existing deployments
[]*kapi.ReplicationController{
mkd(1, deployapi.DeploymentStatusNew, 0, 3),
},
// from and to version
0, 1,
// expected scale events
[]scaleEvent{},
},
{
"last deploy failed",
// existing deployments
[]*kapi.ReplicationController{
mkd(1, deployapi.DeploymentStatusComplete, 3, 0),
mkd(2, deployapi.DeploymentStatusFailed, 1, 3),
mkd(3, deployapi.DeploymentStatusNew, 0, 3),
},
// from and to version
1, 3,
// expected scale events
[]scaleEvent{
{2, 0},
},
},
{
"sequential complete",
// existing deployments
[]*kapi.ReplicationController{
mkd(1, deployapi.DeploymentStatusComplete, 0, 0),
mkd(2, deployapi.DeploymentStatusComplete, 3, 0),
mkd(3, deployapi.DeploymentStatusNew, 0, 3),
},
// from and to version
2, 3,
// expected scale events
[]scaleEvent{},
},
{
"sequential failure",
// existing deployments
[]*kapi.ReplicationController{
mkd(1, deployapi.DeploymentStatusFailed, 1, 3),
mkd(2, deployapi.DeploymentStatusFailed, 1, 3),
mkd(3, deployapi.DeploymentStatusNew, 0, 3),
},
// from and to version
0, 3,
// expected scale events
[]scaleEvent{
{1, 0},
{2, 0},
},
},
}
for _, s := range scenarios {
t.Logf("executing scenario %s", s.name)
findDeployment := func(version int) *kapi.ReplicationController {
for _, d := range s.deployments {
if deployutil.DeploymentVersionFor(d) == version {
return d
}
}
return nil
}
var actualFrom, actualTo *kapi.ReplicationController
var actualDesired int
to := findDeployment(s.toVersion)
scaler := &scalertest.FakeScaler{}
deployer := &Deployer{
strategyFor: func(config *deployapi.DeploymentConfig) (strategy.DeploymentStrategy, error) {
return &testStrategy{
deployFunc: func(from *kapi.ReplicationController, to *kapi.ReplicationController, desiredReplicas int) error {
actualFrom = from
actualTo = to
actualDesired = desiredReplicas
return nil
},
}, nil
},
getDeployment: func(namespace, name string) (*kapi.ReplicationController, error) {
return to, nil
},
getDeployments: func(namespace, configName string) (*kapi.ReplicationControllerList, error) {
list := &kapi.ReplicationControllerList{}
for _, d := range s.deployments {
list.Items = append(list.Items, *d)
}
return list, nil
},
scaler: scaler,
}
err := deployer.Deploy(to.Namespace, to.Name)
if err != nil {
t.Fatalf("unexpcted error: %v", err)
}
if s.fromVersion > 0 {
if e, a := s.fromVersion, deployutil.DeploymentVersionFor(actualFrom); e != a {
t.Fatalf("expected from.latestVersion %d, got %d", e, a)
}
}
if e, a := s.toVersion, deployutil.DeploymentVersionFor(actualTo); e != a {
t.Fatalf("expected to.latestVersion %d, got %d", e, a)
}
if e, a := len(s.scaleEvents), len(scaler.Events); e != a {
t.Fatalf("expected %d scale events, got %d", e, a)
}
for _, expected := range s.scaleEvents {
expectedTo := findDeployment(expected.version)
expectedWasScaled := false
for _, actual := range scaler.Events {
if actual.Name != expectedTo.Name {
continue
}
if e, a := uint(expected.size), actual.Size; e != a {
t.Fatalf("expected version %d to be scaled to %d, got %d", expected.version, e, a)
}
expectedWasScaled = true
}
if !expectedWasScaled {
t.Fatalf("expected version %d to be scaled to %d, but it wasn't scaled at all", expected.version, expected.size)
}
}
}
}
// Handle processes config and creates a new deployment if necessary.
func (c *DeploymentConfigController) Handle(config *deployapi.DeploymentConfig) error {
// Only deploy when the version has advanced past 0.
if config.LatestVersion == 0 {
glog.V(5).Infof("Waiting for first version of %s", deployutil.LabelForDeploymentConfig(config))
return nil
}
// Check if any existing inflight deployments (any non-terminal state).
existingDeployments, err := c.deploymentClient.listDeploymentsForConfig(config.Namespace, config.Name)
if err != nil {
return fmt.Errorf("couldn't list Deployments for DeploymentConfig %s: %v", deployutil.LabelForDeploymentConfig(config), err)
}
var inflightDeployment *kapi.ReplicationController
latestDeploymentExists := false
for _, deployment := range existingDeployments.Items {
// check if this is the latest deployment
// we'll return after we've dealt with the multiple-active-deployments case
if deployutil.DeploymentVersionFor(&deployment) == config.LatestVersion {
latestDeploymentExists = true
}
deploymentStatus := deployutil.DeploymentStatusFor(&deployment)
switch deploymentStatus {
case deployapi.DeploymentStatusFailed,
deployapi.DeploymentStatusComplete:
// Previous deployment in terminal state - can ignore
// Ignoring specific deployment states so that any newly introduced
// deployment state will not be ignored
default:
if inflightDeployment == nil {
inflightDeployment = &deployment
continue
}
var deploymentForCancellation *kapi.ReplicationController
if deployutil.DeploymentVersionFor(inflightDeployment) < deployutil.DeploymentVersionFor(&deployment) {
deploymentForCancellation, inflightDeployment = inflightDeployment, &deployment
} else {
deploymentForCancellation = &deployment
}
deploymentForCancellation.Annotations[deployapi.DeploymentCancelledAnnotation] = deployapi.DeploymentCancelledAnnotationValue
deploymentForCancellation.Annotations[deployapi.DeploymentStatusReasonAnnotation] = deployapi.DeploymentCancelledNewerDeploymentExists
if _, err := c.deploymentClient.updateDeployment(deploymentForCancellation.Namespace, deploymentForCancellation); err != nil {
util.HandleError(fmt.Errorf("couldn't cancel Deployment %s: %v", deployutil.LabelForDeployment(deploymentForCancellation), err))
}
glog.V(4).Infof("Cancelled Deployment %s for DeploymentConfig %s", deployutil.LabelForDeployment(deploymentForCancellation), deployutil.LabelForDeploymentConfig(config))
}
}
// if the latest deployment exists then nothing else needs to be done
if latestDeploymentExists {
return nil
}
// check to see if there are inflight deployments
if inflightDeployment != nil {
// raise a transientError so that the deployment config can be re-queued
glog.V(4).Infof("Found previous inflight Deployment for %s - will requeue", deployutil.LabelForDeploymentConfig(config))
return transientError(fmt.Sprintf("found previous inflight Deployment for %s - requeuing", deployutil.LabelForDeploymentConfig(config)))
}
// Try and build a deployment for the config.
deployment, err := c.makeDeployment(config)
if err != nil {
return fatalError(fmt.Sprintf("couldn't make Deployment from (potentially invalid) DeploymentConfig %s: %v", deployutil.LabelForDeploymentConfig(config), err))
}
// Compute the desired replicas for the deployment. Use the last completed
// deployment's current replica count, or the config template if there is no
// prior completed deployment available.
desiredReplicas := config.Template.ControllerTemplate.Replicas
if len(existingDeployments.Items) > 0 {
sort.Sort(deployutil.DeploymentsByLatestVersionDesc(existingDeployments.Items))
for _, existing := range existingDeployments.Items {
if deployutil.DeploymentStatusFor(&existing) == deployapi.DeploymentStatusComplete {
desiredReplicas = existing.Spec.Replicas
glog.V(4).Infof("Desired replicas for %s set to %d based on prior completed deployment %s", deployutil.LabelForDeploymentConfig(config), desiredReplicas, existing.Name)
break
}
}
}
deployment.Annotations[deployapi.DesiredReplicasAnnotation] = strconv.Itoa(desiredReplicas)
// Create the deployment.
if _, err := c.deploymentClient.createDeployment(config.Namespace, deployment); err == nil {
glog.V(4).Infof("Created Deployment for DeploymentConfig %s", deployutil.LabelForDeploymentConfig(config))
return nil
} else {
// If the deployment was already created, just move on. The cache could be stale, or another
// process could have already handled this update.
if errors.IsAlreadyExists(err) {
glog.V(4).Infof("Deployment already exists for DeploymentConfig %s", deployutil.LabelForDeploymentConfig(config))
return nil
}
// log an event if the deployment could not be created that the user can discover
c.recorder.Eventf(config, "failedCreate", "Error creating: %v", err)
return fmt.Errorf("couldn't create Deployment for DeploymentConfig %s: %v", deployutil.LabelForDeploymentConfig(config), err)
}
}
// TestCmdDeploy_cancelOk ensures that attempts to cancel deployments
// for a config result in cancelling all in-progress deployments
// and none of the completed/faild ones.
func TestCmdDeploy_cancelOk(t *testing.T) {
var (
config *deployapi.DeploymentConfig
existingDeployments *kapi.ReplicationControllerList
updatedDeployments []kapi.ReplicationController
)
commandClient := &deployCommandClientImpl{
GetDeploymentFn: func(namespace, name string) (*kapi.ReplicationController, error) {
t.Fatalf("unexpected call to GetDeployment: %s", name)
return nil, nil
},
ListDeploymentsForConfigFn: func(namespace, configName string) (*kapi.ReplicationControllerList, error) {
return existingDeployments, nil
},
UpdateDeploymentConfigFn: func(config *deployapi.DeploymentConfig) (*deployapi.DeploymentConfig, error) {
t.Fatalf("unexpected call to UpdateDeploymentConfig")
return nil, nil
},
UpdateDeploymentFn: func(deployment *kapi.ReplicationController) (*kapi.ReplicationController, error) {
updatedDeployments = append(updatedDeployments, *deployment)
return deployment, nil
},
}
type existing struct {
version int
status deployapi.DeploymentStatus
shouldCancel bool
}
type scenario struct {
version int
existing []existing
}
scenarios := []scenario{
// No existing deployments
{1, []existing{{1, deployapi.DeploymentStatusComplete, false}}},
// A single existing failed deployment
{1, []existing{{1, deployapi.DeploymentStatusFailed, false}}},
// Multiple existing completed/failed deployments
{2, []existing{{2, deployapi.DeploymentStatusFailed, false}, {1, deployapi.DeploymentStatusComplete, false}}},
// A single existing new deployment
{1, []existing{{1, deployapi.DeploymentStatusNew, true}}},
// A single existing pending deployment
{1, []existing{{1, deployapi.DeploymentStatusPending, true}}},
// A single existing running deployment
{1, []existing{{1, deployapi.DeploymentStatusRunning, true}}},
// Multiple existing deployments with one in new/pending/running
{3, []existing{{3, deployapi.DeploymentStatusRunning, true}, {2, deployapi.DeploymentStatusComplete, false}, {1, deployapi.DeploymentStatusFailed, false}}},
// Multiple existing deployments with more than one in new/pending/running
{3, []existing{{3, deployapi.DeploymentStatusNew, true}, {2, deployapi.DeploymentStatusRunning, true}, {1, deployapi.DeploymentStatusFailed, false}}},
}
c := &cancelDeploymentCommand{client: commandClient}
for _, scenario := range scenarios {
updatedDeployments = []kapi.ReplicationController{}
config = deploytest.OkDeploymentConfig(scenario.version)
existingDeployments = &kapi.ReplicationControllerList{}
for _, e := range scenario.existing {
d, _ := deployutil.MakeDeployment(deploytest.OkDeploymentConfig(e.version), api.Codec)
d.Annotations[deployapi.DeploymentStatusAnnotation] = string(e.status)
existingDeployments.Items = append(existingDeployments.Items, *d)
}
err := c.cancel(config, ioutil.Discard)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
expectedCancellations := []int{}
actualCancellations := []int{}
for _, e := range scenario.existing {
if e.shouldCancel {
expectedCancellations = append(expectedCancellations, e.version)
}
}
for _, d := range updatedDeployments {
actualCancellations = append(actualCancellations, deployutil.DeploymentVersionFor(&d))
}
sort.Ints(actualCancellations)
sort.Ints(expectedCancellations)
if !reflect.DeepEqual(actualCancellations, expectedCancellations) {
t.Fatalf("expected cancellations: %v, actual: %v", expectedCancellations, actualCancellations)
}
}
}
// TestHandle_existingDeployments ensures that an attempt to create a
// new deployment for a config that has existing deployments succeeds of fails
// depending upon the state of the existing deployments
func TestHandle_existingDeployments(t *testing.T) {
var updatedDeployments []kapi.ReplicationController
var (
config *deployapi.DeploymentConfig
deployed *kapi.ReplicationController
existingDeployments *kapi.ReplicationControllerList
)
controller := &DeploymentConfigController{
makeDeployment: func(config *deployapi.DeploymentConfig) (*kapi.ReplicationController, error) {
return deployutil.MakeDeployment(config, api.Codec)
},
deploymentClient: &deploymentClientImpl{
createDeploymentFunc: func(namespace string, deployment *kapi.ReplicationController) (*kapi.ReplicationController, error) {
deployed = deployment
return deployment, nil
},
listDeploymentsForConfigFunc: func(namespace, configName string) (*kapi.ReplicationControllerList, error) {
return existingDeployments, nil
},
updateDeploymentFunc: func(namespace string, deployment *kapi.ReplicationController) (*kapi.ReplicationController, error) {
updatedDeployments = append(updatedDeployments, *deployment)
//t.Fatalf("unexpected update call with deployment %v", deployment)
return deployment, nil
},
},
recorder: &record.FakeRecorder{},
}
type existing struct {
version int
status deployapi.DeploymentStatus
shouldCancel bool
}
type scenario struct {
version int
existing []existing
errorType reflect.Type
expectDeployment bool
}
transientErrorType := reflect.TypeOf(transientError(""))
scenarios := []scenario{
// No existing deployments
{1, []existing{}, nil, true},
// A single existing completed deployment
{2, []existing{{1, deployapi.DeploymentStatusComplete, false}}, nil, true},
// A single existing failed deployment
{2, []existing{{1, deployapi.DeploymentStatusFailed, false}}, nil, true},
// Multiple existing completed/failed deployments
{3, []existing{{2, deployapi.DeploymentStatusFailed, false}, {1, deployapi.DeploymentStatusComplete, false}}, nil, true},
// A single existing deployment in the default state
{2, []existing{{1, "", false}}, transientErrorType, false},
// A single existing new deployment
{2, []existing{{1, deployapi.DeploymentStatusNew, false}}, transientErrorType, false},
// A single existing pending deployment
{2, []existing{{1, deployapi.DeploymentStatusPending, false}}, transientErrorType, false},
// A single existing running deployment
{2, []existing{{1, deployapi.DeploymentStatusRunning, false}}, transientErrorType, false},
// Multiple existing deployments with one in new/pending/running
{4, []existing{{3, deployapi.DeploymentStatusRunning, false}, {2, deployapi.DeploymentStatusComplete, false}, {1, deployapi.DeploymentStatusFailed, false}}, transientErrorType, false},
// Latest deployment exists and has already failed/completed
{2, []existing{{2, deployapi.DeploymentStatusFailed, false}, {1, deployapi.DeploymentStatusComplete, false}}, nil, false},
// Latest deployment exists and is in new/pending/running state
{2, []existing{{2, deployapi.DeploymentStatusRunning, false}, {1, deployapi.DeploymentStatusComplete, false}}, nil, false},
// Multiple existing deployments with more than one in new/pending/running
{4, []existing{{3, deployapi.DeploymentStatusNew, false}, {2, deployapi.DeploymentStatusRunning, true}, {1, deployapi.DeploymentStatusFailed, false}}, transientErrorType, false},
// Multiple existing deployments with more than one in new/pending/running
// Latest deployment has already failed
{6, []existing{{5, deployapi.DeploymentStatusFailed, false}, {4, deployapi.DeploymentStatusRunning, false}, {3, deployapi.DeploymentStatusNew, true}, {2, deployapi.DeploymentStatusComplete, false}, {1, deployapi.DeploymentStatusNew, true}}, transientErrorType, false},
}
for _, scenario := range scenarios {
updatedDeployments = []kapi.ReplicationController{}
deployed = nil
config = deploytest.OkDeploymentConfig(scenario.version)
existingDeployments = &kapi.ReplicationControllerList{}
for _, e := range scenario.existing {
d, _ := deployutil.MakeDeployment(deploytest.OkDeploymentConfig(e.version), api.Codec)
if e.status != "" {
d.Annotations[deployapi.DeploymentStatusAnnotation] = string(e.status)
}
existingDeployments.Items = append(existingDeployments.Items, *d)
}
err := controller.Handle(config)
if scenario.expectDeployment && deployed == nil {
t.Fatalf("expected a deployment")
}
if scenario.errorType == nil {
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
} else {
if err == nil {
t.Fatalf("expected error")
}
if reflect.TypeOf(err) != scenario.errorType {
t.Fatalf("error expected: %s, got: %s", scenario.errorType, reflect.TypeOf(err))
}
}
expectedCancellations := []int{}
actualCancellations := []int{}
for _, e := range scenario.existing {
if e.shouldCancel {
expectedCancellations = append(expectedCancellations, e.version)
}
}
for _, d := range updatedDeployments {
actualCancellations = append(actualCancellations, deployutil.DeploymentVersionFor(&d))
}
sort.Ints(actualCancellations)
sort.Ints(expectedCancellations)
if !reflect.DeepEqual(actualCancellations, expectedCancellations) {
t.Fatalf("expected cancellations: %v, actual: %v", expectedCancellations, actualCancellations)
}
}
}
// TestHandle_cleanupDeploymentFailure ensures that clean up happens
// for the deployment if the deployer pod fails.
// - failed deployment is scaled down
// - the last completed deployment is scaled back up
func TestHandle_cleanupDeploymentFailure(t *testing.T) {
var existingDeployments *kapi.ReplicationControllerList
var failedDeployment *kapi.ReplicationController
// map of deployment-version to updated replicas
var updatedDeployments map[int]*kapi.ReplicationController
controller := &DeployerPodController{
deploymentClient: &deploymentClientImpl{
getDeploymentFunc: func(namespace, name string) (*kapi.ReplicationController, error) {
return failedDeployment, nil
},
updateDeploymentFunc: func(namespace string, deployment *kapi.ReplicationController) (*kapi.ReplicationController, error) {
if _, found := updatedDeployments[deployutil.DeploymentVersionFor(deployment)]; found {
t.Fatalf("unexpected multiple updates for deployment #%d", deployutil.DeploymentVersionFor(deployment))
}
updatedDeployments[deployutil.DeploymentVersionFor(deployment)] = deployment
return deployment, nil
},
listDeploymentsForConfigFunc: func(namespace, configName string) (*kapi.ReplicationControllerList, error) {
return existingDeployments, nil
},
},
}
type existing struct {
version int
status deployapi.DeploymentStatus
initialReplicas int
updatedReplicas int
}
type scenario struct {
name string
// this is the deployment that is passed to Handle
version int
// this is the target replicas for the deployment that failed
desiredReplicas int
// existing deployments also include the one being handled currently
existing []existing
}
// existing deployments intentionally placed un-ordered
// in order to verify sorting
scenarios := []scenario{
{"No previous deployments",
1, 3, []existing{
{1, deployapi.DeploymentStatusRunning, 3, 0},
}},
{"Multiple existing deployments - none in complete state",
3, 2, []existing{
{1, deployapi.DeploymentStatusFailed, 2, 2},
{2, deployapi.DeploymentStatusFailed, 0, 0},
{3, deployapi.DeploymentStatusRunning, 2, 0},
}},
{"Failed deployment is already at 0 replicas",
3, 2, []existing{
{1, deployapi.DeploymentStatusFailed, 2, 2},
{2, deployapi.DeploymentStatusFailed, 0, 0},
{3, deployapi.DeploymentStatusRunning, 0, 0},
}},
{"Multiple existing completed deployments",
4, 2, []existing{
{3, deployapi.DeploymentStatusComplete, 0, 2},
{2, deployapi.DeploymentStatusComplete, 0, 0},
{4, deployapi.DeploymentStatusRunning, 1, 0},
{1, deployapi.DeploymentStatusFailed, 0, 0},
}},
// A deployment already exists after the current failed deployment
// only the current deployment is marked as failed
// the completed deployment is not scaled up
{"Deployment exists after current failed",
4, 2, []existing{
{3, deployapi.DeploymentStatusComplete, 1, 1},
{2, deployapi.DeploymentStatusComplete, 0, 0},
{4, deployapi.DeploymentStatusRunning, 2, 0},
{5, deployapi.DeploymentStatusNew, 0, 0},
{1, deployapi.DeploymentStatusFailed, 0, 0},
}},
}
for _, scenario := range scenarios {
t.Logf("running scenario: %s", scenario.name)
updatedDeployments = make(map[int]*kapi.ReplicationController)
failedDeployment = nil
existingDeployments = &kapi.ReplicationControllerList{}
for _, e := range scenario.existing {
d, _ := deployutil.MakeDeployment(deploytest.OkDeploymentConfig(e.version), kapi.Codec)
d.Annotations[deployapi.DeploymentStatusAnnotation] = string(e.status)
d.Spec.Replicas = e.initialReplicas
// if this is the deployment passed to Handle, set the desired replica annotation
if e.version == scenario.version {
d.Annotations[deployapi.DesiredReplicasAnnotation] = strconv.Itoa(scenario.desiredReplicas)
failedDeployment = d
}
existingDeployments.Items = append(existingDeployments.Items, *d)
}
associatedDeployment, _ := deployutil.MakeDeployment(deploytest.OkDeploymentConfig(scenario.version), kapi.Codec)
err := controller.Handle(terminatedPod(associatedDeployment))
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
// only the failed and the last completed deployment should be updated
if len(updatedDeployments) > 2 {
t.Fatalf("expected to update only the failed and last completed deployment")
}
for _, existing := range scenario.existing {
updatedDeployment, ok := updatedDeployments[existing.version]
if existing.initialReplicas != existing.updatedReplicas {
if !ok {
t.Fatalf("expected deployment #%d to be updated", existing.version)
}
if e, a := existing.updatedReplicas, updatedDeployment.Spec.Replicas; e != a {
t.Fatalf("expected deployment #%d to be scaled to %d, got %d", existing.version, e, a)
}
} else if ok && existing.version != scenario.version {
t.Fatalf("unexpected update for deployment #%d; replicas %d; status: %s", existing.version, updatedDeployment.Spec.Replicas, deployutil.DeploymentStatusFor(updatedDeployment))
}
}
if deployutil.DeploymentStatusFor(updatedDeployments[scenario.version]) != deployapi.DeploymentStatusFailed {
t.Fatalf("status for deployment #%d expected to be updated to failed; got %s", scenario.version, deployutil.DeploymentStatusFor(updatedDeployments[scenario.version]))
}
if updatedDeployments[scenario.version].Spec.Replicas != 0 {
t.Fatalf("deployment #%d expected to be scaled down to 0; got %d", scenario.version, updatedDeployments[scenario.version].Spec.Replicas)
}
}
}