2016-05-04 05:31:26 +00:00
|
|
|
/*
|
2016-06-03 00:25:58 +00:00
|
|
|
Copyright 2015 The Kubernetes Authors.
|
2016-05-04 05:31:26 +00:00
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
2016-06-08 18:44:10 +00:00
|
|
|
package garbagecollector
|
2016-05-04 05:31:26 +00:00
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"strconv"
|
2016-05-18 03:24:42 +00:00
|
|
|
"strings"
|
2016-05-04 05:31:26 +00:00
|
|
|
"sync"
|
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
|
2017-06-22 18:24:23 +00:00
|
|
|
"k8s.io/api/core/v1"
|
2017-05-17 22:54:58 +00:00
|
|
|
apiextensionsv1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
|
|
|
|
apiextensionsclientset "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
|
|
|
|
apiextensionstestserver "k8s.io/apiextensions-apiserver/test/integration/testserver"
|
2017-02-23 19:16:25 +00:00
|
|
|
"k8s.io/apimachinery/pkg/api/errors"
|
2017-05-17 22:54:58 +00:00
|
|
|
"k8s.io/apimachinery/pkg/api/meta"
|
2017-01-11 14:09:48 +00:00
|
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
2017-05-17 22:54:58 +00:00
|
|
|
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
|
2017-01-11 14:09:48 +00:00
|
|
|
"k8s.io/apimachinery/pkg/types"
|
|
|
|
"k8s.io/apimachinery/pkg/util/wait"
|
2017-05-17 22:54:58 +00:00
|
|
|
"k8s.io/apiserver/pkg/storage/names"
|
2017-01-25 19:00:30 +00:00
|
|
|
"k8s.io/client-go/discovery"
|
2017-05-17 22:54:58 +00:00
|
|
|
cacheddiscovery "k8s.io/client-go/discovery/cached"
|
2017-01-25 19:00:30 +00:00
|
|
|
"k8s.io/client-go/dynamic"
|
2017-06-23 20:56:37 +00:00
|
|
|
"k8s.io/client-go/informers"
|
|
|
|
clientset "k8s.io/client-go/kubernetes"
|
2017-03-14 23:19:33 +00:00
|
|
|
"k8s.io/client-go/tools/cache"
|
2017-11-12 09:40:57 +00:00
|
|
|
kubeapiservertesting "k8s.io/kubernetes/cmd/kube-apiserver/app/testing"
|
2016-05-04 05:31:26 +00:00
|
|
|
"k8s.io/kubernetes/pkg/controller/garbagecollector"
|
2016-09-22 00:29:46 +00:00
|
|
|
"k8s.io/kubernetes/test/integration"
|
2017-11-12 09:40:57 +00:00
|
|
|
"k8s.io/kubernetes/test/integration/framework"
|
2016-05-04 05:31:26 +00:00
|
|
|
)
|
|
|
|
|
2017-02-23 19:16:25 +00:00
|
|
|
func getForegroundOptions() *metav1.DeleteOptions {
|
|
|
|
policy := metav1.DeletePropagationForeground
|
|
|
|
return &metav1.DeleteOptions{PropagationPolicy: &policy}
|
|
|
|
}
|
|
|
|
|
2017-01-24 15:38:21 +00:00
|
|
|
func getOrphanOptions() *metav1.DeleteOptions {
|
2016-05-18 03:24:42 +00:00
|
|
|
var trueVar = true
|
2017-01-24 15:38:21 +00:00
|
|
|
return &metav1.DeleteOptions{OrphanDependents: &trueVar}
|
2016-05-18 03:24:42 +00:00
|
|
|
}
|
|
|
|
|
2017-01-24 15:38:21 +00:00
|
|
|
func getNonOrphanOptions() *metav1.DeleteOptions {
|
2016-05-18 03:24:42 +00:00
|
|
|
var falseVar = false
|
2017-01-24 15:38:21 +00:00
|
|
|
return &metav1.DeleteOptions{OrphanDependents: &falseVar}
|
2016-05-18 03:24:42 +00:00
|
|
|
}
|
|
|
|
|
2016-05-04 05:31:26 +00:00
|
|
|
const garbageCollectedPodName = "test.pod.1"
|
|
|
|
const independentPodName = "test.pod.2"
|
|
|
|
const oneValidOwnerPodName = "test.pod.3"
|
|
|
|
const toBeDeletedRCName = "test.rc.1"
|
|
|
|
const remainingRCName = "test.rc.2"
|
|
|
|
|
2016-12-09 18:16:33 +00:00
|
|
|
func newPod(podName, podNamespace string, ownerReferences []metav1.OwnerReference) *v1.Pod {
|
2016-05-04 05:31:26 +00:00
|
|
|
for i := 0; i < len(ownerReferences); i++ {
|
2016-05-18 03:24:42 +00:00
|
|
|
if len(ownerReferences[i].Kind) == 0 {
|
|
|
|
ownerReferences[i].Kind = "ReplicationController"
|
|
|
|
}
|
2016-05-04 05:31:26 +00:00
|
|
|
ownerReferences[i].APIVersion = "v1"
|
|
|
|
}
|
|
|
|
return &v1.Pod{
|
2016-12-03 18:57:26 +00:00
|
|
|
TypeMeta: metav1.TypeMeta{
|
2016-05-04 05:31:26 +00:00
|
|
|
Kind: "Pod",
|
|
|
|
APIVersion: "v1",
|
|
|
|
},
|
2017-01-17 03:38:19 +00:00
|
|
|
ObjectMeta: metav1.ObjectMeta{
|
2016-05-04 05:31:26 +00:00
|
|
|
Name: podName,
|
2016-07-05 08:58:22 +00:00
|
|
|
Namespace: podNamespace,
|
2016-05-04 05:31:26 +00:00
|
|
|
OwnerReferences: ownerReferences,
|
|
|
|
},
|
|
|
|
Spec: v1.PodSpec{
|
|
|
|
Containers: []v1.Container{
|
|
|
|
{
|
|
|
|
Name: "fake-name",
|
|
|
|
Image: "fakeimage",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-05 08:58:22 +00:00
|
|
|
func newOwnerRC(name, namespace string) *v1.ReplicationController {
|
2016-05-04 05:31:26 +00:00
|
|
|
return &v1.ReplicationController{
|
2016-12-03 18:57:26 +00:00
|
|
|
TypeMeta: metav1.TypeMeta{
|
2016-05-04 05:31:26 +00:00
|
|
|
Kind: "ReplicationController",
|
|
|
|
APIVersion: "v1",
|
|
|
|
},
|
2017-01-17 03:38:19 +00:00
|
|
|
ObjectMeta: metav1.ObjectMeta{
|
2016-07-05 08:58:22 +00:00
|
|
|
Namespace: namespace,
|
2016-05-04 05:31:26 +00:00
|
|
|
Name: name,
|
|
|
|
},
|
|
|
|
Spec: v1.ReplicationControllerSpec{
|
|
|
|
Selector: map[string]string{"name": "test"},
|
|
|
|
Template: &v1.PodTemplateSpec{
|
2017-01-17 03:38:19 +00:00
|
|
|
ObjectMeta: metav1.ObjectMeta{
|
2016-05-04 05:31:26 +00:00
|
|
|
Labels: map[string]string{"name": "test"},
|
|
|
|
},
|
|
|
|
Spec: v1.PodSpec{
|
|
|
|
Containers: []v1.Container{
|
|
|
|
{
|
|
|
|
Name: "fake-name",
|
|
|
|
Image: "fakeimage",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
func newCRDInstance(definition *apiextensionsv1beta1.CustomResourceDefinition, namespace, name string) *unstructured.Unstructured {
|
|
|
|
return &unstructured.Unstructured{
|
|
|
|
Object: map[string]interface{}{
|
|
|
|
"kind": definition.Spec.Names.Kind,
|
|
|
|
"apiVersion": definition.Spec.Group + "/" + definition.Spec.Version,
|
|
|
|
"metadata": map[string]interface{}{
|
|
|
|
"name": name,
|
|
|
|
"namespace": namespace,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func newConfigMap(namespace, name string) *v1.ConfigMap {
|
|
|
|
return &v1.ConfigMap{
|
|
|
|
TypeMeta: metav1.TypeMeta{
|
|
|
|
Kind: "ConfigMap",
|
|
|
|
APIVersion: "v1",
|
|
|
|
},
|
|
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
|
|
Namespace: namespace,
|
|
|
|
Name: name,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func link(t *testing.T, owner, dependent metav1.Object) {
|
|
|
|
ownerType, err := meta.TypeAccessor(owner)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to get type info for %#v: %v", owner, err)
|
|
|
|
}
|
|
|
|
ref := metav1.OwnerReference{
|
|
|
|
Kind: ownerType.GetKind(),
|
|
|
|
APIVersion: ownerType.GetAPIVersion(),
|
|
|
|
Name: owner.GetName(),
|
|
|
|
UID: owner.GetUID(),
|
|
|
|
}
|
|
|
|
dependent.SetOwnerReferences(append(dependent.GetOwnerReferences(), ref))
|
|
|
|
}
|
|
|
|
|
|
|
|
func createRandomCustomResourceDefinition(
|
|
|
|
t *testing.T, apiExtensionClient apiextensionsclientset.Interface,
|
|
|
|
clientPool dynamic.ClientPool,
|
|
|
|
namespace string,
|
|
|
|
) (*apiextensionsv1beta1.CustomResourceDefinition, dynamic.ResourceInterface) {
|
|
|
|
// Create a random custom resource definition and ensure it's available for
|
|
|
|
// use.
|
|
|
|
definition := apiextensionstestserver.NewRandomNameCustomResourceDefinition(apiextensionsv1beta1.NamespaceScoped)
|
|
|
|
|
|
|
|
client, err := apiextensionstestserver.CreateNewCustomResourceDefinition(definition, apiExtensionClient, clientPool)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to create CustomResourceDefinition: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get a client for the custom resource.
|
|
|
|
resourceClient := client.Resource(&metav1.APIResource{
|
|
|
|
Name: definition.Spec.Names.Plural,
|
|
|
|
Namespaced: true,
|
|
|
|
}, namespace)
|
|
|
|
return definition, resourceClient
|
|
|
|
}
|
|
|
|
|
|
|
|
type testContext struct {
|
|
|
|
tearDown func()
|
|
|
|
gc *garbagecollector.GarbageCollector
|
|
|
|
clientSet clientset.Interface
|
|
|
|
apiExtensionClient apiextensionsclientset.Interface
|
|
|
|
clientPool dynamic.ClientPool
|
|
|
|
startGC func(workers int)
|
|
|
|
// syncPeriod is how often the GC started with startGC will be resynced.
|
|
|
|
syncPeriod time.Duration
|
|
|
|
}
|
|
|
|
|
|
|
|
// if workerCount > 0, will start the GC, otherwise it's up to the caller to Run() the GC.
|
|
|
|
func setup(t *testing.T, workerCount int) *testContext {
|
2017-12-14 20:43:37 +00:00
|
|
|
return setupWithServer(t, kubeapiservertesting.StartTestServerOrDie(t, nil, framework.SharedEtcd()), workerCount)
|
|
|
|
}
|
2017-05-17 22:54:58 +00:00
|
|
|
|
2017-12-14 20:43:37 +00:00
|
|
|
func setupWithServer(t *testing.T, result *kubeapiservertesting.TestServer, workerCount int) *testContext {
|
2017-11-12 09:40:57 +00:00
|
|
|
clientSet, err := clientset.NewForConfig(result.ClientConfig)
|
2017-05-17 22:54:58 +00:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("error creating clientset: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Helpful stuff for testing CRD.
|
2017-11-12 09:40:57 +00:00
|
|
|
apiExtensionClient, err := apiextensionsclientset.NewForConfig(result.ClientConfig)
|
2016-05-04 05:31:26 +00:00
|
|
|
if err != nil {
|
2017-05-17 22:54:58 +00:00
|
|
|
t.Fatalf("error creating extension clientset: %v", err)
|
2016-05-04 05:31:26 +00:00
|
|
|
}
|
2017-05-17 22:54:58 +00:00
|
|
|
// CreateNewCustomResourceDefinition wants to use this namespace for verifying
|
|
|
|
// namespace-scoped CRD creation.
|
|
|
|
createNamespaceOrDie("aval", clientSet, t)
|
|
|
|
|
|
|
|
discoveryClient := cacheddiscovery.NewMemCacheClient(clientSet.Discovery())
|
|
|
|
restMapper := discovery.NewDeferredDiscoveryRESTMapper(discoveryClient, meta.InterfacesForUnstructured)
|
|
|
|
restMapper.Reset()
|
2017-11-07 18:19:43 +00:00
|
|
|
deletableResources := garbagecollector.GetDeletableResources(discoveryClient)
|
2017-11-12 09:40:57 +00:00
|
|
|
config := *result.ClientConfig
|
2017-05-17 22:54:58 +00:00
|
|
|
config.ContentConfig = dynamic.ContentConfig()
|
|
|
|
metaOnlyClientPool := dynamic.NewClientPool(&config, restMapper, dynamic.LegacyAPIPathResolverFunc)
|
|
|
|
clientPool := dynamic.NewClientPool(&config, restMapper, dynamic.LegacyAPIPathResolverFunc)
|
2017-05-04 17:55:24 +00:00
|
|
|
sharedInformers := informers.NewSharedInformerFactory(clientSet, 0)
|
2017-08-24 16:39:55 +00:00
|
|
|
alwaysStarted := make(chan struct{})
|
|
|
|
close(alwaysStarted)
|
2017-05-16 17:35:45 +00:00
|
|
|
gc, err := garbagecollector.NewGarbageCollector(
|
|
|
|
metaOnlyClientPool,
|
|
|
|
clientPool,
|
2017-05-17 22:54:58 +00:00
|
|
|
restMapper,
|
|
|
|
deletableResources,
|
2017-05-16 17:35:45 +00:00
|
|
|
garbagecollector.DefaultIgnoredResources(),
|
|
|
|
sharedInformers,
|
2017-08-24 16:39:55 +00:00
|
|
|
alwaysStarted,
|
2017-05-16 17:35:45 +00:00
|
|
|
)
|
2016-05-04 05:31:26 +00:00
|
|
|
if err != nil {
|
2017-05-17 22:54:58 +00:00
|
|
|
t.Fatalf("failed to create garbage collector: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
stopCh := make(chan struct{})
|
|
|
|
tearDown := func() {
|
|
|
|
close(stopCh)
|
2017-11-12 09:40:57 +00:00
|
|
|
result.TearDownFn()
|
2016-05-04 05:31:26 +00:00
|
|
|
}
|
2017-05-17 22:54:58 +00:00
|
|
|
syncPeriod := 5 * time.Second
|
|
|
|
startGC := func(workers int) {
|
|
|
|
go gc.Run(workers, stopCh)
|
2017-08-08 19:57:55 +00:00
|
|
|
go gc.Sync(clientSet.Discovery(), syncPeriod, stopCh)
|
2017-05-17 22:54:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if workerCount > 0 {
|
|
|
|
startGC(workerCount)
|
|
|
|
}
|
|
|
|
|
|
|
|
return &testContext{
|
|
|
|
tearDown: tearDown,
|
|
|
|
gc: gc,
|
|
|
|
clientSet: clientSet,
|
|
|
|
apiExtensionClient: apiExtensionClient,
|
|
|
|
clientPool: clientPool,
|
|
|
|
startGC: startGC,
|
|
|
|
syncPeriod: syncPeriod,
|
|
|
|
}
|
|
|
|
}
|
2017-05-04 17:55:24 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
func createNamespaceOrDie(name string, c clientset.Interface, t *testing.T) *v1.Namespace {
|
|
|
|
ns := &v1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: name}}
|
2017-10-25 15:54:32 +00:00
|
|
|
if _, err := c.CoreV1().Namespaces().Create(ns); err != nil {
|
2017-05-17 22:54:58 +00:00
|
|
|
t.Fatalf("failed to create namespace: %v", err)
|
|
|
|
}
|
|
|
|
falseVar := false
|
2017-10-25 15:54:32 +00:00
|
|
|
_, err := c.CoreV1().ServiceAccounts(ns.Name).Create(&v1.ServiceAccount{
|
2017-05-17 22:54:58 +00:00
|
|
|
ObjectMeta: metav1.ObjectMeta{Name: "default"},
|
|
|
|
AutomountServiceAccountToken: &falseVar,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to create service account: %v", err)
|
|
|
|
}
|
|
|
|
return ns
|
|
|
|
}
|
2017-05-04 17:55:24 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
func deleteNamespaceOrDie(name string, c clientset.Interface, t *testing.T) {
|
|
|
|
zero := int64(0)
|
|
|
|
background := metav1.DeletePropagationBackground
|
2017-10-25 15:54:32 +00:00
|
|
|
err := c.CoreV1().Namespaces().Delete(name, &metav1.DeleteOptions{GracePeriodSeconds: &zero, PropagationPolicy: &background})
|
2017-05-17 22:54:58 +00:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to delete namespace %q: %v", name, err)
|
|
|
|
}
|
2016-05-04 05:31:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// This test simulates the cascading deletion.
|
|
|
|
func TestCascadingDeletion(t *testing.T) {
|
2017-05-17 22:54:58 +00:00
|
|
|
ctx := setup(t, 5)
|
|
|
|
defer ctx.tearDown()
|
2017-05-04 17:55:24 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
gc, clientSet := ctx.gc, ctx.clientSet
|
2016-07-05 08:58:22 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
ns := createNamespaceOrDie("gc-cascading-deletion", clientSet, t)
|
|
|
|
defer deleteNamespaceOrDie(ns.Name, clientSet, t)
|
2016-07-05 08:58:22 +00:00
|
|
|
|
2017-10-25 15:54:32 +00:00
|
|
|
rcClient := clientSet.CoreV1().ReplicationControllers(ns.Name)
|
|
|
|
podClient := clientSet.CoreV1().Pods(ns.Name)
|
2016-05-04 05:31:26 +00:00
|
|
|
|
2016-07-05 08:58:22 +00:00
|
|
|
toBeDeletedRC, err := rcClient.Create(newOwnerRC(toBeDeletedRCName, ns.Name))
|
2016-05-04 05:31:26 +00:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create replication controller: %v", err)
|
|
|
|
}
|
2016-07-05 08:58:22 +00:00
|
|
|
remainingRC, err := rcClient.Create(newOwnerRC(remainingRCName, ns.Name))
|
2016-05-04 05:31:26 +00:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create replication controller: %v", err)
|
|
|
|
}
|
|
|
|
|
2017-01-22 03:36:02 +00:00
|
|
|
rcs, err := rcClient.List(metav1.ListOptions{})
|
2016-05-04 05:31:26 +00:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to list replication controllers: %v", err)
|
|
|
|
}
|
|
|
|
if len(rcs.Items) != 2 {
|
|
|
|
t.Fatalf("Expect only 2 replication controller")
|
|
|
|
}
|
|
|
|
|
|
|
|
// this pod should be cascadingly deleted.
|
2016-12-09 18:16:33 +00:00
|
|
|
pod := newPod(garbageCollectedPodName, ns.Name, []metav1.OwnerReference{{UID: toBeDeletedRC.ObjectMeta.UID, Name: toBeDeletedRCName}})
|
2016-05-04 05:31:26 +00:00
|
|
|
_, err = podClient.Create(pod)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create Pod: %v", err)
|
|
|
|
}
|
|
|
|
|
2016-06-18 15:51:56 +00:00
|
|
|
// this pod shouldn't be cascadingly deleted, because it has a valid reference.
|
2016-12-09 18:16:33 +00:00
|
|
|
pod = newPod(oneValidOwnerPodName, ns.Name, []metav1.OwnerReference{
|
2016-05-04 05:31:26 +00:00
|
|
|
{UID: toBeDeletedRC.ObjectMeta.UID, Name: toBeDeletedRCName},
|
|
|
|
{UID: remainingRC.ObjectMeta.UID, Name: remainingRCName},
|
|
|
|
})
|
|
|
|
_, err = podClient.Create(pod)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create Pod: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// this pod shouldn't be cascadingly deleted, because it doesn't have an owner.
|
2016-12-09 18:16:33 +00:00
|
|
|
pod = newPod(independentPodName, ns.Name, []metav1.OwnerReference{})
|
2016-05-04 05:31:26 +00:00
|
|
|
_, err = podClient.Create(pod)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create Pod: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// set up watch
|
2017-01-22 03:36:02 +00:00
|
|
|
pods, err := podClient.List(metav1.ListOptions{})
|
2016-05-04 05:31:26 +00:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to list pods: %v", err)
|
|
|
|
}
|
|
|
|
if len(pods.Items) != 3 {
|
|
|
|
t.Fatalf("Expect only 3 pods")
|
|
|
|
}
|
|
|
|
// delete one of the replication controller
|
2016-08-17 21:23:09 +00:00
|
|
|
if err := rcClient.Delete(toBeDeletedRCName, getNonOrphanOptions()); err != nil {
|
2016-05-04 05:31:26 +00:00
|
|
|
t.Fatalf("failed to delete replication controller: %v", err)
|
|
|
|
}
|
2016-05-17 16:31:32 +00:00
|
|
|
// sometimes the deletion of the RC takes long time to be observed by
|
|
|
|
// the gc, so wait for the garbage collector to observe the deletion of
|
|
|
|
// the toBeDeletedRC
|
2017-11-25 06:05:10 +00:00
|
|
|
if err := wait.Poll(1*time.Second, 60*time.Second, func() (bool, error) {
|
2016-05-17 16:31:32 +00:00
|
|
|
return !gc.GraphHasUID([]types.UID{toBeDeletedRC.ObjectMeta.UID}), nil
|
|
|
|
}); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2017-11-25 06:05:10 +00:00
|
|
|
if err := integration.WaitForPodToDisappear(podClient, garbageCollectedPodName, 1*time.Second, 30*time.Second); err != nil {
|
2016-09-22 00:29:46 +00:00
|
|
|
t.Fatalf("expect pod %s to be garbage collected, got err= %v", garbageCollectedPodName, err)
|
2016-05-17 16:31:32 +00:00
|
|
|
}
|
2016-09-22 00:29:46 +00:00
|
|
|
// checks the garbage collect doesn't delete pods it shouldn't delete.
|
2016-12-07 14:40:26 +00:00
|
|
|
if _, err := podClient.Get(independentPodName, metav1.GetOptions{}); err != nil {
|
2016-05-04 05:31:26 +00:00
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2016-12-07 14:40:26 +00:00
|
|
|
if _, err := podClient.Get(oneValidOwnerPodName, metav1.GetOptions{}); err != nil {
|
2016-05-04 05:31:26 +00:00
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// This test simulates the case where an object is created with an owner that
|
|
|
|
// doesn't exist. It verifies the GC will delete such an object.
|
2016-06-17 14:20:49 +00:00
|
|
|
func TestCreateWithNonExistentOwner(t *testing.T) {
|
2017-05-17 22:54:58 +00:00
|
|
|
ctx := setup(t, 5)
|
|
|
|
defer ctx.tearDown()
|
2016-07-05 08:58:22 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
clientSet := ctx.clientSet
|
|
|
|
|
|
|
|
ns := createNamespaceOrDie("gc-non-existing-owner", clientSet, t)
|
|
|
|
defer deleteNamespaceOrDie(ns.Name, clientSet, t)
|
2016-07-05 08:58:22 +00:00
|
|
|
|
2017-10-25 15:54:32 +00:00
|
|
|
podClient := clientSet.CoreV1().Pods(ns.Name)
|
2016-05-04 05:31:26 +00:00
|
|
|
|
2016-12-09 18:16:33 +00:00
|
|
|
pod := newPod(garbageCollectedPodName, ns.Name, []metav1.OwnerReference{{UID: "doesn't matter", Name: toBeDeletedRCName}})
|
2016-05-04 05:31:26 +00:00
|
|
|
_, err := podClient.Create(pod)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create Pod: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// set up watch
|
2017-01-22 03:36:02 +00:00
|
|
|
pods, err := podClient.List(metav1.ListOptions{})
|
2016-05-04 05:31:26 +00:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to list pods: %v", err)
|
|
|
|
}
|
2017-08-21 13:25:50 +00:00
|
|
|
if len(pods.Items) > 1 {
|
|
|
|
t.Fatalf("Unexpected pod list: %v", pods.Items)
|
2016-05-04 05:31:26 +00:00
|
|
|
}
|
2016-09-22 00:29:46 +00:00
|
|
|
// wait for the garbage collector to delete the pod
|
2017-11-25 06:05:10 +00:00
|
|
|
if err := integration.WaitForPodToDisappear(podClient, garbageCollectedPodName, 1*time.Second, 30*time.Second); err != nil {
|
2016-09-22 00:29:46 +00:00
|
|
|
t.Fatalf("expect pod %s to be garbage collected, got err= %v", garbageCollectedPodName, err)
|
2016-05-04 05:31:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-24 15:38:21 +00:00
|
|
|
func setupRCsPods(t *testing.T, gc *garbagecollector.GarbageCollector, clientSet clientset.Interface, nameSuffix, namespace string, initialFinalizers []string, options *metav1.DeleteOptions, wg *sync.WaitGroup, rcUIDs chan types.UID) {
|
2016-05-04 05:31:26 +00:00
|
|
|
defer wg.Done()
|
2017-10-25 15:54:32 +00:00
|
|
|
rcClient := clientSet.CoreV1().ReplicationControllers(namespace)
|
|
|
|
podClient := clientSet.CoreV1().Pods(namespace)
|
2016-05-04 05:31:26 +00:00
|
|
|
// create rc.
|
2016-05-18 03:24:42 +00:00
|
|
|
rcName := "test.rc." + nameSuffix
|
2016-07-05 08:58:22 +00:00
|
|
|
rc := newOwnerRC(rcName, namespace)
|
2016-05-18 03:24:42 +00:00
|
|
|
rc.ObjectMeta.Finalizers = initialFinalizers
|
|
|
|
rc, err := rcClient.Create(rc)
|
2016-05-04 05:31:26 +00:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create replication controller: %v", err)
|
|
|
|
}
|
2016-05-18 03:24:42 +00:00
|
|
|
rcUIDs <- rc.ObjectMeta.UID
|
|
|
|
// create pods.
|
|
|
|
var podUIDs []types.UID
|
2016-05-04 05:31:26 +00:00
|
|
|
for j := 0; j < 3; j++ {
|
2016-05-18 03:24:42 +00:00
|
|
|
podName := "test.pod." + nameSuffix + "-" + strconv.Itoa(j)
|
2016-12-09 18:16:33 +00:00
|
|
|
pod := newPod(podName, namespace, []metav1.OwnerReference{{UID: rc.ObjectMeta.UID, Name: rc.ObjectMeta.Name}})
|
2016-05-04 05:31:26 +00:00
|
|
|
_, err = podClient.Create(pod)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create Pod: %v", err)
|
|
|
|
}
|
2016-05-18 03:24:42 +00:00
|
|
|
podUIDs = append(podUIDs, pod.ObjectMeta.UID)
|
|
|
|
}
|
2017-02-23 19:16:25 +00:00
|
|
|
orphan := (options != nil && options.OrphanDependents != nil && *options.OrphanDependents) || (options == nil && len(initialFinalizers) != 0 && initialFinalizers[0] == metav1.FinalizerOrphanDependents)
|
2016-05-18 03:24:42 +00:00
|
|
|
// if we intend to orphan the pods, we need wait for the gc to observe the
|
|
|
|
// creation of the pods, otherwise if the deletion of RC is observed before
|
|
|
|
// the creation of the pods, the pods will not be orphaned.
|
|
|
|
if orphan {
|
2017-11-25 06:05:10 +00:00
|
|
|
wait.Poll(1*time.Second, 60*time.Second, func() (bool, error) { return gc.GraphHasUID(podUIDs), nil })
|
2016-05-04 05:31:26 +00:00
|
|
|
}
|
|
|
|
// delete the rc
|
2016-05-18 03:24:42 +00:00
|
|
|
if err := rcClient.Delete(rc.ObjectMeta.Name, options); err != nil {
|
2016-05-04 05:31:26 +00:00
|
|
|
t.Fatalf("failed to delete replication controller: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-05 08:58:22 +00:00
|
|
|
func verifyRemainingObjects(t *testing.T, clientSet clientset.Interface, namespace string, rcNum, podNum int) (bool, error) {
|
2017-10-25 15:54:32 +00:00
|
|
|
rcClient := clientSet.CoreV1().ReplicationControllers(namespace)
|
|
|
|
podClient := clientSet.CoreV1().Pods(namespace)
|
2017-01-22 03:36:02 +00:00
|
|
|
pods, err := podClient.List(metav1.ListOptions{})
|
2016-05-04 05:31:26 +00:00
|
|
|
if err != nil {
|
|
|
|
return false, fmt.Errorf("Failed to list pods: %v", err)
|
|
|
|
}
|
2016-05-18 03:24:42 +00:00
|
|
|
var ret = true
|
|
|
|
if len(pods.Items) != podNum {
|
|
|
|
ret = false
|
|
|
|
t.Logf("expect %d pods, got %d pods", podNum, len(pods.Items))
|
2016-05-04 05:31:26 +00:00
|
|
|
}
|
2017-01-22 03:36:02 +00:00
|
|
|
rcs, err := rcClient.List(metav1.ListOptions{})
|
2016-05-04 05:31:26 +00:00
|
|
|
if err != nil {
|
|
|
|
return false, fmt.Errorf("Failed to list replication controllers: %v", err)
|
|
|
|
}
|
2016-05-18 03:24:42 +00:00
|
|
|
if len(rcs.Items) != rcNum {
|
|
|
|
ret = false
|
|
|
|
t.Logf("expect %d RCs, got %d RCs", rcNum, len(rcs.Items))
|
2016-05-04 05:31:26 +00:00
|
|
|
}
|
2016-05-18 03:24:42 +00:00
|
|
|
return ret, nil
|
2016-05-04 05:31:26 +00:00
|
|
|
}
|
|
|
|
|
2016-06-07 22:57:48 +00:00
|
|
|
// The stress test is not very stressful, because we need to control the running
|
|
|
|
// time of our pre-submit tests to increase submit-queue throughput. We'll add
|
|
|
|
// e2e tests that put more stress.
|
2016-05-04 05:31:26 +00:00
|
|
|
func TestStressingCascadingDeletion(t *testing.T) {
|
2017-05-17 22:54:58 +00:00
|
|
|
ctx := setup(t, 5)
|
|
|
|
defer ctx.tearDown()
|
2016-07-05 08:58:22 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
gc, clientSet := ctx.gc, ctx.clientSet
|
2016-07-05 08:58:22 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
ns := createNamespaceOrDie("gc-stressing-cascading-deletion", clientSet, t)
|
|
|
|
defer deleteNamespaceOrDie(ns.Name, clientSet, t)
|
2016-05-04 05:31:26 +00:00
|
|
|
|
2016-06-07 22:57:48 +00:00
|
|
|
const collections = 10
|
2016-05-04 05:31:26 +00:00
|
|
|
var wg sync.WaitGroup
|
2016-05-18 03:24:42 +00:00
|
|
|
wg.Add(collections * 4)
|
|
|
|
rcUIDs := make(chan types.UID, collections*4)
|
2016-05-04 05:31:26 +00:00
|
|
|
for i := 0; i < collections; i++ {
|
2016-08-17 21:23:09 +00:00
|
|
|
// rc is created with empty finalizers, deleted with nil delete options, pods will remain.
|
2016-07-05 08:58:22 +00:00
|
|
|
go setupRCsPods(t, gc, clientSet, "collection1-"+strconv.Itoa(i), ns.Name, []string{}, nil, &wg, rcUIDs)
|
2016-05-18 03:24:42 +00:00
|
|
|
// rc is created with the orphan finalizer, deleted with nil options, pods will remain.
|
2017-02-23 19:16:25 +00:00
|
|
|
go setupRCsPods(t, gc, clientSet, "collection2-"+strconv.Itoa(i), ns.Name, []string{metav1.FinalizerOrphanDependents}, nil, &wg, rcUIDs)
|
2016-05-18 03:24:42 +00:00
|
|
|
// rc is created with the orphan finalizer, deleted with DeleteOptions.OrphanDependents=false, pods will be deleted.
|
2017-02-23 19:16:25 +00:00
|
|
|
go setupRCsPods(t, gc, clientSet, "collection3-"+strconv.Itoa(i), ns.Name, []string{metav1.FinalizerOrphanDependents}, getNonOrphanOptions(), &wg, rcUIDs)
|
2016-05-18 03:24:42 +00:00
|
|
|
// rc is created with empty finalizers, deleted with DeleteOptions.OrphanDependents=true, pods will remain.
|
2016-07-05 08:58:22 +00:00
|
|
|
go setupRCsPods(t, gc, clientSet, "collection4-"+strconv.Itoa(i), ns.Name, []string{}, getOrphanOptions(), &wg, rcUIDs)
|
2016-05-04 05:31:26 +00:00
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
t.Logf("all pods are created, all replications controllers are created then deleted")
|
2016-09-22 00:29:46 +00:00
|
|
|
// wait for the RCs and Pods to reach the expected numbers.
|
2017-11-25 06:05:10 +00:00
|
|
|
if err := wait.Poll(1*time.Second, 300*time.Second, func() (bool, error) {
|
2016-05-18 03:24:42 +00:00
|
|
|
podsInEachCollection := 3
|
|
|
|
// see the comments on the calls to setupRCsPods for details
|
2016-08-17 21:23:09 +00:00
|
|
|
remainingGroups := 3
|
2016-07-05 08:58:22 +00:00
|
|
|
return verifyRemainingObjects(t, clientSet, ns.Name, 0, collections*podsInEachCollection*remainingGroups)
|
2016-05-04 05:31:26 +00:00
|
|
|
}); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2016-05-18 03:24:42 +00:00
|
|
|
t.Logf("number of remaining replication controllers and pods are as expected")
|
|
|
|
|
|
|
|
// verify the remaining pods all have "orphan" in their names.
|
2017-10-25 15:54:32 +00:00
|
|
|
podClient := clientSet.CoreV1().Pods(ns.Name)
|
2017-01-22 03:36:02 +00:00
|
|
|
pods, err := podClient.List(metav1.ListOptions{})
|
2016-05-18 03:24:42 +00:00
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
for _, pod := range pods.Items {
|
2016-08-17 21:23:09 +00:00
|
|
|
if !strings.Contains(pod.ObjectMeta.Name, "collection1-") && !strings.Contains(pod.ObjectMeta.Name, "collection2-") && !strings.Contains(pod.ObjectMeta.Name, "collection4-") {
|
2016-05-18 03:24:42 +00:00
|
|
|
t.Errorf("got unexpected remaining pod: %#v", pod)
|
|
|
|
}
|
|
|
|
}
|
2016-05-04 05:31:26 +00:00
|
|
|
|
|
|
|
// verify there is no node representing replication controllers in the gc's graph
|
|
|
|
uids := make([]types.UID, 0, collections)
|
|
|
|
for i := 0; i < collections; i++ {
|
|
|
|
uid := <-rcUIDs
|
|
|
|
uids = append(uids, uid)
|
|
|
|
}
|
|
|
|
if gc.GraphHasUID(uids) {
|
|
|
|
t.Errorf("Expect all nodes representing replication controllers are removed from the Propagator's graph")
|
|
|
|
}
|
|
|
|
}
|
2016-05-18 03:24:42 +00:00
|
|
|
|
|
|
|
func TestOrphaning(t *testing.T) {
|
2017-05-17 22:54:58 +00:00
|
|
|
ctx := setup(t, 5)
|
|
|
|
defer ctx.tearDown()
|
2017-05-04 17:55:24 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
gc, clientSet := ctx.gc, ctx.clientSet
|
2016-07-05 08:58:22 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
ns := createNamespaceOrDie("gc-orphaning", clientSet, t)
|
|
|
|
defer deleteNamespaceOrDie(ns.Name, clientSet, t)
|
2016-07-05 08:58:22 +00:00
|
|
|
|
2017-10-25 15:54:32 +00:00
|
|
|
podClient := clientSet.CoreV1().Pods(ns.Name)
|
|
|
|
rcClient := clientSet.CoreV1().ReplicationControllers(ns.Name)
|
2016-05-18 03:24:42 +00:00
|
|
|
// create the RC with the orphan finalizer set
|
2016-07-05 08:58:22 +00:00
|
|
|
toBeDeletedRC := newOwnerRC(toBeDeletedRCName, ns.Name)
|
2016-05-18 03:24:42 +00:00
|
|
|
toBeDeletedRC, err := rcClient.Create(toBeDeletedRC)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create replication controller: %v", err)
|
|
|
|
}
|
|
|
|
|
2016-12-14 14:03:00 +00:00
|
|
|
// these pods should be orphaned.
|
2016-05-18 03:24:42 +00:00
|
|
|
var podUIDs []types.UID
|
|
|
|
podsNum := 3
|
|
|
|
for i := 0; i < podsNum; i++ {
|
|
|
|
podName := garbageCollectedPodName + strconv.Itoa(i)
|
2016-12-09 18:16:33 +00:00
|
|
|
pod := newPod(podName, ns.Name, []metav1.OwnerReference{{UID: toBeDeletedRC.ObjectMeta.UID, Name: toBeDeletedRCName}})
|
2016-05-18 03:24:42 +00:00
|
|
|
_, err = podClient.Create(pod)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create Pod: %v", err)
|
|
|
|
}
|
|
|
|
podUIDs = append(podUIDs, pod.ObjectMeta.UID)
|
|
|
|
}
|
|
|
|
|
|
|
|
// we need wait for the gc to observe the creation of the pods, otherwise if
|
|
|
|
// the deletion of RC is observed before the creation of the pods, the pods
|
|
|
|
// will not be orphaned.
|
2017-11-25 06:05:10 +00:00
|
|
|
wait.Poll(1*time.Second, 60*time.Second, func() (bool, error) { return gc.GraphHasUID(podUIDs), nil })
|
2016-05-18 03:24:42 +00:00
|
|
|
|
|
|
|
err = rcClient.Delete(toBeDeletedRCName, getOrphanOptions())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to gracefully delete the rc: %v", err)
|
|
|
|
}
|
2016-09-22 00:29:46 +00:00
|
|
|
// verify the toBeDeleteRC is deleted
|
2017-11-25 06:05:10 +00:00
|
|
|
if err := wait.PollImmediate(1*time.Second, 30*time.Second, func() (bool, error) {
|
2017-01-22 03:36:02 +00:00
|
|
|
rcs, err := rcClient.List(metav1.ListOptions{})
|
2016-09-22 00:29:46 +00:00
|
|
|
if err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
if len(rcs.Items) == 0 {
|
|
|
|
t.Logf("Still has %d RCs", len(rcs.Items))
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
return false, nil
|
2016-05-18 03:24:42 +00:00
|
|
|
}); err != nil {
|
2016-09-22 00:29:46 +00:00
|
|
|
t.Errorf("unexpected error: %v", err)
|
2016-05-18 03:24:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// verify pods don't have the ownerPod as an owner anymore
|
2017-01-22 03:36:02 +00:00
|
|
|
pods, err := podClient.List(metav1.ListOptions{})
|
2016-05-18 03:24:42 +00:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to list pods: %v", err)
|
|
|
|
}
|
|
|
|
if len(pods.Items) != podsNum {
|
|
|
|
t.Errorf("Expect %d pod(s), but got %#v", podsNum, pods)
|
|
|
|
}
|
|
|
|
for _, pod := range pods.Items {
|
|
|
|
if len(pod.ObjectMeta.OwnerReferences) != 0 {
|
2016-12-14 14:03:00 +00:00
|
|
|
t.Errorf("pod %s still has non-empty OwnerReferences: %v", pod.ObjectMeta.Name, pod.ObjectMeta.OwnerReferences)
|
2016-05-18 03:24:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-02-23 19:16:25 +00:00
|
|
|
|
|
|
|
func TestSolidOwnerDoesNotBlockWaitingOwner(t *testing.T) {
|
2017-05-17 22:54:58 +00:00
|
|
|
ctx := setup(t, 5)
|
|
|
|
defer ctx.tearDown()
|
2017-05-04 17:55:24 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
clientSet := ctx.clientSet
|
2017-02-23 19:16:25 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
ns := createNamespaceOrDie("gc-foreground1", clientSet, t)
|
|
|
|
defer deleteNamespaceOrDie(ns.Name, clientSet, t)
|
2017-02-23 19:16:25 +00:00
|
|
|
|
2017-10-25 15:54:32 +00:00
|
|
|
podClient := clientSet.CoreV1().Pods(ns.Name)
|
|
|
|
rcClient := clientSet.CoreV1().ReplicationControllers(ns.Name)
|
2017-02-23 19:16:25 +00:00
|
|
|
// create the RC with the orphan finalizer set
|
|
|
|
toBeDeletedRC, err := rcClient.Create(newOwnerRC(toBeDeletedRCName, ns.Name))
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create replication controller: %v", err)
|
|
|
|
}
|
|
|
|
remainingRC, err := rcClient.Create(newOwnerRC(remainingRCName, ns.Name))
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create replication controller: %v", err)
|
|
|
|
}
|
|
|
|
trueVar := true
|
|
|
|
pod := newPod("pod", ns.Name, []metav1.OwnerReference{
|
|
|
|
{UID: toBeDeletedRC.ObjectMeta.UID, Name: toBeDeletedRC.Name, BlockOwnerDeletion: &trueVar},
|
|
|
|
{UID: remainingRC.ObjectMeta.UID, Name: remainingRC.Name},
|
|
|
|
})
|
|
|
|
_, err = podClient.Create(pod)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create Pod: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = rcClient.Delete(toBeDeletedRCName, getForegroundOptions())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to delete the rc: %v", err)
|
|
|
|
}
|
|
|
|
// verify the toBeDeleteRC is deleted
|
2017-11-25 06:05:10 +00:00
|
|
|
if err := wait.PollImmediate(1*time.Second, 30*time.Second, func() (bool, error) {
|
2017-02-23 19:16:25 +00:00
|
|
|
_, err := rcClient.Get(toBeDeletedRC.Name, metav1.GetOptions{})
|
|
|
|
if err != nil {
|
|
|
|
if errors.IsNotFound(err) {
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
return false, nil
|
|
|
|
}); err != nil {
|
|
|
|
t.Errorf("unexpected error: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// verify pods don't have the toBeDeleteRC as an owner anymore
|
|
|
|
pod, err = podClient.Get("pod", metav1.GetOptions{})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to list pods: %v", err)
|
|
|
|
}
|
|
|
|
if len(pod.ObjectMeta.OwnerReferences) != 1 {
|
|
|
|
t.Errorf("expect pod to have only one ownerReference: got %#v", pod.ObjectMeta.OwnerReferences)
|
|
|
|
} else if pod.ObjectMeta.OwnerReferences[0].Name != remainingRC.Name {
|
|
|
|
t.Errorf("expect pod to have an ownerReference pointing to %s, got %#v", remainingRC.Name, pod.ObjectMeta.OwnerReferences)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestNonBlockingOwnerRefDoesNotBlock(t *testing.T) {
|
2017-05-17 22:54:58 +00:00
|
|
|
ctx := setup(t, 5)
|
|
|
|
defer ctx.tearDown()
|
2017-05-04 17:55:24 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
clientSet := ctx.clientSet
|
2017-02-23 19:16:25 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
ns := createNamespaceOrDie("gc-foreground2", clientSet, t)
|
|
|
|
defer deleteNamespaceOrDie(ns.Name, clientSet, t)
|
2017-02-23 19:16:25 +00:00
|
|
|
|
2017-10-25 15:54:32 +00:00
|
|
|
podClient := clientSet.CoreV1().Pods(ns.Name)
|
|
|
|
rcClient := clientSet.CoreV1().ReplicationControllers(ns.Name)
|
2017-02-23 19:16:25 +00:00
|
|
|
// create the RC with the orphan finalizer set
|
|
|
|
toBeDeletedRC, err := rcClient.Create(newOwnerRC(toBeDeletedRCName, ns.Name))
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create replication controller: %v", err)
|
|
|
|
}
|
|
|
|
// BlockingOwnerDeletion is not set
|
|
|
|
pod1 := newPod("pod1", ns.Name, []metav1.OwnerReference{
|
|
|
|
{UID: toBeDeletedRC.ObjectMeta.UID, Name: toBeDeletedRC.Name},
|
|
|
|
})
|
|
|
|
// adding finalizer that no controller handles, so that the pod won't be deleted
|
|
|
|
pod1.ObjectMeta.Finalizers = []string{"x/y"}
|
|
|
|
// BlockingOwnerDeletion is false
|
|
|
|
falseVar := false
|
|
|
|
pod2 := newPod("pod2", ns.Name, []metav1.OwnerReference{
|
|
|
|
{UID: toBeDeletedRC.ObjectMeta.UID, Name: toBeDeletedRC.Name, BlockOwnerDeletion: &falseVar},
|
|
|
|
})
|
|
|
|
// adding finalizer that no controller handles, so that the pod won't be deleted
|
|
|
|
pod2.ObjectMeta.Finalizers = []string{"x/y"}
|
|
|
|
_, err = podClient.Create(pod1)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create Pod: %v", err)
|
|
|
|
}
|
|
|
|
_, err = podClient.Create(pod2)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create Pod: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = rcClient.Delete(toBeDeletedRCName, getForegroundOptions())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to delete the rc: %v", err)
|
|
|
|
}
|
|
|
|
// verify the toBeDeleteRC is deleted
|
2017-11-25 06:05:10 +00:00
|
|
|
if err := wait.PollImmediate(1*time.Second, 30*time.Second, func() (bool, error) {
|
2017-02-23 19:16:25 +00:00
|
|
|
_, err := rcClient.Get(toBeDeletedRC.Name, metav1.GetOptions{})
|
|
|
|
if err != nil {
|
|
|
|
if errors.IsNotFound(err) {
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
return false, nil
|
|
|
|
}); err != nil {
|
|
|
|
t.Errorf("unexpected error: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// verify pods are still there
|
|
|
|
pods, err := podClient.List(metav1.ListOptions{})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to list pods: %v", err)
|
|
|
|
}
|
|
|
|
if len(pods.Items) != 2 {
|
|
|
|
t.Errorf("expect there to be 2 pods, got %#v", pods.Items)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestBlockingOwnerRefDoesBlock(t *testing.T) {
|
2017-05-17 22:54:58 +00:00
|
|
|
ctx := setup(t, 0)
|
|
|
|
defer ctx.tearDown()
|
|
|
|
gc, clientSet := ctx.gc, ctx.clientSet
|
2017-02-23 19:16:25 +00:00
|
|
|
|
2017-05-17 22:54:58 +00:00
|
|
|
ns := createNamespaceOrDie("foo", clientSet, t)
|
|
|
|
defer deleteNamespaceOrDie(ns.Name, clientSet, t)
|
2017-02-23 19:16:25 +00:00
|
|
|
|
2017-10-25 15:54:32 +00:00
|
|
|
podClient := clientSet.CoreV1().Pods(ns.Name)
|
|
|
|
rcClient := clientSet.CoreV1().ReplicationControllers(ns.Name)
|
2017-02-23 19:16:25 +00:00
|
|
|
// create the RC with the orphan finalizer set
|
|
|
|
toBeDeletedRC, err := rcClient.Create(newOwnerRC(toBeDeletedRCName, ns.Name))
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create replication controller: %v", err)
|
|
|
|
}
|
|
|
|
trueVar := true
|
|
|
|
pod := newPod("pod", ns.Name, []metav1.OwnerReference{
|
|
|
|
{UID: toBeDeletedRC.ObjectMeta.UID, Name: toBeDeletedRC.Name, BlockOwnerDeletion: &trueVar},
|
|
|
|
})
|
|
|
|
// adding finalizer that no controller handles, so that the pod won't be deleted
|
|
|
|
pod.ObjectMeta.Finalizers = []string{"x/y"}
|
|
|
|
_, err = podClient.Create(pod)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to create Pod: %v", err)
|
|
|
|
}
|
|
|
|
|
2017-03-14 23:19:33 +00:00
|
|
|
// this makes sure the garbage collector will have added the pod to its
|
|
|
|
// dependency graph before handling the foreground deletion of the rc.
|
2017-05-17 22:54:58 +00:00
|
|
|
ctx.startGC(5)
|
2017-03-14 23:19:33 +00:00
|
|
|
timeout := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
select {
|
|
|
|
case <-time.After(5 * time.Second):
|
|
|
|
close(timeout)
|
|
|
|
}
|
|
|
|
}()
|
2017-05-17 22:54:58 +00:00
|
|
|
if !cache.WaitForCacheSync(timeout, gc.IsSynced) {
|
2017-03-14 23:19:33 +00:00
|
|
|
t.Fatalf("failed to wait for garbage collector to be synced")
|
|
|
|
}
|
|
|
|
|
2017-02-23 19:16:25 +00:00
|
|
|
err = rcClient.Delete(toBeDeletedRCName, getForegroundOptions())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to delete the rc: %v", err)
|
|
|
|
}
|
2017-05-17 22:54:58 +00:00
|
|
|
time.Sleep(15 * time.Second)
|
2017-02-23 19:16:25 +00:00
|
|
|
// verify the toBeDeleteRC is NOT deleted
|
|
|
|
_, err = rcClient.Get(toBeDeletedRC.Name, metav1.GetOptions{})
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("unexpected error: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// verify pods are still there
|
|
|
|
pods, err := podClient.List(metav1.ListOptions{})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to list pods: %v", err)
|
|
|
|
}
|
|
|
|
if len(pods.Items) != 1 {
|
|
|
|
t.Errorf("expect there to be 1 pods, got %#v", pods.Items)
|
|
|
|
}
|
|
|
|
}
|
2017-05-17 22:54:58 +00:00
|
|
|
|
|
|
|
// TestCustomResourceCascadingDeletion ensures the basic cascading delete
|
|
|
|
// behavior supports custom resources.
|
|
|
|
func TestCustomResourceCascadingDeletion(t *testing.T) {
|
|
|
|
ctx := setup(t, 5)
|
|
|
|
defer ctx.tearDown()
|
|
|
|
|
|
|
|
clientSet, apiExtensionClient, clientPool := ctx.clientSet, ctx.apiExtensionClient, ctx.clientPool
|
|
|
|
|
|
|
|
ns := createNamespaceOrDie("crd-cascading", clientSet, t)
|
|
|
|
|
|
|
|
definition, resourceClient := createRandomCustomResourceDefinition(t, apiExtensionClient, clientPool, ns.Name)
|
|
|
|
|
|
|
|
// Create a custom owner resource.
|
|
|
|
owner := newCRDInstance(definition, ns.Name, names.SimpleNameGenerator.GenerateName("owner"))
|
|
|
|
owner, err := resourceClient.Create(owner)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to create owner resource %q: %v", owner.GetName(), err)
|
|
|
|
}
|
|
|
|
t.Logf("created owner resource %q", owner.GetName())
|
|
|
|
|
|
|
|
// Create a custom dependent resource.
|
|
|
|
dependent := newCRDInstance(definition, ns.Name, names.SimpleNameGenerator.GenerateName("dependent"))
|
|
|
|
link(t, owner, dependent)
|
|
|
|
|
|
|
|
dependent, err = resourceClient.Create(dependent)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to create dependent resource %q: %v", dependent.GetName(), err)
|
|
|
|
}
|
|
|
|
t.Logf("created dependent resource %q", dependent.GetName())
|
|
|
|
|
|
|
|
// Delete the owner.
|
|
|
|
foreground := metav1.DeletePropagationForeground
|
|
|
|
err = resourceClient.Delete(owner.GetName(), &metav1.DeleteOptions{PropagationPolicy: &foreground})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to delete owner resource %q: %v", owner.GetName(), err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure the owner is deleted.
|
2017-11-25 06:05:10 +00:00
|
|
|
if err := wait.Poll(1*time.Second, 60*time.Second, func() (bool, error) {
|
2017-05-17 22:54:58 +00:00
|
|
|
_, err := resourceClient.Get(owner.GetName(), metav1.GetOptions{})
|
|
|
|
return errors.IsNotFound(err), nil
|
|
|
|
}); err != nil {
|
|
|
|
t.Fatalf("failed waiting for owner resource %q to be deleted", owner.GetName())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure the dependent is deleted.
|
|
|
|
_, err = resourceClient.Get(dependent.GetName(), metav1.GetOptions{})
|
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("expected dependent %q to be deleted", dependent.GetName())
|
|
|
|
} else {
|
|
|
|
if !errors.IsNotFound(err) {
|
|
|
|
t.Fatalf("unexpected error getting dependent %q: %v", dependent.GetName(), err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestMixedRelationships ensures that owner/dependent relationships work
|
|
|
|
// between core and custom resources.
|
|
|
|
//
|
|
|
|
// TODO: Consider how this could be represented with table-style tests (e.g. a
|
2018-02-09 06:53:53 +00:00
|
|
|
// before/after expected object graph given a delete operation targeting a
|
2017-05-17 22:54:58 +00:00
|
|
|
// specific node in the before graph with certain delete options).
|
|
|
|
func TestMixedRelationships(t *testing.T) {
|
|
|
|
ctx := setup(t, 5)
|
|
|
|
defer ctx.tearDown()
|
|
|
|
|
|
|
|
clientSet, apiExtensionClient, clientPool := ctx.clientSet, ctx.apiExtensionClient, ctx.clientPool
|
|
|
|
|
|
|
|
ns := createNamespaceOrDie("crd-mixed", clientSet, t)
|
|
|
|
|
2017-10-25 15:54:32 +00:00
|
|
|
configMapClient := clientSet.CoreV1().ConfigMaps(ns.Name)
|
2017-05-17 22:54:58 +00:00
|
|
|
|
|
|
|
definition, resourceClient := createRandomCustomResourceDefinition(t, apiExtensionClient, clientPool, ns.Name)
|
|
|
|
|
|
|
|
// Create a custom owner resource.
|
|
|
|
customOwner, err := resourceClient.Create(newCRDInstance(definition, ns.Name, names.SimpleNameGenerator.GenerateName("owner")))
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to create owner: %v", err)
|
|
|
|
}
|
|
|
|
t.Logf("created custom owner %q", customOwner.GetName())
|
|
|
|
|
|
|
|
// Create a core dependent resource.
|
|
|
|
coreDependent := newConfigMap(ns.Name, names.SimpleNameGenerator.GenerateName("dependent"))
|
|
|
|
link(t, customOwner, coreDependent)
|
|
|
|
coreDependent, err = configMapClient.Create(coreDependent)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to create dependent: %v", err)
|
|
|
|
}
|
|
|
|
t.Logf("created core dependent %q", coreDependent.GetName())
|
|
|
|
|
|
|
|
// Create a core owner resource.
|
|
|
|
coreOwner, err := configMapClient.Create(newConfigMap(ns.Name, names.SimpleNameGenerator.GenerateName("owner")))
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to create owner: %v", err)
|
|
|
|
}
|
|
|
|
t.Logf("created core owner %q: %#v", coreOwner.GetName(), coreOwner)
|
|
|
|
|
|
|
|
// Create a custom dependent resource.
|
|
|
|
customDependent := newCRDInstance(definition, ns.Name, names.SimpleNameGenerator.GenerateName("dependent"))
|
|
|
|
coreOwner.TypeMeta.Kind = "ConfigMap"
|
|
|
|
coreOwner.TypeMeta.APIVersion = "v1"
|
|
|
|
link(t, coreOwner, customDependent)
|
|
|
|
customDependent, err = resourceClient.Create(customDependent)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to create dependent: %v", err)
|
|
|
|
}
|
|
|
|
t.Logf("created custom dependent %q", customDependent.GetName())
|
|
|
|
|
|
|
|
// Delete the custom owner.
|
|
|
|
foreground := metav1.DeletePropagationForeground
|
|
|
|
err = resourceClient.Delete(customOwner.GetName(), &metav1.DeleteOptions{PropagationPolicy: &foreground})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to delete owner resource %q: %v", customOwner.GetName(), err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure the owner is deleted.
|
2017-11-25 06:05:10 +00:00
|
|
|
if err := wait.Poll(1*time.Second, 60*time.Second, func() (bool, error) {
|
2017-05-17 22:54:58 +00:00
|
|
|
_, err := resourceClient.Get(customOwner.GetName(), metav1.GetOptions{})
|
|
|
|
return errors.IsNotFound(err), nil
|
|
|
|
}); err != nil {
|
|
|
|
t.Fatalf("failed waiting for owner resource %q to be deleted", customOwner.GetName())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure the dependent is deleted.
|
|
|
|
_, err = resourceClient.Get(coreDependent.GetName(), metav1.GetOptions{})
|
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("expected dependent %q to be deleted", coreDependent.GetName())
|
|
|
|
} else {
|
|
|
|
if !errors.IsNotFound(err) {
|
|
|
|
t.Fatalf("unexpected error getting dependent %q: %v", coreDependent.GetName(), err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Delete the core owner.
|
|
|
|
err = configMapClient.Delete(coreOwner.GetName(), &metav1.DeleteOptions{PropagationPolicy: &foreground})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to delete owner resource %q: %v", coreOwner.GetName(), err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure the owner is deleted.
|
2017-11-25 06:05:10 +00:00
|
|
|
if err := wait.Poll(1*time.Second, 60*time.Second, func() (bool, error) {
|
2017-05-17 22:54:58 +00:00
|
|
|
_, err := configMapClient.Get(coreOwner.GetName(), metav1.GetOptions{})
|
|
|
|
return errors.IsNotFound(err), nil
|
|
|
|
}); err != nil {
|
|
|
|
t.Fatalf("failed waiting for owner resource %q to be deleted", coreOwner.GetName())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure the dependent is deleted.
|
|
|
|
_, err = resourceClient.Get(customDependent.GetName(), metav1.GetOptions{})
|
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("expected dependent %q to be deleted", customDependent.GetName())
|
|
|
|
} else {
|
|
|
|
if !errors.IsNotFound(err) {
|
|
|
|
t.Fatalf("unexpected error getting dependent %q: %v", customDependent.GetName(), err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestCRDDeletionCascading ensures propagating deletion of a custom resource
|
|
|
|
// definition with an instance that owns a core resource.
|
|
|
|
func TestCRDDeletionCascading(t *testing.T) {
|
|
|
|
ctx := setup(t, 5)
|
|
|
|
defer ctx.tearDown()
|
|
|
|
|
|
|
|
clientSet, apiExtensionClient, clientPool := ctx.clientSet, ctx.apiExtensionClient, ctx.clientPool
|
|
|
|
|
|
|
|
ns := createNamespaceOrDie("crd-mixed", clientSet, t)
|
|
|
|
|
2017-10-25 15:54:32 +00:00
|
|
|
configMapClient := clientSet.CoreV1().ConfigMaps(ns.Name)
|
2017-05-17 22:54:58 +00:00
|
|
|
|
|
|
|
definition, resourceClient := createRandomCustomResourceDefinition(t, apiExtensionClient, clientPool, ns.Name)
|
|
|
|
|
|
|
|
// Create a custom owner resource.
|
|
|
|
owner, err := resourceClient.Create(newCRDInstance(definition, ns.Name, names.SimpleNameGenerator.GenerateName("owner")))
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to create owner: %v", err)
|
|
|
|
}
|
|
|
|
t.Logf("created owner %q", owner.GetName())
|
|
|
|
|
|
|
|
// Create a core dependent resource.
|
|
|
|
dependent := newConfigMap(ns.Name, names.SimpleNameGenerator.GenerateName("dependent"))
|
|
|
|
link(t, owner, dependent)
|
|
|
|
dependent, err = configMapClient.Create(dependent)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to create dependent: %v", err)
|
|
|
|
}
|
|
|
|
t.Logf("created dependent %q", dependent.GetName())
|
|
|
|
|
|
|
|
time.Sleep(ctx.syncPeriod + 5*time.Second)
|
|
|
|
|
|
|
|
// Delete the definition, which should cascade to the owner and ultimately its dependents.
|
|
|
|
if err := apiextensionstestserver.DeleteCustomResourceDefinition(definition, apiExtensionClient); err != nil {
|
|
|
|
t.Fatalf("failed to delete %q: %v", definition.Name, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure the owner is deleted.
|
2017-11-25 06:05:10 +00:00
|
|
|
if err := wait.Poll(1*time.Second, 60*time.Second, func() (bool, error) {
|
2017-05-17 22:54:58 +00:00
|
|
|
_, err := resourceClient.Get(owner.GetName(), metav1.GetOptions{})
|
|
|
|
return errors.IsNotFound(err), nil
|
|
|
|
}); err != nil {
|
|
|
|
t.Fatalf("failed waiting for owner %q to be deleted", owner.GetName())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure the dependent is deleted.
|
2017-11-25 06:05:10 +00:00
|
|
|
if err := wait.Poll(1*time.Second, 60*time.Second, func() (bool, error) {
|
2017-05-17 22:54:58 +00:00
|
|
|
_, err := configMapClient.Get(dependent.GetName(), metav1.GetOptions{})
|
|
|
|
return errors.IsNotFound(err), nil
|
|
|
|
}); err != nil {
|
|
|
|
t.Fatalf("failed waiting for dependent %q (owned by %q) to be deleted", dependent.GetName(), owner.GetName())
|
|
|
|
}
|
|
|
|
}
|