gc changes

pkg/controller/controller_ref_manager.go

@@ -191,7 +191,7 @@ func (m *PodControllerRefManager) AdoptPod(pod *v1.Pod) error {
 	// Note that ValidateOwnerReferences() will reject this patch if another
 	// OwnerReference exists with controller=true.
 	addControllerPatch := fmt.Sprintf(
-		`{"metadata":{"ownerReferences":[{"apiVersion":"%s","kind":"%s","name":"%s","uid":"%s","controller":true}],"uid":"%s"}}`,
+		`{"metadata":{"ownerReferences":[{"apiVersion":"%s","kind":"%s","name":"%s","uid":"%s","controller":true,"blockOwnerDeletion":true}],"uid":"%s"}}`,
 		m.controllerKind.GroupVersion(), m.controllerKind.Kind,
 		m.controller.GetName(), m.controller.GetUID(), pod.UID)
 	return m.podControl.PatchPod(pod.Namespace, pod.Name, []byte(addControllerPatch))

pkg/controller/controller_utils.go

@@ -483,6 +483,9 @@ func (r RealPodControl) CreatePodsWithControllerRef(namespace string, template *
 	if controllerRef.Controller == nil || *controllerRef.Controller != true {
 		return fmt.Errorf("controllerRef.Controller is not set")
 	}
+	if controllerRef.BlockOwnerDeletion == nil || *controllerRef.BlockOwnerDeletion != true {
+		return fmt.Errorf("controllerRef.BlockOwnerDeletion is not set")
+	}
 	return r.createPods("", namespace, template, controllerObject, controllerRef)
 }
 

pkg/controller/garbagecollector/garbagecollector_test.go

@@ -19,6 +19,7 @@ package garbagecollector
 import (
 	"net/http"
 	"net/http/httptest"
+	"reflect"
 	"strings"
 	"sync"
 	"testing"
@@ -27,15 +28,16 @@ import (
 
 	_ "k8s.io/kubernetes/pkg/api/install"
 
+	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/json"
 	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/apimachinery/pkg/util/strategicpatch"
 	"k8s.io/client-go/dynamic"
 	restclient "k8s.io/client-go/rest"
-	"k8s.io/client-go/util/clock"
 	"k8s.io/client-go/util/workqueue"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/v1"
@@ -53,7 +55,7 @@ func TestNewGarbageCollector(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	assert.Equal(t, 1, len(gc.monitors))
+	assert.Equal(t, 1, len(gc.dependencyGraphBuilder.monitors))
 }
 
 // fakeAction records information about requests to aid in testing.
@@ -142,8 +144,8 @@ func serilizeOrDie(t *testing.T, object interface{}) []byte {
 	return data
 }
 
-// test the processItem function making the expected actions.
-func TestProcessItem(t *testing.T) {
+// test the attemptToDeleteItem function making the expected actions.
+func TestAttemptToDeleteItem(t *testing.T) {
 	pod := getPod("ToBeDeletedPod", []metav1.OwnerReference{
 		{
 			Kind:       "ReplicationController",
@@ -177,10 +179,10 @@ func TestProcessItem(t *testing.T) {
 			},
 			Namespace: pod.Namespace,
 		},
-		// owners are intentionally left empty. The processItem routine should get the latest item from the server.
+		// owners are intentionally left empty. The attemptToDeleteItem routine should get the latest item from the server.
 		owners: nil,
 	}
-	err := gc.processItem(item)
+	err := gc.attemptToDeleteItem(item)
 	if err != nil {
 		t.Errorf("Unexpected Error: %v", err)
 	}
@@ -249,7 +251,7 @@ func TestProcessEvent(t *testing.T) {
 	var testScenarios = []struct {
 		name string
 		// a series of events that will be supplied to the
-		// Propagator.eventQueue.
+		// GraphBuilder.eventQueue.
 		events []event
 	}{
 		{
@@ -293,22 +295,19 @@ func TestProcessEvent(t *testing.T) {
 	}
 
 	for _, scenario := range testScenarios {
-		propagator := &Propagator{
-			eventQueue: workqueue.NewTimedWorkQueue(),
+		dependencyGraphBuilder := &GraphBuilder{
+			graphChanges: workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter()),
 			uidToNode: &concurrentUIDToNode{
-				RWMutex:   &sync.RWMutex{},
-				uidToNode: make(map[types.UID]*node),
-			},
-			gc: &GarbageCollector{
-				dirtyQueue:       workqueue.NewTimedWorkQueue(),
-				clock:            clock.RealClock{},
-				absentOwnerCache: NewUIDCache(2),
+				uidToNodeLock: sync.RWMutex{},
+				uidToNode:     make(map[types.UID]*node),
 			},
+			attemptToDelete:  workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter()),
+			absentOwnerCache: NewUIDCache(2),
 		}
 		for i := 0; i < len(scenario.events); i++ {
-			propagator.eventQueue.Add(&workqueue.TimedWorkQueueItem{StartTime: propagator.gc.clock.Now(), Object: &scenario.events[i]})
-			propagator.processEvent()
-			verifyGraphInvariants(scenario.name, propagator.uidToNode.uidToNode, t)
+			dependencyGraphBuilder.graphChanges.Add(&scenario.events[i])
+			dependencyGraphBuilder.processGraphChanges()
+			verifyGraphInvariants(scenario.name, dependencyGraphBuilder.uidToNode.uidToNode, t)
 		}
 	}
 }
@@ -321,18 +320,18 @@ func TestDependentsRace(t *testing.T) {
 	const updates = 100
 	owner := &node{dependents: make(map[*node]struct{})}
 	ownerUID := types.UID("owner")
-	gc.propagator.uidToNode.Write(owner)
+	gc.dependencyGraphBuilder.uidToNode.Write(owner)
 	go func() {
 		for i := 0; i < updates; i++ {
 			dependent := &node{}
-			gc.propagator.addDependentToOwners(dependent, []metav1.OwnerReference{{UID: ownerUID}})
-			gc.propagator.removeDependentFromOwners(dependent, []metav1.OwnerReference{{UID: ownerUID}})
+			gc.dependencyGraphBuilder.addDependentToOwners(dependent, []metav1.OwnerReference{{UID: ownerUID}})
+			gc.dependencyGraphBuilder.removeDependentFromOwners(dependent, []metav1.OwnerReference{{UID: ownerUID}})
 		}
 	}()
 	go func() {
-		gc.orphanQueue.Add(&workqueue.TimedWorkQueueItem{StartTime: gc.clock.Now(), Object: owner})
+		gc.attemptToOrphan.Add(owner)
 		for i := 0; i < updates; i++ {
-			gc.orphanFinalizer()
+			gc.attemptToOrphanWorker()
 		}
 	}()
 }
@@ -348,9 +347,13 @@ func TestGCListWatcher(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	lw := gcListWatcher(client, podResource)
-	lw.Watch(metav1.ListOptions{ResourceVersion: "1"})
-	lw.List(metav1.ListOptions{ResourceVersion: "1"})
+	lw := listWatcher(client, podResource)
+	if _, err := lw.Watch(metav1.ListOptions{ResourceVersion: "1"}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := lw.List(metav1.ListOptions{ResourceVersion: "1"}); err != nil {
+		t.Fatal(err)
+	}
 	if e, a := 2, len(testHandler.actions); e != a {
 		t.Errorf("expect %d requests, got %d", e, a)
 	}
@@ -373,7 +376,7 @@ func podToGCNode(pod *v1.Pod) *node {
 			},
 			Namespace: pod.Namespace,
 		},
-		// owners are intentionally left empty. The processItem routine should get the latest item from the server.
+		// owners are intentionally left empty. The attemptToDeleteItem routine should get the latest item from the server.
 		owners: nil,
 	}
 }
@@ -447,12 +450,12 @@ func TestAbsentUIDCache(t *testing.T) {
 	defer srv.Close()
 	gc := setupGC(t, clientConfig)
 	gc.absentOwnerCache = NewUIDCache(2)
-	gc.processItem(podToGCNode(rc1Pod1))
-	gc.processItem(podToGCNode(rc2Pod1))
+	gc.attemptToDeleteItem(podToGCNode(rc1Pod1))
+	gc.attemptToDeleteItem(podToGCNode(rc2Pod1))
 	// rc1 should already be in the cache, no request should be sent. rc1 should be promoted in the UIDCache
-	gc.processItem(podToGCNode(rc1Pod2))
+	gc.attemptToDeleteItem(podToGCNode(rc1Pod2))
 	// after this call, rc2 should be evicted from the UIDCache
-	gc.processItem(podToGCNode(rc3Pod1))
+	gc.attemptToDeleteItem(podToGCNode(rc3Pod1))
 	// check cache
 	if !gc.absentOwnerCache.Has(types.UID("1")) {
 		t.Errorf("expected rc1 to be in the cache")
@@ -474,3 +477,89 @@ func TestAbsentUIDCache(t *testing.T) {
 		t.Errorf("expected only 1 GET rc1 request, got %d", count)
 	}
 }
+
+func TestDeleteOwnerRefPatch(t *testing.T) {
+	original := v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			UID: "100",
+			OwnerReferences: []metav1.OwnerReference{
+				{UID: "1"},
+				{UID: "2"},
+				{UID: "3"},
+			},
+		},
+	}
+	originalData := serilizeOrDie(t, original)
+	expected := v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			UID: "100",
+			OwnerReferences: []metav1.OwnerReference{
+				{UID: "1"},
+			},
+		},
+	}
+	patch := deleteOwnerRefPatch("100", "2", "3")
+	patched, err := strategicpatch.StrategicMergePatch(originalData, patch, v1.Pod{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got v1.Pod
+	if err := json.Unmarshal(patched, &got); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(expected, got) {
+		t.Errorf("expected: %#v,\ngot: %#v", expected, got)
+	}
+}
+
+func TestUnblockOwnerReference(t *testing.T) {
+	trueVar := true
+	falseVar := false
+	original := v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			UID: "100",
+			OwnerReferences: []metav1.OwnerReference{
+				{UID: "1", BlockOwnerDeletion: &trueVar},
+				{UID: "2", BlockOwnerDeletion: &falseVar},
+				{UID: "3"},
+			},
+		},
+	}
+	originalData := serilizeOrDie(t, original)
+	expected := v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			UID: "100",
+			OwnerReferences: []metav1.OwnerReference{
+				{UID: "1", BlockOwnerDeletion: &falseVar},
+				{UID: "2", BlockOwnerDeletion: &falseVar},
+				{UID: "3"},
+			},
+		},
+	}
+	accessor, err := meta.Accessor(&original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	n := node{
+		owners: accessor.GetOwnerReferences(),
+	}
+	patch, err := n.patchToUnblockOwnerReferences()
+	if err != nil {
+		t.Fatal(err)
+	}
+	patched, err := strategicpatch.StrategicMergePatch(originalData, patch, v1.Pod{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got v1.Pod
+	if err := json.Unmarshal(patched, &got); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(expected, got) {
+		t.Errorf("expected: %#v,\ngot: %#v", expected, got)
+		t.Errorf("expected: %#v,\ngot: %#v", expected.OwnerReferences, got.OwnerReferences)
+		for _, ref := range got.OwnerReferences {
+			t.Errorf("ref.UID=%s, ref.BlockOwnerDeletion=%v", ref.UID, *ref.BlockOwnerDeletion)
+		}
+	}
+}

pkg/controller/garbagecollector/graph.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 garbagecollector
+
+import (
+	"fmt"
+	"sync"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+)
+
+type objectReference struct {
+	metav1.OwnerReference
+	// This is needed by the dynamic client
+	Namespace string
+}
+
+func (s objectReference) String() string {
+	return fmt.Sprintf("[%s/%s, namespace: %s, name: %s, uid: %s]", s.APIVersion, s.Kind, s.Namespace, s.Name, s.UID)
+}
+
+// The single-threaded GraphBuilder.processEvent() is the sole writer of the
+// nodes. The multi-threaded GarbageCollector.processItem() reads the nodes.
+// WARNING: node has different locks on different fields. setters and getters
+// use the respective locks, so the return values of the getters can be
+// inconsistent.
+type node struct {
+	identity objectReference
+	// dependents will be read by the orphan() routine, we need to protect it with a lock.
+	dependentsLock sync.RWMutex
+	// dependents are the nodes that have node.identity as a
+	// metadata.ownerReference.
+	dependents map[*node]struct{}
+	// this is set by processEvent() if the object has non-nil DeletionTimestamp
+	// and has the FinalizerDeleteDependents.
+	deletingDependents     bool
+	deletingDependentsLock sync.RWMutex
+	// this records if the object's deletionTimestamp is non-nil.
+	beingDeleted     bool
+	beingDeletedLock sync.RWMutex
+	// when processing an Update event, we need to compare the updated
+	// ownerReferences with the owners recorded in the graph.
+	owners []metav1.OwnerReference
+}
+
+// An object is on a one way trip to its final deletion if it starts being
+// deleted, so we only provide a function to set beingDeleted to true.
+func (n *node) markBeingDeleted() {
+	n.beingDeletedLock.Lock()
+	defer n.beingDeletedLock.Unlock()
+	n.beingDeleted = true
+}
+
+func (n *node) isBeingDeleted() bool {
+	n.beingDeletedLock.RLock()
+	defer n.beingDeletedLock.RUnlock()
+	return n.beingDeleted
+}
+
+func (n *node) markDeletingDependents() {
+	n.deletingDependentsLock.Lock()
+	defer n.deletingDependentsLock.Unlock()
+	n.deletingDependents = true
+}
+
+func (n *node) isDeletingDependents() bool {
+	n.deletingDependentsLock.RLock()
+	defer n.deletingDependentsLock.RUnlock()
+	return n.deletingDependents
+}
+
+func (ownerNode *node) addDependent(dependent *node) {
+	ownerNode.dependentsLock.Lock()
+	defer ownerNode.dependentsLock.Unlock()
+	ownerNode.dependents[dependent] = struct{}{}
+}
+
+func (ownerNode *node) deleteDependent(dependent *node) {
+	ownerNode.dependentsLock.Lock()
+	defer ownerNode.dependentsLock.Unlock()
+	delete(ownerNode.dependents, dependent)
+}
+
+func (ownerNode *node) dependentsLength() int {
+	ownerNode.dependentsLock.RLock()
+	defer ownerNode.dependentsLock.RUnlock()
+	return len(ownerNode.dependents)
+}
+
+// Note that this function does not provide any synchronization guarantees;
+// items could be added to or removed from ownerNode.dependents the moment this
+// function returns.
+func (ownerNode *node) getDependents() []*node {
+	ownerNode.dependentsLock.RLock()
+	defer ownerNode.dependentsLock.RUnlock()
+	var ret []*node
+	for dep := range ownerNode.dependents {
+		ret = append(ret, dep)
+	}
+	return ret
+}
+
+// blockingDependents returns the dependents that are blocking the deletion of
+// n, i.e., the dependent that has an ownerReference pointing to n, and
+// the BlockOwnerDeletion field of that ownerReference is true.
+// Note that this function does not provide any synchronization guarantees;
+// items could be added to or removed from ownerNode.dependents the moment this
+// function returns.
+func (n *node) blockingDependents() []*node {
+	dependents := n.getDependents()
+	var ret []*node
+	for _, dep := range dependents {
+		for _, owner := range dep.owners {
+			if owner.UID == n.identity.UID && owner.BlockOwnerDeletion != nil && *owner.BlockOwnerDeletion {
+				ret = append(ret, dep)
+			}
+		}
+	}
+	return ret
+}
+
+type concurrentUIDToNode struct {
+	uidToNodeLock sync.RWMutex
+	uidToNode     map[types.UID]*node
+}
+
+func (m *concurrentUIDToNode) Write(node *node) {
+	m.uidToNodeLock.Lock()
+	defer m.uidToNodeLock.Unlock()
+	m.uidToNode[node.identity.UID] = node
+}
+
+func (m *concurrentUIDToNode) Read(uid types.UID) (*node, bool) {
+	m.uidToNodeLock.RLock()
+	defer m.uidToNodeLock.RUnlock()
+	n, ok := m.uidToNode[uid]
+	return n, ok
+}
+
+func (m *concurrentUIDToNode) Delete(uid types.UID) {
+	m.uidToNodeLock.Lock()
+	defer m.uidToNodeLock.Unlock()
+	delete(m.uidToNode, uid)
+}

pkg/controller/garbagecollector/operations.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 garbagecollector
+
+import (
+	"fmt"
+
+	"github.com/golang/glog"
+
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/kubernetes/pkg/client/retry"
+)
+
+// apiResource consults the REST mapper to translate an <apiVersion, kind,
+// namespace> tuple to a unversioned.APIResource struct.
+func (gc *GarbageCollector) apiResource(apiVersion, kind string, namespaced bool) (*metav1.APIResource, error) {
+	fqKind := schema.FromAPIVersionAndKind(apiVersion, kind)
+	mapping, err := gc.restMapper.RESTMapping(fqKind.GroupKind(), apiVersion)
+	if err != nil {
+		return nil, fmt.Errorf("unable to get REST mapping for kind: %s, version: %s", kind, apiVersion)
+	}
+	glog.V(5).Infof("map kind %s, version %s to resource %s", kind, apiVersion, mapping.Resource)
+	resource := metav1.APIResource{
+		Name:       mapping.Resource,
+		Namespaced: namespaced,
+		Kind:       kind,
+	}
+	return &resource, nil
+}
+
+func (gc *GarbageCollector) deleteObject(item objectReference, policy *metav1.DeletionPropagation) error {
+	fqKind := schema.FromAPIVersionAndKind(item.APIVersion, item.Kind)
+	client, err := gc.clientPool.ClientForGroupVersionKind(fqKind)
+	gc.registeredRateLimiter.registerIfNotPresent(fqKind.GroupVersion(), client, "garbage_collector_operation")
+	resource, err := gc.apiResource(item.APIVersion, item.Kind, len(item.Namespace) != 0)
+	if err != nil {
+		return err
+	}
+	uid := item.UID
+	preconditions := metav1.Preconditions{UID: &uid}
+	deleteOptions := metav1.DeleteOptions{Preconditions: &preconditions, PropagationPolicy: policy}
+	return client.Resource(resource, item.Namespace).Delete(item.Name, &deleteOptions)
+}
+
+func (gc *GarbageCollector) getObject(item objectReference) (*unstructured.Unstructured, error) {
+	fqKind := schema.FromAPIVersionAndKind(item.APIVersion, item.Kind)
+	client, err := gc.clientPool.ClientForGroupVersionKind(fqKind)
+	gc.registeredRateLimiter.registerIfNotPresent(fqKind.GroupVersion(), client, "garbage_collector_operation")
+	resource, err := gc.apiResource(item.APIVersion, item.Kind, len(item.Namespace) != 0)
+	if err != nil {
+		return nil, err
+	}
+	return client.Resource(resource, item.Namespace).Get(item.Name)
+}
+
+func (gc *GarbageCollector) updateObject(item objectReference, obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	fqKind := schema.FromAPIVersionAndKind(item.APIVersion, item.Kind)
+	client, err := gc.clientPool.ClientForGroupVersionKind(fqKind)
+	gc.registeredRateLimiter.registerIfNotPresent(fqKind.GroupVersion(), client, "garbage_collector_operation")
+	resource, err := gc.apiResource(item.APIVersion, item.Kind, len(item.Namespace) != 0)
+	if err != nil {
+		return nil, err
+	}
+	return client.Resource(resource, item.Namespace).Update(obj)
+}
+
+func (gc *GarbageCollector) patchObject(item objectReference, patch []byte) (*unstructured.Unstructured, error) {
+	fqKind := schema.FromAPIVersionAndKind(item.APIVersion, item.Kind)
+	client, err := gc.clientPool.ClientForGroupVersionKind(fqKind)
+	gc.registeredRateLimiter.registerIfNotPresent(fqKind.GroupVersion(), client, "garbage_collector_operation")
+	resource, err := gc.apiResource(item.APIVersion, item.Kind, len(item.Namespace) != 0)
+	if err != nil {
+		return nil, err
+	}
+	return client.Resource(resource, item.Namespace).Patch(item.Name, types.StrategicMergePatchType, patch)
+}
+
+// TODO: Using Patch when strategicmerge supports deleting an entry from a
+// slice of a base type.
+func (gc *GarbageCollector) removeFinalizer(owner *node, targetFinalizer string) error {
+	err := retry.RetryOnConflict(retry.DefaultBackoff, func() error {
+		ownerObject, err := gc.getObject(owner.identity)
+		if errors.IsNotFound(err) {
+			return nil
+		}
+		if err != nil {
+			return fmt.Errorf("cannot finalize owner %s, because cannot get it: %v. The garbage collector will retry later.", owner.identity, err)
+		}
+		accessor, err := meta.Accessor(ownerObject)
+		if err != nil {
+			return fmt.Errorf("cannot access the owner object %v: %v. The garbage collector will retry later.", ownerObject, err)
+		}
+		finalizers := accessor.GetFinalizers()
+		var newFinalizers []string
+		found := false
+		for _, f := range finalizers {
+			if f == targetFinalizer {
+				found = true
+				break
+			}
+			newFinalizers = append(newFinalizers, f)
+		}
+		if !found {
+			glog.V(5).Infof("the orphan finalizer is already removed from object %s", owner.identity)
+			return nil
+		}
+		// remove the owner from dependent's OwnerReferences
+		ownerObject.SetFinalizers(newFinalizers)
+		_, err = gc.updateObject(owner.identity, ownerObject)
+		return err
+	})
+	if errors.IsConflict(err) {
+		return fmt.Errorf("updateMaxRetries(%d) has reached. The garbage collector will retry later for owner %v.", retry.DefaultBackoff.Steps, owner.identity)
+	}
+	return err
+}

pkg/controller/garbagecollector/patch.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 garbagecollector
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/kubernetes/pkg/controller/garbagecollector/metaonly"
+)
+
+func deleteOwnerRefPatch(dependentUID types.UID, ownerUIDs ...types.UID) []byte {
+	var pieces []string
+	for _, ownerUID := range ownerUIDs {
+		pieces = append(pieces, fmt.Sprintf(`{"$patch":"delete","uid":"%s"}`, ownerUID))
+	}
+	patch := fmt.Sprintf(`{"metadata":{"ownerReferences":[%s],"uid":"%s"}}`, strings.Join(pieces, ","), dependentUID)
+	return []byte(patch)
+}
+
+// generate a patch that unsets the BlockOwnerDeletion field of all
+// ownerReferences of node.
+func (n *node) patchToUnblockOwnerReferences() ([]byte, error) {
+	var dummy metaonly.MetadataOnlyObject
+	var blockingRefs []metav1.OwnerReference
+	falseVar := false
+	for _, owner := range n.owners {
+		if owner.BlockOwnerDeletion != nil && *owner.BlockOwnerDeletion {
+			ref := owner
+			ref.BlockOwnerDeletion = &falseVar
+			blockingRefs = append(blockingRefs, ref)
+		}
+	}
+	dummy.ObjectMeta.SetOwnerReferences(blockingRefs)
+	dummy.ObjectMeta.UID = n.identity.UID
+	return json.Marshal(dummy)
+}

pkg/controller/replicaset/replica_set.go

@@ -481,14 +481,14 @@ func (rsc *ReplicaSetController) manageReplicas(filteredPods []*v1.Pod, rs *exte
 			go func() {
 				defer wg.Done()
 				var err error
-
-				var trueVar = true
+				boolPtr := func(b bool) *bool { return &b }
 				controllerRef := &metav1.OwnerReference{
-					APIVersion: getRSKind().GroupVersion().String(),
-					Kind:       getRSKind().Kind,
-					Name:       rs.Name,
-					UID:        rs.UID,
-					Controller: &trueVar,
+					APIVersion:         getRSKind().GroupVersion().String(),
+					Kind:               getRSKind().Kind,
+					Name:               rs.Name,
+					UID:                rs.UID,
+					BlockOwnerDeletion: boolPtr(true),
+					Controller:         boolPtr(true),
 				}
 				err = rsc.podControl.CreatePodsWithControllerRef(rs.Namespace, &rs.Spec.Template, rs, controllerRef)
 				if err != nil {

pkg/controller/replication/replication_controller.go

@@ -479,13 +479,14 @@ func (rm *ReplicationManager) manageReplicas(filteredPods []*v1.Pod, rc *v1.Repl
 			go func() {
 				defer wg.Done()
 				var err error
-				var trueVar = true
+				boolPtr := func(b bool) *bool { return &b }
 				controllerRef := &metav1.OwnerReference{
-					APIVersion: getRCKind().GroupVersion().String(),
-					Kind:       getRCKind().Kind,
-					Name:       rc.Name,
-					UID:        rc.UID,
-					Controller: &trueVar,
+					APIVersion:         getRCKind().GroupVersion().String(),
+					Kind:               getRCKind().Kind,
+					Name:               rc.Name,
+					UID:                rc.UID,
+					BlockOwnerDeletion: boolPtr(true),
+					Controller:         boolPtr(true),
 				}
 				err = rm.podControl.CreatePodsWithControllerRef(rc.Namespace, rc.Spec.Template, rc, controllerRef)
 				if err != nil {