mirror of https://github.com/k3s-io/k3s
126 lines
4.7 KiB
Go
126 lines
4.7 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 garbagecollector
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"k8s.io/klog"
|
|
|
|
"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/client-go/util/retry"
|
|
)
|
|
|
|
// cluster scoped resources don't have namespaces. Default to the item's namespace, but clear it for cluster scoped resources
|
|
func resourceDefaultNamespace(namespaced bool, defaultNamespace string) string {
|
|
if namespaced {
|
|
return defaultNamespace
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// apiResource consults the REST mapper to translate an <apiVersion, kind,
|
|
// namespace> tuple to a unversioned.APIResource struct.
|
|
func (gc *GarbageCollector) apiResource(apiVersion, kind string) (schema.GroupVersionResource, bool, error) {
|
|
fqKind := schema.FromAPIVersionAndKind(apiVersion, kind)
|
|
mapping, err := gc.restMapper.RESTMapping(fqKind.GroupKind(), fqKind.Version)
|
|
if err != nil {
|
|
return schema.GroupVersionResource{}, false, newRESTMappingError(kind, apiVersion)
|
|
}
|
|
return mapping.Resource, mapping.Scope == meta.RESTScopeNamespace, nil
|
|
}
|
|
|
|
func (gc *GarbageCollector) deleteObject(item objectReference, policy *metav1.DeletionPropagation) error {
|
|
resource, namespaced, err := gc.apiResource(item.APIVersion, item.Kind)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
uid := item.UID
|
|
preconditions := metav1.Preconditions{UID: &uid}
|
|
deleteOptions := metav1.DeleteOptions{Preconditions: &preconditions, PropagationPolicy: policy}
|
|
return gc.dynamicClient.Resource(resource).Namespace(resourceDefaultNamespace(namespaced, item.Namespace)).Delete(item.Name, &deleteOptions)
|
|
}
|
|
|
|
func (gc *GarbageCollector) getObject(item objectReference) (*unstructured.Unstructured, error) {
|
|
resource, namespaced, err := gc.apiResource(item.APIVersion, item.Kind)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return gc.dynamicClient.Resource(resource).Namespace(resourceDefaultNamespace(namespaced, item.Namespace)).Get(item.Name, metav1.GetOptions{})
|
|
}
|
|
|
|
func (gc *GarbageCollector) updateObject(item objectReference, obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
|
|
resource, namespaced, err := gc.apiResource(item.APIVersion, item.Kind)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return gc.dynamicClient.Resource(resource).Namespace(resourceDefaultNamespace(namespaced, item.Namespace)).Update(obj, metav1.UpdateOptions{})
|
|
}
|
|
|
|
func (gc *GarbageCollector) patchObject(item objectReference, patch []byte, pt types.PatchType) (*unstructured.Unstructured, error) {
|
|
resource, namespaced, err := gc.apiResource(item.APIVersion, item.Kind)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return gc.dynamicClient.Resource(resource).Namespace(resourceDefaultNamespace(namespaced, item.Namespace)).Patch(item.Name, pt, patch, metav1.UpdateOptions{})
|
|
}
|
|
|
|
// 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
|
|
continue
|
|
}
|
|
newFinalizers = append(newFinalizers, f)
|
|
}
|
|
if !found {
|
|
klog.V(5).Infof("the %s finalizer is already removed from object %s", targetFinalizer, 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
|
|
}
|