mirror of
https://github.com/kubernetes/kubernetes.git
synced 2026-11-06 13:28:22 +00:00
Patrick Ohly
2579861734
Kubernetes 1.37 finished the introduction of context-aware client-go APIs. Components like kube-controller-manager which are meant to support contextual logging should use those new APIs. This is not enforced yet because existing code must be updated first. Once that is done, enforcement of everything touched here can be enabled tree-wide.
728 lines
25 KiB
Go
728 lines
25 KiB
Go
/*
|
|
Copyright 2016 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 (
|
|
"math"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
apps "k8s.io/api/apps/v1"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/apimachinery/pkg/util/intstr"
|
|
"k8s.io/apimachinery/pkg/util/sets"
|
|
"k8s.io/apimachinery/pkg/util/validation"
|
|
"k8s.io/client-go/informers"
|
|
"k8s.io/client-go/kubernetes/fake"
|
|
testclient "k8s.io/client-go/testing"
|
|
"k8s.io/client-go/tools/record"
|
|
"k8s.io/klog/v2/ktesting"
|
|
"k8s.io/kubernetes/pkg/controller"
|
|
deploymentutil "k8s.io/kubernetes/pkg/controller/deployment/util"
|
|
"k8s.io/utils/ptr"
|
|
)
|
|
|
|
func TestScale(t *testing.T) {
|
|
newTimestamp := metav1.Date(2016, 5, 20, 2, 0, 0, 0, time.UTC)
|
|
oldTimestamp := metav1.Date(2016, 5, 20, 1, 0, 0, 0, time.UTC)
|
|
olderTimestamp := metav1.Date(2016, 5, 20, 0, 0, 0, 0, time.UTC)
|
|
|
|
var updatedTemplate = func(replicas int32) *apps.Deployment {
|
|
d := newDeployment("foo", replicas, nil, nil, nil, map[string]string{"foo": "bar"})
|
|
d.Spec.Template.Labels["another"] = "label"
|
|
return d
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
deployment *apps.Deployment
|
|
oldDeployment *apps.Deployment
|
|
|
|
newRS *apps.ReplicaSet
|
|
oldRSs []*apps.ReplicaSet
|
|
|
|
expectedNew *apps.ReplicaSet
|
|
expectedOld []*apps.ReplicaSet
|
|
wasntUpdated map[string]bool
|
|
|
|
desiredReplicasAnnotations map[string]int32
|
|
}{
|
|
{
|
|
name: "normal scaling event: 10 -> 12",
|
|
deployment: newDeployment("foo", 12, nil, nil, nil, nil),
|
|
oldDeployment: newDeployment("foo", 10, nil, nil, nil, nil),
|
|
|
|
newRS: rs("foo-v1", 10, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{},
|
|
|
|
expectedNew: rs("foo-v1", 12, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{},
|
|
},
|
|
{
|
|
name: "normal scaling event: 10 -> 5",
|
|
deployment: newDeployment("foo", 5, nil, nil, nil, nil),
|
|
oldDeployment: newDeployment("foo", 10, nil, nil, nil, nil),
|
|
|
|
newRS: rs("foo-v1", 10, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{},
|
|
|
|
expectedNew: rs("foo-v1", 5, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{},
|
|
},
|
|
{
|
|
name: "proportional scaling: 5 -> 10",
|
|
deployment: newDeployment("foo", 10, nil, nil, nil, nil),
|
|
oldDeployment: newDeployment("foo", 5, nil, nil, nil, nil),
|
|
|
|
newRS: rs("foo-v2", 2, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v1", 3, nil, oldTimestamp)},
|
|
|
|
expectedNew: rs("foo-v2", 4, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v1", 6, nil, oldTimestamp)},
|
|
},
|
|
{
|
|
name: "proportional scaling: 5 -> 3",
|
|
deployment: newDeployment("foo", 3, nil, nil, nil, nil),
|
|
oldDeployment: newDeployment("foo", 5, nil, nil, nil, nil),
|
|
|
|
newRS: rs("foo-v2", 2, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v1", 3, nil, oldTimestamp)},
|
|
|
|
expectedNew: rs("foo-v2", 1, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v1", 2, nil, oldTimestamp)},
|
|
},
|
|
{
|
|
name: "proportional scaling: 9 -> 4",
|
|
deployment: newDeployment("foo", 4, nil, nil, nil, nil),
|
|
oldDeployment: newDeployment("foo", 9, nil, nil, nil, nil),
|
|
|
|
newRS: rs("foo-v2", 8, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v1", 1, nil, oldTimestamp)},
|
|
|
|
expectedNew: rs("foo-v2", 4, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v1", 0, nil, oldTimestamp)},
|
|
},
|
|
{
|
|
name: "proportional scaling: 7 -> 10",
|
|
deployment: newDeployment("foo", 10, nil, nil, nil, nil),
|
|
oldDeployment: newDeployment("foo", 7, nil, nil, nil, nil),
|
|
|
|
newRS: rs("foo-v3", 2, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v2", 3, nil, oldTimestamp), rs("foo-v1", 2, nil, olderTimestamp)},
|
|
|
|
expectedNew: rs("foo-v3", 3, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v2", 4, nil, oldTimestamp), rs("foo-v1", 3, nil, olderTimestamp)},
|
|
},
|
|
{
|
|
name: "proportional scaling: 13 -> 8",
|
|
deployment: newDeployment("foo", 8, nil, nil, nil, nil),
|
|
oldDeployment: newDeployment("foo", 13, nil, nil, nil, nil),
|
|
|
|
newRS: rs("foo-v3", 2, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v2", 8, nil, oldTimestamp), rs("foo-v1", 3, nil, olderTimestamp)},
|
|
|
|
expectedNew: rs("foo-v3", 1, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v2", 5, nil, oldTimestamp), rs("foo-v1", 2, nil, olderTimestamp)},
|
|
},
|
|
// Scales up the new replica set.
|
|
{
|
|
name: "leftover distribution: 3 -> 4",
|
|
deployment: newDeployment("foo", 4, nil, nil, nil, nil),
|
|
oldDeployment: newDeployment("foo", 3, nil, nil, nil, nil),
|
|
|
|
newRS: rs("foo-v3", 1, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v2", 1, nil, oldTimestamp), rs("foo-v1", 1, nil, olderTimestamp)},
|
|
|
|
expectedNew: rs("foo-v3", 2, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v2", 1, nil, oldTimestamp), rs("foo-v1", 1, nil, olderTimestamp)},
|
|
},
|
|
// Scales down the older replica set.
|
|
{
|
|
name: "leftover distribution: 3 -> 2",
|
|
deployment: newDeployment("foo", 2, nil, nil, nil, nil),
|
|
oldDeployment: newDeployment("foo", 3, nil, nil, nil, nil),
|
|
|
|
newRS: rs("foo-v3", 1, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v2", 1, nil, oldTimestamp), rs("foo-v1", 1, nil, olderTimestamp)},
|
|
|
|
expectedNew: rs("foo-v3", 1, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v2", 1, nil, oldTimestamp), rs("foo-v1", 0, nil, olderTimestamp)},
|
|
},
|
|
// Scales up the latest replica set first.
|
|
{
|
|
name: "proportional scaling (no new rs): 4 -> 5",
|
|
deployment: newDeployment("foo", 5, nil, nil, nil, nil),
|
|
oldDeployment: newDeployment("foo", 4, nil, nil, nil, nil),
|
|
|
|
newRS: nil,
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v2", 2, nil, oldTimestamp), rs("foo-v1", 2, nil, olderTimestamp)},
|
|
|
|
expectedNew: nil,
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v2", 3, nil, oldTimestamp), rs("foo-v1", 2, nil, olderTimestamp)},
|
|
},
|
|
// Scales down to zero
|
|
{
|
|
name: "proportional scaling: 6 -> 0",
|
|
deployment: newDeployment("foo", 0, nil, nil, nil, nil),
|
|
oldDeployment: newDeployment("foo", 6, nil, nil, nil, nil),
|
|
|
|
newRS: rs("foo-v3", 3, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v2", 2, nil, oldTimestamp), rs("foo-v1", 1, nil, olderTimestamp)},
|
|
|
|
expectedNew: rs("foo-v3", 0, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v2", 0, nil, oldTimestamp), rs("foo-v1", 0, nil, olderTimestamp)},
|
|
},
|
|
// Scales up from zero
|
|
{
|
|
name: "proportional scaling: 0 -> 6",
|
|
deployment: newDeployment("foo", 6, nil, nil, nil, nil),
|
|
oldDeployment: newDeployment("foo", 6, nil, nil, nil, nil),
|
|
|
|
newRS: rs("foo-v3", 0, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v2", 0, nil, oldTimestamp), rs("foo-v1", 0, nil, olderTimestamp)},
|
|
|
|
expectedNew: rs("foo-v3", 6, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v2", 0, nil, oldTimestamp), rs("foo-v1", 0, nil, olderTimestamp)},
|
|
wasntUpdated: map[string]bool{"foo-v2": true, "foo-v1": true},
|
|
},
|
|
// Scenario: deployment.spec.replicas == 3 ( foo-v1.spec.replicas == foo-v2.spec.replicas == foo-v3.spec.replicas == 1 )
|
|
// Deployment is scaled to 5. foo-v3.spec.replicas and foo-v2.spec.replicas should increment by 1 but foo-v2 fails to
|
|
// update.
|
|
{
|
|
name: "failed rs update",
|
|
deployment: newDeployment("foo", 5, nil, nil, nil, nil),
|
|
oldDeployment: newDeployment("foo", 5, nil, nil, nil, nil),
|
|
|
|
newRS: rs("foo-v3", 2, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v2", 1, nil, oldTimestamp), rs("foo-v1", 1, nil, olderTimestamp)},
|
|
|
|
expectedNew: rs("foo-v3", 2, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v2", 2, nil, oldTimestamp), rs("foo-v1", 1, nil, olderTimestamp)},
|
|
wasntUpdated: map[string]bool{"foo-v3": true, "foo-v1": true},
|
|
|
|
desiredReplicasAnnotations: map[string]int32{"foo-v2": int32(3)},
|
|
},
|
|
{
|
|
name: "deployment with surge pods",
|
|
deployment: newDeployment("foo", 20, nil, ptr.To(intstr.FromInt32(2)), nil, nil),
|
|
oldDeployment: newDeployment("foo", 10, nil, ptr.To(intstr.FromInt32(2)), nil, nil),
|
|
|
|
newRS: rs("foo-v2", 6, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v1", 6, nil, oldTimestamp)},
|
|
|
|
expectedNew: rs("foo-v2", 11, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v1", 11, nil, oldTimestamp)},
|
|
},
|
|
{
|
|
name: "change both surge and size",
|
|
deployment: newDeployment("foo", 50, nil, ptr.To(intstr.FromInt32(6)), nil, nil),
|
|
oldDeployment: newDeployment("foo", 10, nil, ptr.To(intstr.FromInt32(3)), nil, nil),
|
|
|
|
newRS: rs("foo-v2", 5, nil, newTimestamp),
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v1", 8, nil, oldTimestamp)},
|
|
|
|
expectedNew: rs("foo-v2", 22, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v1", 34, nil, oldTimestamp)},
|
|
},
|
|
{
|
|
name: "change both size and template",
|
|
deployment: updatedTemplate(14),
|
|
oldDeployment: newDeployment("foo", 10, nil, nil, nil, map[string]string{"foo": "bar"}),
|
|
|
|
newRS: nil,
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v2", 7, nil, newTimestamp), rs("foo-v1", 3, nil, oldTimestamp)},
|
|
|
|
expectedNew: nil,
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v2", 10, nil, newTimestamp), rs("foo-v1", 4, nil, oldTimestamp)},
|
|
},
|
|
{
|
|
name: "saturated but broken new replica set does not affect old pods",
|
|
deployment: newDeployment("foo", 2, nil, ptr.To(intstr.FromInt32(1)), ptr.To(intstr.FromInt32(1)), nil),
|
|
oldDeployment: newDeployment("foo", 2, nil, ptr.To(intstr.FromInt32(1)), ptr.To(intstr.FromInt32(1)), nil),
|
|
|
|
newRS: func() *apps.ReplicaSet {
|
|
rs := rs("foo-v2", 2, nil, newTimestamp)
|
|
rs.Status.AvailableReplicas = 0
|
|
return rs
|
|
}(),
|
|
oldRSs: []*apps.ReplicaSet{rs("foo-v1", 1, nil, oldTimestamp)},
|
|
|
|
expectedNew: rs("foo-v2", 2, nil, newTimestamp),
|
|
expectedOld: []*apps.ReplicaSet{rs("foo-v1", 1, nil, oldTimestamp)},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
_ = olderTimestamp
|
|
t.Log(test.name)
|
|
fake := fake.Clientset{}
|
|
dc := &DeploymentController{
|
|
client: &fake,
|
|
eventRecorder: &record.FakeRecorder{},
|
|
}
|
|
|
|
if test.newRS != nil {
|
|
desiredReplicas := *(test.oldDeployment.Spec.Replicas)
|
|
if desired, ok := test.desiredReplicasAnnotations[test.newRS.Name]; ok {
|
|
desiredReplicas = desired
|
|
}
|
|
deploymentutil.SetReplicasAnnotations(test.newRS, desiredReplicas, desiredReplicas+deploymentutil.MaxSurge(*test.oldDeployment))
|
|
}
|
|
for i := range test.oldRSs {
|
|
rs := test.oldRSs[i]
|
|
if rs == nil {
|
|
continue
|
|
}
|
|
desiredReplicas := *(test.oldDeployment.Spec.Replicas)
|
|
if desired, ok := test.desiredReplicasAnnotations[rs.Name]; ok {
|
|
desiredReplicas = desired
|
|
}
|
|
deploymentutil.SetReplicasAnnotations(rs, desiredReplicas, desiredReplicas+deploymentutil.MaxSurge(*test.oldDeployment))
|
|
}
|
|
|
|
_, ctx := ktesting.NewTestContext(t)
|
|
|
|
if err := dc.scale(ctx, test.deployment, test.newRS, test.oldRSs); err != nil {
|
|
t.Errorf("%s: unexpected error: %v", test.name, err)
|
|
return
|
|
}
|
|
|
|
// Construct the nameToSize map that will hold all the sizes we got our of tests
|
|
// Skip updating the map if the replica set wasn't updated since there will be
|
|
// no update action for it.
|
|
nameToSize := make(map[string]int32)
|
|
if test.newRS != nil {
|
|
nameToSize[test.newRS.Name] = *(test.newRS.Spec.Replicas)
|
|
}
|
|
for i := range test.oldRSs {
|
|
rs := test.oldRSs[i]
|
|
nameToSize[rs.Name] = *(rs.Spec.Replicas)
|
|
}
|
|
// Get all the UPDATE actions and update nameToSize with all the updated sizes.
|
|
for _, action := range fake.Actions() {
|
|
rs := action.(testclient.UpdateAction).GetObject().(*apps.ReplicaSet)
|
|
if !test.wasntUpdated[rs.Name] {
|
|
nameToSize[rs.Name] = *(rs.Spec.Replicas)
|
|
}
|
|
}
|
|
|
|
if test.expectedNew != nil && test.newRS != nil && *(test.expectedNew.Spec.Replicas) != nameToSize[test.newRS.Name] {
|
|
t.Errorf("%s: expected new replicas: %d, got: %d", test.name, *(test.expectedNew.Spec.Replicas), nameToSize[test.newRS.Name])
|
|
return
|
|
}
|
|
if len(test.expectedOld) != len(test.oldRSs) {
|
|
t.Errorf("%s: expected %d old replica sets, got %d", test.name, len(test.expectedOld), len(test.oldRSs))
|
|
return
|
|
}
|
|
for n := range test.oldRSs {
|
|
rs := test.oldRSs[n]
|
|
expected := test.expectedOld[n]
|
|
if *(expected.Spec.Replicas) != nameToSize[rs.Name] {
|
|
t.Errorf("%s: expected old (%s) replicas: %d, got: %d", test.name, rs.Name, *(expected.Spec.Replicas), nameToSize[rs.Name])
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDeploymentController_cleanupDeployment(t *testing.T) {
|
|
selector := map[string]string{"foo": "bar"}
|
|
alreadyDeleted := newRSWithStatus("foo-1", 0, 0, selector)
|
|
now := metav1.Now()
|
|
alreadyDeleted.DeletionTimestamp = &now
|
|
|
|
tests := []struct {
|
|
oldRSs []*apps.ReplicaSet
|
|
revisionHistoryLimit int32
|
|
expectedDeletions int
|
|
}{
|
|
{
|
|
oldRSs: []*apps.ReplicaSet{
|
|
newRSWithStatus("foo-1", 0, 0, selector),
|
|
newRSWithStatus("foo-2", 0, 0, selector),
|
|
newRSWithStatus("foo-3", 0, 0, selector),
|
|
},
|
|
revisionHistoryLimit: 1,
|
|
expectedDeletions: 2,
|
|
},
|
|
{
|
|
// Only delete the replica set with Spec.Replicas = Status.Replicas = 0.
|
|
oldRSs: []*apps.ReplicaSet{
|
|
newRSWithStatus("foo-1", 0, 0, selector),
|
|
newRSWithStatus("foo-2", 0, 1, selector),
|
|
newRSWithStatus("foo-3", 1, 0, selector),
|
|
newRSWithStatus("foo-4", 1, 1, selector),
|
|
},
|
|
revisionHistoryLimit: 0,
|
|
expectedDeletions: 1,
|
|
},
|
|
|
|
{
|
|
oldRSs: []*apps.ReplicaSet{
|
|
newRSWithStatus("foo-1", 0, 0, selector),
|
|
newRSWithStatus("foo-2", 0, 0, selector),
|
|
},
|
|
revisionHistoryLimit: 0,
|
|
expectedDeletions: 2,
|
|
},
|
|
{
|
|
oldRSs: []*apps.ReplicaSet{
|
|
newRSWithStatus("foo-1", 1, 1, selector),
|
|
newRSWithStatus("foo-2", 1, 1, selector),
|
|
},
|
|
revisionHistoryLimit: 0,
|
|
expectedDeletions: 0,
|
|
},
|
|
{
|
|
oldRSs: []*apps.ReplicaSet{
|
|
alreadyDeleted,
|
|
},
|
|
revisionHistoryLimit: 0,
|
|
expectedDeletions: 0,
|
|
},
|
|
{
|
|
// with unlimited revisionHistoryLimit
|
|
oldRSs: []*apps.ReplicaSet{
|
|
newRSWithStatus("foo-1", 0, 0, selector),
|
|
newRSWithStatus("foo-2", 0, 0, selector),
|
|
newRSWithStatus("foo-3", 0, 0, selector),
|
|
},
|
|
revisionHistoryLimit: math.MaxInt32,
|
|
expectedDeletions: 0,
|
|
},
|
|
}
|
|
|
|
for i := range tests {
|
|
test := tests[i]
|
|
t.Logf("scenario %d", i)
|
|
|
|
_, ctx := ktesting.NewTestContext(t)
|
|
|
|
fake := &fake.Clientset{}
|
|
informers := informers.NewSharedInformerFactory(fake, controller.NoResyncPeriodFunc())
|
|
controller, err := NewDeploymentController(ctx, informers.Apps().V1().Deployments(), informers.Apps().V1().ReplicaSets(), informers.Core().V1().Pods(), fake)
|
|
if err != nil {
|
|
t.Fatalf("error creating Deployment controller: %v", err)
|
|
}
|
|
|
|
controller.eventRecorder = &record.FakeRecorder{}
|
|
controller.dListerSynced = alwaysReady
|
|
controller.rsListerSynced = alwaysReady
|
|
controller.podListerSynced = alwaysReady
|
|
for _, rs := range test.oldRSs {
|
|
informers.Apps().V1().ReplicaSets().Informer().GetIndexer().Add(rs)
|
|
}
|
|
|
|
stopCh := make(chan struct{})
|
|
defer close(stopCh)
|
|
informers.StartWithContext(ctx)
|
|
informers.WaitForCacheSyncWithContext(ctx)
|
|
|
|
t.Logf(" &test.revisionHistoryLimit: %d", test.revisionHistoryLimit)
|
|
d := newDeployment("foo", 1, &test.revisionHistoryLimit, nil, nil, map[string]string{"foo": "bar"})
|
|
controller.cleanupDeployment(ctx, test.oldRSs, d)
|
|
|
|
gotDeletions := 0
|
|
for _, action := range fake.Actions() {
|
|
if action.GetVerb() == "delete" {
|
|
gotDeletions++
|
|
}
|
|
}
|
|
if gotDeletions != test.expectedDeletions {
|
|
t.Errorf("expect %v old replica sets been deleted, but got %v", test.expectedDeletions, gotDeletions)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDeploymentController_cleanupDeploymentOrder(t *testing.T) {
|
|
selector := map[string]string{"foo": "bar"}
|
|
now := metav1.Now()
|
|
duration := time.Minute
|
|
|
|
newRSWithRevisionAndCreationTimestamp := func(name string, replicas int32, selector map[string]string, timestamp time.Time, revision string) *apps.ReplicaSet {
|
|
rs := rs(name, replicas, selector, metav1.NewTime(timestamp))
|
|
if revision != "" {
|
|
rs.Annotations = map[string]string{
|
|
deploymentutil.RevisionAnnotation: revision,
|
|
}
|
|
}
|
|
rs.Status = apps.ReplicaSetStatus{
|
|
Replicas: int32(replicas),
|
|
}
|
|
return rs
|
|
}
|
|
|
|
// for all test cases, creationTimestamp order keeps as: rs1 < rs2 < rs3 < r4
|
|
tests := []struct {
|
|
oldRSs []*apps.ReplicaSet
|
|
revisionHistoryLimit int32
|
|
expectedDeletedRSs sets.String
|
|
}{
|
|
{
|
|
// revision order: rs1 < rs2, delete rs1
|
|
oldRSs: []*apps.ReplicaSet{
|
|
newRSWithRevisionAndCreationTimestamp("foo-1", 0, selector, now.Add(-1*duration), "1"),
|
|
newRSWithRevisionAndCreationTimestamp("foo-2", 0, selector, now.Time, "2"),
|
|
},
|
|
revisionHistoryLimit: 1,
|
|
expectedDeletedRSs: sets.NewString("foo-1"),
|
|
},
|
|
{
|
|
// revision order: rs2 < rs1, delete rs2
|
|
oldRSs: []*apps.ReplicaSet{
|
|
newRSWithRevisionAndCreationTimestamp("foo-1", 0, selector, now.Add(-1*duration), "2"),
|
|
newRSWithRevisionAndCreationTimestamp("foo-2", 0, selector, now.Time, "1"),
|
|
},
|
|
revisionHistoryLimit: 1,
|
|
expectedDeletedRSs: sets.NewString("foo-2"),
|
|
},
|
|
{
|
|
// rs1 has revision but rs2 doesn't have revision, delete rs2
|
|
oldRSs: []*apps.ReplicaSet{
|
|
newRSWithRevisionAndCreationTimestamp("foo-1", 0, selector, now.Add(-1*duration), "1"),
|
|
newRSWithRevisionAndCreationTimestamp("foo-2", 0, selector, now.Time, ""),
|
|
},
|
|
revisionHistoryLimit: 1,
|
|
expectedDeletedRSs: sets.NewString("foo-2"),
|
|
},
|
|
{
|
|
// rs1 doesn't have revision while rs2 has revision, delete rs1
|
|
oldRSs: []*apps.ReplicaSet{
|
|
newRSWithRevisionAndCreationTimestamp("foo-1", 0, selector, now.Add(-1*duration), ""),
|
|
newRSWithRevisionAndCreationTimestamp("foo-2", 0, selector, now.Time, "2"),
|
|
},
|
|
revisionHistoryLimit: 1,
|
|
expectedDeletedRSs: sets.NewString("foo-1"),
|
|
},
|
|
{
|
|
// revision order: rs1 < rs2 < r3, but rs1 has replicas, delete rs2
|
|
oldRSs: []*apps.ReplicaSet{
|
|
newRSWithRevisionAndCreationTimestamp("foo-1", 1, selector, now.Add(-1*duration), "1"),
|
|
newRSWithRevisionAndCreationTimestamp("foo-2", 0, selector, now.Time, "2"),
|
|
newRSWithRevisionAndCreationTimestamp("foo-3", 0, selector, now.Add(duration), "3"),
|
|
},
|
|
revisionHistoryLimit: 1,
|
|
expectedDeletedRSs: sets.NewString("foo-2"),
|
|
},
|
|
{
|
|
// revision order: rs1 < rs2 < r3, both rs1 && rs2 have replicas, don't delete
|
|
oldRSs: []*apps.ReplicaSet{
|
|
newRSWithRevisionAndCreationTimestamp("foo-1", 1, selector, now.Add(-1*duration), "1"),
|
|
newRSWithRevisionAndCreationTimestamp("foo-2", 1, selector, now.Time, "2"),
|
|
newRSWithRevisionAndCreationTimestamp("foo-3", 0, selector, now.Add(duration), "3"),
|
|
},
|
|
revisionHistoryLimit: 1,
|
|
expectedDeletedRSs: sets.NewString(),
|
|
},
|
|
{
|
|
// revision order: rs2 < rs4 < rs1 < rs3, delete rs2 && rs4
|
|
oldRSs: []*apps.ReplicaSet{
|
|
newRSWithRevisionAndCreationTimestamp("foo-1", 0, selector, now.Add(-1*duration), "3"),
|
|
newRSWithRevisionAndCreationTimestamp("foo-2", 0, selector, now.Time, "1"),
|
|
newRSWithRevisionAndCreationTimestamp("foo-3", 0, selector, now.Add(duration), "4"),
|
|
newRSWithRevisionAndCreationTimestamp("foo-4", 0, selector, now.Add(2*duration), "2"),
|
|
},
|
|
revisionHistoryLimit: 2,
|
|
expectedDeletedRSs: sets.NewString("foo-2", "foo-4"),
|
|
},
|
|
}
|
|
|
|
for i := range tests {
|
|
test := tests[i]
|
|
t.Logf("scenario %d", i)
|
|
|
|
_, ctx := ktesting.NewTestContext(t)
|
|
|
|
fake := &fake.Clientset{}
|
|
informers := informers.NewSharedInformerFactory(fake, controller.NoResyncPeriodFunc())
|
|
controller, err := NewDeploymentController(ctx, informers.Apps().V1().Deployments(), informers.Apps().V1().ReplicaSets(), informers.Core().V1().Pods(), fake)
|
|
if err != nil {
|
|
t.Fatalf("error creating Deployment controller: %v", err)
|
|
}
|
|
|
|
controller.eventRecorder = &record.FakeRecorder{}
|
|
controller.dListerSynced = alwaysReady
|
|
controller.rsListerSynced = alwaysReady
|
|
controller.podListerSynced = alwaysReady
|
|
for _, rs := range test.oldRSs {
|
|
informers.Apps().V1().ReplicaSets().Informer().GetIndexer().Add(rs)
|
|
}
|
|
|
|
stopCh := make(chan struct{})
|
|
defer close(stopCh)
|
|
informers.StartWithContext(ctx)
|
|
|
|
d := newDeployment("foo", 1, &test.revisionHistoryLimit, nil, nil, map[string]string{"foo": "bar"})
|
|
controller.cleanupDeployment(ctx, test.oldRSs, d)
|
|
|
|
deletedRSs := sets.String{}
|
|
for _, action := range fake.Actions() {
|
|
deleteAction, ok := action.(testclient.DeleteActionImpl)
|
|
if !ok {
|
|
t.Logf("Found not-delete action with verb %v. Ignoring.", action.GetVerb())
|
|
continue
|
|
}
|
|
|
|
if deleteAction.GetResource().Resource != "replicasets" {
|
|
continue
|
|
}
|
|
|
|
deletedRSs.Insert(deleteAction.GetName())
|
|
}
|
|
t.Logf("&test.revisionHistoryLimit: %d, &test.deletedReplicaSets: %v", test.revisionHistoryLimit, deletedRSs)
|
|
|
|
if !test.expectedDeletedRSs.Equal(deletedRSs) {
|
|
t.Errorf("expect to delete old replica sets %v, but got %v", test.expectedDeletedRSs, deletedRSs)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDeploymentController_generateReplicaSetName(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
deploymentName string
|
|
wantDeploymentPortion string
|
|
}{
|
|
{
|
|
name: "short name",
|
|
deploymentName: "my-deployment",
|
|
wantDeploymentPortion: "my-deployment",
|
|
},
|
|
{
|
|
name: "very long name truncated",
|
|
deploymentName: strings.Repeat("a", 250),
|
|
wantDeploymentPortion: strings.Repeat("a", 242),
|
|
},
|
|
{
|
|
name: "very long name not truncated",
|
|
deploymentName: strings.Repeat("a", 242),
|
|
wantDeploymentPortion: strings.Repeat("a", 242),
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
_, ctx := ktesting.NewTestContext(t)
|
|
|
|
fake := &fake.Clientset{}
|
|
informers := informers.NewSharedInformerFactory(fake, controller.NoResyncPeriodFunc())
|
|
controller, err := NewDeploymentController(ctx, informers.Apps().V1().Deployments(), informers.Apps().V1().ReplicaSets(), informers.Core().V1().Pods(), fake)
|
|
if err != nil {
|
|
t.Fatalf("error creating Deployment controller: %v", err)
|
|
}
|
|
|
|
controller.eventRecorder = &record.FakeRecorder{}
|
|
controller.dListerSynced = alwaysReady
|
|
controller.rsListerSynced = alwaysReady
|
|
controller.podListerSynced = alwaysReady
|
|
|
|
stopCh := make(chan struct{})
|
|
defer close(stopCh)
|
|
informers.StartWithContext(ctx)
|
|
|
|
d := newDeployment(test.deploymentName, 1, nil, nil, nil, map[string]string{"foo": "bar"})
|
|
|
|
if _, err := controller.getNewReplicaSet(ctx, d, []*apps.ReplicaSet{}, []*apps.ReplicaSet{}, true); err != nil {
|
|
t.Errorf("failed to create new ReplicaSet: %v", err)
|
|
return
|
|
}
|
|
|
|
rsName := ""
|
|
for _, action := range fake.Actions() {
|
|
if createAction, ok := action.(testclient.CreateAction); ok {
|
|
if createdRS, ok := createAction.GetObject().(*apps.ReplicaSet); ok {
|
|
if createdRS.Name != "" {
|
|
rsName = createdRS.Name
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(rsName) > validation.DNS1123SubdomainMaxLength {
|
|
t.Errorf("ReplicaSet name length %d, want <= %d", len(rsName), validation.DNS1123SubdomainMaxLength)
|
|
}
|
|
|
|
parts := strings.Split(rsName, "-")
|
|
if len(parts) < 2 {
|
|
t.Errorf("ReplicaSet name should contain at least one hyphen separator")
|
|
}
|
|
|
|
deploymentPortion := strings.Join(parts[:len(parts)-1], "-")
|
|
if len(test.deploymentName) <= 242 {
|
|
if len(deploymentPortion) != len(test.deploymentName) {
|
|
t.Errorf("Deployment name portion should be %d chars, got %d", len(test.deploymentName), len(deploymentPortion))
|
|
}
|
|
} else {
|
|
if len(deploymentPortion) != 242 {
|
|
t.Errorf("Truncated deployment name should be 242 chars, got %d", len(deploymentPortion))
|
|
}
|
|
}
|
|
|
|
if deploymentPortion != test.wantDeploymentPortion {
|
|
t.Errorf("Deployment name portion mismatch: got %q, want %q", deploymentPortion, test.wantDeploymentPortion)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGenerateReplicaSetName(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
deploymentName string
|
|
hash string
|
|
want string
|
|
}{
|
|
{
|
|
name: "short name",
|
|
deploymentName: "my-deployment",
|
|
hash: "abcde12345",
|
|
want: "my-deployment-abcde12345",
|
|
},
|
|
{
|
|
name: "maximum length without truncating",
|
|
deploymentName: strings.Repeat("a", 242),
|
|
hash: "abcde12345",
|
|
want: strings.Repeat("a", 242) + "-abcde12345",
|
|
},
|
|
{
|
|
name: "very long deployment name is truncated",
|
|
deploymentName: strings.Repeat("b", 250),
|
|
hash: "abcde12345",
|
|
want: strings.Repeat("b", 242) + "-abcde12345",
|
|
},
|
|
{
|
|
name: "very long hash is not truncated",
|
|
deploymentName: strings.Repeat("d", 252),
|
|
hash: strings.Repeat("h", 252),
|
|
want: strings.Repeat("d", 252) + "-" + strings.Repeat("h", 252),
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
got := generateReplicaSetName(test.deploymentName, test.hash)
|
|
|
|
if got != test.want {
|
|
t.Errorf("generateReplicaSetName(%q, %q) = %q, want %q", test.deploymentName, test.hash, got, test.want)
|
|
}
|
|
})
|
|
}
|
|
}
|