Add field tracker support to client fake fixtures

Kubernetes-commit: 75d6f024326dadc13807b8221bedd8da7924c2ba
This commit is contained in:
Joe Betz 2024-06-24 15:42:29 -04:00 committed by Kubernetes Publisher
parent 96f66e9159
commit 2c866525dd
2 changed files with 711 additions and 125 deletions

View File

@ -19,19 +19,24 @@ package testing
import ( import (
"fmt" "fmt"
"reflect" "reflect"
"sigs.k8s.io/structured-merge-diff/v4/typed"
"sigs.k8s.io/yaml"
"sort" "sort"
"strings" "strings"
"sync" "sync"
jsonpatch "gopkg.in/evanphx/json-patch.v4" jsonpatch "gopkg.in/evanphx/json-patch.v4"
"k8s.io/apimachinery/pkg/api/errors" apierrors "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/api/meta" "k8s.io/apimachinery/pkg/api/meta"
"k8s.io/apimachinery/pkg/api/meta/testrestmapper"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/json" "k8s.io/apimachinery/pkg/util/json"
"k8s.io/apimachinery/pkg/util/managedfields"
"k8s.io/apimachinery/pkg/util/strategicpatch" "k8s.io/apimachinery/pkg/util/strategicpatch"
"k8s.io/apimachinery/pkg/watch" "k8s.io/apimachinery/pkg/watch"
restclient "k8s.io/client-go/rest" restclient "k8s.io/client-go/rest"
@ -46,26 +51,32 @@ type ObjectTracker interface {
Add(obj runtime.Object) error Add(obj runtime.Object) error
// Get retrieves the object by its kind, namespace and name. // Get retrieves the object by its kind, namespace and name.
Get(gvr schema.GroupVersionResource, ns, name string) (runtime.Object, error) Get(gvr schema.GroupVersionResource, ns, name string, opts ...metav1.GetOptions) (runtime.Object, error)
// Create adds an object to the tracker in the specified namespace. // Create adds an object to the tracker in the specified namespace.
Create(gvr schema.GroupVersionResource, obj runtime.Object, ns string) error Create(gvr schema.GroupVersionResource, obj runtime.Object, ns string, opts ...metav1.CreateOptions) error
// Update updates an existing object in the tracker in the specified namespace. // Update updates an existing object in the tracker in the specified namespace.
Update(gvr schema.GroupVersionResource, obj runtime.Object, ns string) error Update(gvr schema.GroupVersionResource, obj runtime.Object, ns string, opts ...metav1.UpdateOptions) error
// Patch patches an existing object in the tracker in the specified namespace.
Patch(gvr schema.GroupVersionResource, obj runtime.Object, ns string, opts ...metav1.PatchOptions) error
// Apply applies an object in the tracker in the specified namespace.
Apply(gvr schema.GroupVersionResource, applyConfiguration runtime.Object, ns string, opts ...metav1.PatchOptions) error
// List retrieves all objects of a given kind in the given // List retrieves all objects of a given kind in the given
// namespace. Only non-List kinds are accepted. // namespace. Only non-List kinds are accepted.
List(gvr schema.GroupVersionResource, gvk schema.GroupVersionKind, ns string) (runtime.Object, error) List(gvr schema.GroupVersionResource, gvk schema.GroupVersionKind, ns string, opts ...metav1.ListOptions) (runtime.Object, error)
// Delete deletes an existing object from the tracker. If object // Delete deletes an existing object from the tracker. If object
// didn't exist in the tracker prior to deletion, Delete returns // didn't exist in the tracker prior to deletion, Delete returns
// no error. // no error.
Delete(gvr schema.GroupVersionResource, ns, name string) error Delete(gvr schema.GroupVersionResource, ns, name string, opts ...metav1.DeleteOptions) error
// Watch watches objects from the tracker. Watch returns a channel // Watch watches objects from the tracker. Watch returns a channel
// which will push added / modified / deleted object. // which will push added / modified / deleted object.
Watch(gvr schema.GroupVersionResource, ns string) (watch.Interface, error) Watch(gvr schema.GroupVersionResource, ns string, opts ...metav1.ListOptions) (watch.Interface, error)
} }
// ObjectScheme abstracts the implementation of common operations on objects. // ObjectScheme abstracts the implementation of common operations on objects.
@ -76,81 +87,153 @@ type ObjectScheme interface {
// ObjectReaction returns a ReactionFunc that applies core.Action to // ObjectReaction returns a ReactionFunc that applies core.Action to
// the given tracker. // the given tracker.
//
// If tracker also implements ManagedFieldObjectTracker, then managed fields
// will be handled by the tracker and apply patch actions will be evaluated
// using the field manager and will take field ownership into consideration.
// Without a ManagedFieldObjectTracker, apply patch actions do not consider
// field ownership.
//
// WARNING: There is no server side defaulting, validation, or conversion handled
// by the fake client and subresources are not handled accurately (fields in the
// root resource are not automatically updated when a scale resource is updated, for example).
func ObjectReaction(tracker ObjectTracker) ReactionFunc { func ObjectReaction(tracker ObjectTracker) ReactionFunc {
reactor := objectTrackerReact{tracker: tracker}
return func(action Action) (bool, runtime.Object, error) { return func(action Action) (bool, runtime.Object, error) {
ns := action.GetNamespace()
gvr := action.GetResource()
// Here and below we need to switch on implementation types, // Here and below we need to switch on implementation types,
// not on interfaces, as some interfaces are identical // not on interfaces, as some interfaces are identical
// (e.g. UpdateAction and CreateAction), so if we use them, // (e.g. UpdateAction and CreateAction), so if we use them,
// updates and creates end up matching the same case branch. // updates and creates end up matching the same case branch.
switch action := action.(type) { switch action := action.(type) {
case ListActionImpl: case ListActionImpl:
obj, err := tracker.List(gvr, action.GetKind(), ns) obj, err := reactor.List(action)
return true, obj, err return true, obj, err
case GetActionImpl: case GetActionImpl:
obj, err := tracker.Get(gvr, ns, action.GetName()) obj, err := reactor.Get(action)
return true, obj, err return true, obj, err
case CreateActionImpl: case CreateActionImpl:
obj, err := reactor.Create(action)
return true, obj, err
case UpdateActionImpl:
obj, err := reactor.Update(action)
return true, obj, err
case DeleteActionImpl:
obj, err := reactor.Delete(action)
return true, obj, err
case PatchActionImpl:
if action.GetPatchType() == types.ApplyPatchType {
obj, err := reactor.Apply(action)
return true, obj, err
}
obj, err := reactor.Patch(action)
return true, obj, err
default:
return false, nil, fmt.Errorf("no reaction implemented for %s", action)
}
}
}
type objectTrackerReact struct {
tracker ObjectTracker
}
func (o objectTrackerReact) List(action ListActionImpl) (runtime.Object, error) {
return o.tracker.List(action.GetResource(), action.GetKind(), action.GetNamespace(), action.ListOptions)
}
func (o objectTrackerReact) Get(action GetActionImpl) (runtime.Object, error) {
return o.tracker.Get(action.GetResource(), action.GetNamespace(), action.GetName(), action.GetOptions)
}
func (o objectTrackerReact) Create(action CreateActionImpl) (runtime.Object, error) {
ns := action.GetNamespace()
gvr := action.GetResource()
objMeta, err := meta.Accessor(action.GetObject()) objMeta, err := meta.Accessor(action.GetObject())
if err != nil { if err != nil {
return true, nil, err return nil, err
} }
if action.GetSubresource() == "" { if action.GetSubresource() == "" {
err = tracker.Create(gvr, action.GetObject(), ns) err = o.tracker.Create(gvr, action.GetObject(), ns, action.CreateOptions)
if err != nil {
return nil, err
}
} else { } else {
oldObj, getOldObjErr := tracker.Get(gvr, ns, objMeta.GetName()) oldObj, getOldObjErr := o.tracker.Get(gvr, ns, objMeta.GetName(), metav1.GetOptions{})
if getOldObjErr != nil { if getOldObjErr != nil {
return true, nil, getOldObjErr return nil, getOldObjErr
} }
// Check whether the existing historical object type is the same as the current operation object type that needs to be updated, and if it is the same, perform the update operation. // Check whether the existing historical object type is the same as the current operation object type that needs to be updated, and if it is the same, perform the update operation.
if reflect.TypeOf(oldObj) == reflect.TypeOf(action.GetObject()) { if reflect.TypeOf(oldObj) == reflect.TypeOf(action.GetObject()) {
// TODO: Currently we're handling subresource creation as an update // TODO: Currently we're handling subresource creation as an update
// on the enclosing resource. This works for some subresources but // on the enclosing resource. This works for some subresources but
// might not be generic enough. // might not be generic enough.
err = tracker.Update(gvr, action.GetObject(), ns) err = o.tracker.Update(gvr, action.GetObject(), ns, metav1.UpdateOptions{
DryRun: action.CreateOptions.DryRun,
FieldManager: action.CreateOptions.FieldManager,
FieldValidation: action.CreateOptions.FieldValidation,
})
} else { } else {
// If the historical object type is different from the current object type, need to make sure we return the object submitted,don't persist the submitted object in the tracker. // If the historical object type is different from the current object type, need to make sure we return the object submitted,don't persist the submitted object in the tracker.
return true, action.GetObject(), nil return action.GetObject(), nil
} }
} }
if err != nil { if err != nil {
return true, nil, err return nil, err
} }
obj, err := tracker.Get(gvr, ns, objMeta.GetName()) obj, err := o.tracker.Get(gvr, ns, objMeta.GetName(), metav1.GetOptions{})
return true, obj, err return obj, err
}
case UpdateActionImpl: func (o objectTrackerReact) Update(action UpdateActionImpl) (runtime.Object, error) {
ns := action.GetNamespace()
gvr := action.GetResource()
objMeta, err := meta.Accessor(action.GetObject()) objMeta, err := meta.Accessor(action.GetObject())
if err != nil { if err != nil {
return true, nil, err return nil, err
} }
err = tracker.Update(gvr, action.GetObject(), ns)
if err != nil {
return true, nil, err
}
obj, err := tracker.Get(gvr, ns, objMeta.GetName())
return true, obj, err
case DeleteActionImpl: err = o.tracker.Update(gvr, action.GetObject(), ns, action.UpdateOptions)
err := tracker.Delete(gvr, ns, action.GetName())
if err != nil { if err != nil {
return true, nil, err return nil, err
} }
return true, nil, nil
case PatchActionImpl: obj, err := o.tracker.Get(gvr, ns, objMeta.GetName(), metav1.GetOptions{})
obj, err := tracker.Get(gvr, ns, action.GetName()) return obj, err
}
func (o objectTrackerReact) Delete(action DeleteActionImpl) (runtime.Object, error) {
err := o.tracker.Delete(action.GetResource(), action.GetNamespace(), action.GetName(), action.DeleteOptions)
return nil, err
}
func (o objectTrackerReact) Apply(action PatchActionImpl) (runtime.Object, error) {
ns := action.GetNamespace()
gvr := action.GetResource()
patchObj := &unstructured.Unstructured{Object: map[string]interface{}{}}
if err := yaml.Unmarshal(action.GetPatch(), &patchObj.Object); err != nil {
return nil, err
}
err := o.tracker.Apply(gvr, patchObj, ns, action.PatchOptions)
if err != nil { if err != nil {
return true, nil, err return nil, err
}
obj, err := o.tracker.Get(gvr, ns, action.GetName(), metav1.GetOptions{})
return obj, err
}
func (o objectTrackerReact) Patch(action PatchActionImpl) (runtime.Object, error) {
ns := action.GetNamespace()
gvr := action.GetResource()
obj, err := o.tracker.Get(gvr, ns, action.GetName(), metav1.GetOptions{})
if err != nil {
return nil, err
} }
old, err := json.Marshal(obj) old, err := json.Marshal(obj)
if err != nil { if err != nil {
return true, nil, err return nil, err
} }
// reset the object in preparation to unmarshal, since unmarshal does not guarantee that fields // reset the object in preparation to unmarshal, since unmarshal does not guarantee that fields
@ -162,47 +245,42 @@ func ObjectReaction(tracker ObjectTracker) ReactionFunc {
case types.JSONPatchType: case types.JSONPatchType:
patch, err := jsonpatch.DecodePatch(action.GetPatch()) patch, err := jsonpatch.DecodePatch(action.GetPatch())
if err != nil { if err != nil {
return true, nil, err return nil, err
} }
modified, err := patch.Apply(old) modified, err := patch.Apply(old)
if err != nil { if err != nil {
return true, nil, err return nil, err
} }
if err = json.Unmarshal(modified, obj); err != nil { if err = json.Unmarshal(modified, obj); err != nil {
return true, nil, err return nil, err
} }
case types.MergePatchType: case types.MergePatchType:
modified, err := jsonpatch.MergePatch(old, action.GetPatch()) modified, err := jsonpatch.MergePatch(old, action.GetPatch())
if err != nil { if err != nil {
return true, nil, err return nil, err
} }
if err := json.Unmarshal(modified, obj); err != nil { if err := json.Unmarshal(modified, obj); err != nil {
return true, nil, err return nil, err
} }
case types.StrategicMergePatchType, types.ApplyPatchType: case types.StrategicMergePatchType:
mergedByte, err := strategicpatch.StrategicMergePatch(old, action.GetPatch(), obj) mergedByte, err := strategicpatch.StrategicMergePatch(old, action.GetPatch(), obj)
if err != nil { if err != nil {
return true, nil, err return nil, err
} }
if err = json.Unmarshal(mergedByte, obj); err != nil { if err = json.Unmarshal(mergedByte, obj); err != nil {
return true, nil, err return nil, err
} }
default: default:
return true, nil, fmt.Errorf("PatchType is not supported") return nil, fmt.Errorf("PatchType %s is not supported", action.GetPatchType())
} }
if err = tracker.Update(gvr, obj, ns); err != nil { if err = o.tracker.Patch(gvr, obj, ns, action.PatchOptions); err != nil {
return true, nil, err return nil, err
} }
return true, obj, nil return obj, nil
default:
return false, nil, fmt.Errorf("no reaction implemented for %s", action)
}
}
} }
type tracker struct { type tracker struct {
@ -231,7 +309,11 @@ func NewObjectTracker(scheme ObjectScheme, decoder runtime.Decoder) ObjectTracke
} }
} }
func (t *tracker) List(gvr schema.GroupVersionResource, gvk schema.GroupVersionKind, ns string) (runtime.Object, error) { func (t *tracker) List(gvr schema.GroupVersionResource, gvk schema.GroupVersionKind, ns string, opts ...metav1.ListOptions) (runtime.Object, error) {
_, err := assertOptionalSingleArgument(opts)
if err != nil {
return nil, err
}
// Heuristic for list kind: original kind + List suffix. Might // Heuristic for list kind: original kind + List suffix. Might
// not always be true but this tracker has a pretty limited // not always be true but this tracker has a pretty limited
// understanding of the actual API model. // understanding of the actual API model.
@ -270,7 +352,12 @@ func (t *tracker) List(gvr schema.GroupVersionResource, gvk schema.GroupVersionK
return list.DeepCopyObject(), nil return list.DeepCopyObject(), nil
} }
func (t *tracker) Watch(gvr schema.GroupVersionResource, ns string) (watch.Interface, error) { func (t *tracker) Watch(gvr schema.GroupVersionResource, ns string, opts ...metav1.ListOptions) (watch.Interface, error) {
_, err := assertOptionalSingleArgument(opts)
if err != nil {
return nil, err
}
t.lock.Lock() t.lock.Lock()
defer t.lock.Unlock() defer t.lock.Unlock()
@ -283,8 +370,12 @@ func (t *tracker) Watch(gvr schema.GroupVersionResource, ns string) (watch.Inter
return fakewatcher, nil return fakewatcher, nil
} }
func (t *tracker) Get(gvr schema.GroupVersionResource, ns, name string) (runtime.Object, error) { func (t *tracker) Get(gvr schema.GroupVersionResource, ns, name string, opts ...metav1.GetOptions) (runtime.Object, error) {
errNotFound := errors.NewNotFound(gvr.GroupResource(), name) _, err := assertOptionalSingleArgument(opts)
if err != nil {
return nil, err
}
errNotFound := apierrors.NewNotFound(gvr.GroupResource(), name)
t.lock.RLock() t.lock.RLock()
defer t.lock.RUnlock() defer t.lock.RUnlock()
@ -305,7 +396,7 @@ func (t *tracker) Get(gvr schema.GroupVersionResource, ns, name string) (runtime
obj := matchingObj.DeepCopyObject() obj := matchingObj.DeepCopyObject()
if status, ok := obj.(*metav1.Status); ok { if status, ok := obj.(*metav1.Status); ok {
if status.Status != metav1.StatusSuccess { if status.Status != metav1.StatusSuccess {
return nil, &errors.StatusError{ErrStatus: *status} return nil, &apierrors.StatusError{ErrStatus: *status}
} }
} }
@ -352,11 +443,70 @@ func (t *tracker) Add(obj runtime.Object) error {
return nil return nil
} }
func (t *tracker) Create(gvr schema.GroupVersionResource, obj runtime.Object, ns string) error { func (t *tracker) Create(gvr schema.GroupVersionResource, obj runtime.Object, ns string, opts ...metav1.CreateOptions) error {
_, err := assertOptionalSingleArgument(opts)
if err != nil {
return err
}
return t.add(gvr, obj, ns, false) return t.add(gvr, obj, ns, false)
} }
func (t *tracker) Update(gvr schema.GroupVersionResource, obj runtime.Object, ns string) error { func (t *tracker) Update(gvr schema.GroupVersionResource, obj runtime.Object, ns string, opts ...metav1.UpdateOptions) error {
_, err := assertOptionalSingleArgument(opts)
if err != nil {
return err
}
return t.add(gvr, obj, ns, true)
}
func (t *tracker) Patch(gvr schema.GroupVersionResource, patchedObject runtime.Object, ns string, opts ...metav1.PatchOptions) error {
_, err := assertOptionalSingleArgument(opts)
if err != nil {
return err
}
return t.add(gvr, patchedObject, ns, true)
}
func (t *tracker) Apply(gvr schema.GroupVersionResource, applyConfiguration runtime.Object, ns string, opts ...metav1.PatchOptions) error {
_, err := assertOptionalSingleArgument(opts)
if err != nil {
return err
}
applyConfigurationMeta, err := meta.Accessor(applyConfiguration)
if err != nil {
return err
}
obj, err := t.Get(gvr, ns, applyConfigurationMeta.GetName(), metav1.GetOptions{})
if err != nil {
return err
}
old, err := json.Marshal(obj)
if err != nil {
return err
}
// reset the object in preparation to unmarshal, since unmarshal does not guarantee that fields
// in obj that are removed by patch are cleared
value := reflect.ValueOf(obj)
value.Elem().Set(reflect.New(value.Type().Elem()).Elem())
// For backward compatibility with behavior 1.30 and earlier, continue to handle apply
// via strategic merge patch (clients may use fake.NewClientset and ManagedFieldObjectTracker
// for full field manager support).
patch, err := json.Marshal(applyConfiguration)
if err != nil {
return err
}
mergedByte, err := strategicpatch.StrategicMergePatch(old, patch, obj)
if err != nil {
return err
}
if err = json.Unmarshal(mergedByte, obj); err != nil {
return err
}
return t.add(gvr, obj, ns, true) return t.add(gvr, obj, ns, true)
} }
@ -398,7 +548,7 @@ func (t *tracker) add(gvr schema.GroupVersionResource, obj runtime.Object, ns st
if ns != newMeta.GetNamespace() { if ns != newMeta.GetNamespace() {
msg := fmt.Sprintf("request namespace does not match object namespace, request: %q object: %q", ns, newMeta.GetNamespace()) msg := fmt.Sprintf("request namespace does not match object namespace, request: %q object: %q", ns, newMeta.GetNamespace())
return errors.NewBadRequest(msg) return apierrors.NewBadRequest(msg)
} }
_, ok := t.objects[gvr] _, ok := t.objects[gvr]
@ -416,12 +566,12 @@ func (t *tracker) add(gvr schema.GroupVersionResource, obj runtime.Object, ns st
t.objects[gvr][namespacedName] = obj t.objects[gvr][namespacedName] = obj
return nil return nil
} }
return errors.NewAlreadyExists(gr, newMeta.GetName()) return apierrors.NewAlreadyExists(gr, newMeta.GetName())
} }
if replaceExisting { if replaceExisting {
// Tried to update but no matching object was found. // Tried to update but no matching object was found.
return errors.NewNotFound(gr, newMeta.GetName()) return apierrors.NewNotFound(gr, newMeta.GetName())
} }
t.objects[gvr][namespacedName] = obj t.objects[gvr][namespacedName] = obj
@ -451,19 +601,23 @@ func (t *tracker) addList(obj runtime.Object, replaceExisting bool) error {
return nil return nil
} }
func (t *tracker) Delete(gvr schema.GroupVersionResource, ns, name string) error { func (t *tracker) Delete(gvr schema.GroupVersionResource, ns, name string, opts ...metav1.DeleteOptions) error {
_, err := assertOptionalSingleArgument(opts)
if err != nil {
return err
}
t.lock.Lock() t.lock.Lock()
defer t.lock.Unlock() defer t.lock.Unlock()
objs, ok := t.objects[gvr] objs, ok := t.objects[gvr]
if !ok { if !ok {
return errors.NewNotFound(gvr.GroupResource(), name) return apierrors.NewNotFound(gvr.GroupResource(), name)
} }
namespacedName := types.NamespacedName{Namespace: ns, Name: name} namespacedName := types.NamespacedName{Namespace: ns, Name: name}
obj, ok := objs[namespacedName] obj, ok := objs[namespacedName]
if !ok { if !ok {
return errors.NewNotFound(gvr.GroupResource(), name) return apierrors.NewNotFound(gvr.GroupResource(), name)
} }
delete(objs, namespacedName) delete(objs, namespacedName)
@ -473,6 +627,203 @@ func (t *tracker) Delete(gvr schema.GroupVersionResource, ns, name string) error
return nil return nil
} }
type managedFieldObjectTracker struct {
ObjectTracker
scheme ObjectScheme
objectConverter runtime.ObjectConvertor
mapper meta.RESTMapper
typeConverter managedfields.TypeConverter
}
var _ ObjectTracker = &managedFieldObjectTracker{}
// NewFieldManagedObjectTracker returns an ObjectTracker that can be used to keep track
// of objects and managed fields for the fake clientset. Mostly useful for unit tests.
func NewFieldManagedObjectTracker(scheme *runtime.Scheme, decoder runtime.Decoder, typeConverter managedfields.TypeConverter) ObjectTracker {
return &managedFieldObjectTracker{
ObjectTracker: NewObjectTracker(scheme, decoder),
scheme: scheme,
objectConverter: scheme,
mapper: testrestmapper.TestOnlyStaticRESTMapper(scheme),
typeConverter: typeConverter,
}
}
func (t *managedFieldObjectTracker) Create(gvr schema.GroupVersionResource, obj runtime.Object, ns string, vopts ...metav1.CreateOptions) error {
opts, err := assertOptionalSingleArgument(vopts)
if err != nil {
return err
}
gvk, err := t.mapper.KindFor(gvr)
if err != nil {
return err
}
mgr, err := t.fieldManagerFor(gvk)
if err != nil {
return err
}
objType, err := meta.TypeAccessor(obj)
if err != nil {
return err
}
// Stamp GVK
apiVersion, kind := gvk.ToAPIVersionAndKind()
objType.SetAPIVersion(apiVersion)
objType.SetKind(kind)
objMeta, err := meta.Accessor(obj)
if err != nil {
return err
}
liveObject, err := t.ObjectTracker.Get(gvr, ns, objMeta.GetName(), metav1.GetOptions{})
if apierrors.IsNotFound(err) {
liveObject, err = t.scheme.New(gvk)
if err != nil {
return err
}
liveObject.GetObjectKind().SetGroupVersionKind(gvk)
} else if err != nil {
return err
}
objWithManagedFields, err := mgr.Update(liveObject, obj, opts.FieldManager)
if err != nil {
return err
}
return t.ObjectTracker.Create(gvr, objWithManagedFields, ns, opts)
}
func (t *managedFieldObjectTracker) Update(gvr schema.GroupVersionResource, obj runtime.Object, ns string, vopts ...metav1.UpdateOptions) error {
opts, err := assertOptionalSingleArgument(vopts)
if err != nil {
return err
}
gvk, err := t.mapper.KindFor(gvr)
if err != nil {
return err
}
mgr, err := t.fieldManagerFor(gvk)
if err != nil {
return err
}
objMeta, err := meta.Accessor(obj)
if err != nil {
return err
}
oldObj, err := t.ObjectTracker.Get(gvr, ns, objMeta.GetName(), metav1.GetOptions{})
if err != nil {
return err
}
objWithManagedFields, err := mgr.Update(oldObj, obj, opts.FieldManager)
if err != nil {
return err
}
return t.ObjectTracker.Update(gvr, objWithManagedFields, ns, opts)
}
func (t *managedFieldObjectTracker) Patch(gvr schema.GroupVersionResource, patchedObject runtime.Object, ns string, vopts ...metav1.PatchOptions) error {
opts, err := assertOptionalSingleArgument(vopts)
if err != nil {
return err
}
gvk, err := t.mapper.KindFor(gvr)
if err != nil {
return err
}
mgr, err := t.fieldManagerFor(gvk)
if err != nil {
return err
}
objMeta, err := meta.Accessor(patchedObject)
if err != nil {
return err
}
oldObj, err := t.ObjectTracker.Get(gvr, ns, objMeta.GetName(), metav1.GetOptions{})
if err != nil {
return err
}
objWithManagedFields, err := mgr.Update(oldObj, patchedObject, opts.FieldManager)
if err != nil {
return err
}
return t.ObjectTracker.Patch(gvr, objWithManagedFields, ns, vopts...)
}
func (t *managedFieldObjectTracker) Apply(gvr schema.GroupVersionResource, applyConfiguration runtime.Object, ns string, vopts ...metav1.PatchOptions) error {
opts, err := assertOptionalSingleArgument(vopts)
if err != nil {
return err
}
gvk, err := t.mapper.KindFor(gvr)
if err != nil {
return err
}
applyConfigurationMeta, err := meta.Accessor(applyConfiguration)
if err != nil {
return err
}
exists := true
liveObject, err := t.ObjectTracker.Get(gvr, ns, applyConfigurationMeta.GetName(), metav1.GetOptions{})
if apierrors.IsNotFound(err) {
exists = false
liveObject, err = t.scheme.New(gvk)
if err != nil {
return err
}
liveObject.GetObjectKind().SetGroupVersionKind(gvk)
} else if err != nil {
return err
}
mgr, err := t.fieldManagerFor(gvk)
if err != nil {
return err
}
force := false
if opts.Force != nil {
force = *opts.Force
}
objWithManagedFields, err := mgr.Apply(liveObject, applyConfiguration, opts.FieldManager, force)
if err != nil {
return err
}
if !exists {
return t.ObjectTracker.Create(gvr, objWithManagedFields, ns, metav1.CreateOptions{
DryRun: opts.DryRun,
FieldManager: opts.FieldManager,
FieldValidation: opts.FieldValidation,
})
} else {
return t.ObjectTracker.Update(gvr, objWithManagedFields, ns, metav1.UpdateOptions{
DryRun: opts.DryRun,
FieldManager: opts.FieldManager,
FieldValidation: opts.FieldValidation,
})
}
}
func (t *managedFieldObjectTracker) fieldManagerFor(gvk schema.GroupVersionKind) (*managedfields.FieldManager, error) {
return managedfields.NewDefaultFieldManager(
t.typeConverter,
t.objectConverter,
&objectDefaulter{},
t.scheme,
gvk,
gvk.GroupVersion(),
"",
nil)
}
// objectDefaulter implements runtime.Defaulter, but it actually
// does nothing.
type objectDefaulter struct{}
func (d *objectDefaulter) Default(_ runtime.Object) {}
// filterByNamespace returns all objects in the collection that // filterByNamespace returns all objects in the collection that
// match provided namespace. Empty namespace matches // match provided namespace. Empty namespace matches
// non-namespaced objects. // non-namespaced objects.
@ -579,3 +930,76 @@ func resourceCovers(resource string, action Action) bool {
return false return false
} }
// assertOptionalSingleArgument returns an error if there is more than one variadic argument.
// Otherwise, it returns the first variadic argument, or zero value if there are no arguments.
func assertOptionalSingleArgument[T any](arguments []T) (T, error) {
var a T
switch len(arguments) {
case 0:
return a, nil
case 1:
return arguments[0], nil
default:
return a, fmt.Errorf("expected only one option argument but got %d", len(arguments))
}
}
type TypeResolver interface {
Type(openAPIName string) typed.ParseableType
}
type TypeConverter struct {
Scheme *runtime.Scheme
TypeResolver TypeResolver
}
func (tc TypeConverter) ObjectToTyped(obj runtime.Object, opts ...typed.ValidationOptions) (*typed.TypedValue, error) {
gvk := obj.GetObjectKind().GroupVersionKind()
name, err := tc.openAPIName(gvk)
if err != nil {
return nil, err
}
t := tc.TypeResolver.Type(name)
switch o := obj.(type) {
case *unstructured.Unstructured:
return t.FromUnstructured(o.UnstructuredContent(), opts...)
default:
return t.FromStructured(obj, opts...)
}
}
func (tc TypeConverter) TypedToObject(value *typed.TypedValue) (runtime.Object, error) {
vu := value.AsValue().Unstructured()
switch o := vu.(type) {
case map[string]interface{}:
return &unstructured.Unstructured{Object: o}, nil
default:
return nil, fmt.Errorf("failed to convert value to unstructured for type %T", vu)
}
}
func (tc TypeConverter) openAPIName(kind schema.GroupVersionKind) (string, error) {
example, err := tc.Scheme.New(kind)
if err != nil {
return "", err
}
rtype := reflect.TypeOf(example).Elem()
name := friendlyName(rtype.PkgPath() + "." + rtype.Name())
return name, nil
}
// This is a copy of openapi.friendlyName.
// TODO: consider introducing a shared version of this function in apimachinery.
func friendlyName(name string) string {
nameParts := strings.Split(name, "/")
// Reverse first part. e.g., io.k8s... instead of k8s.io...
if len(nameParts) > 0 && strings.Contains(nameParts[0], ".") {
parts := strings.Split(nameParts[0], ".")
for i, j := 0, len(parts)-1; i < j; i, j = i+1, j-1 {
parts[i], parts[j] = parts[j], parts[i]
}
nameParts[0] = strings.Join(parts, ".")
}
return strings.Join(nameParts, ".")
}

View File

@ -17,22 +17,31 @@ limitations under the License.
package testing package testing
import ( import (
"encoding/json"
"fmt" "fmt"
"math/rand" "math/rand"
"os"
"path/filepath"
"strconv" "strconv"
"strings"
"sync" "sync"
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/api/meta" "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/apis/meta/v1/unstructured"
runtime "k8s.io/apimachinery/pkg/runtime" runtime "k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/runtime/schema"
serializer "k8s.io/apimachinery/pkg/runtime/serializer" serializer "k8s.io/apimachinery/pkg/runtime/serializer"
"k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/managedfields"
"k8s.io/apimachinery/pkg/watch" "k8s.io/apimachinery/pkg/watch"
"k8s.io/kube-openapi/pkg/validation/spec"
"k8s.io/utils/ptr"
) )
func getArbitraryResource(s schema.GroupVersionResource, name, namespace string) *unstructured.Unstructured { func getArbitraryResource(s schema.GroupVersionResource, name, namespace string) *unstructured.Unstructured {
@ -275,6 +284,137 @@ func TestPatchWithMissingObject(t *testing.T) {
assert.EqualError(t, err, `nodes "node-1" not found`) assert.EqualError(t, err, `nodes "node-1" not found`)
} }
func TestApplyCreate(t *testing.T) {
cmResource := schema.GroupVersionResource{Group: "", Version: "v1", Resource: "configMaps"}
scheme := runtime.NewScheme()
scheme.AddKnownTypes(cmResource.GroupVersion(), &v1.ConfigMap{})
codecs := serializer.NewCodecFactory(scheme)
o := NewFieldManagedObjectTracker(scheme, codecs.UniversalDecoder(), fakeTypeConverter)
reaction := ObjectReaction(o)
patch := []byte(`{"apiVersion": "v1", "kind": "ConfigMap", "metadata": {"name": "cm-1"}, "data": {"k": "v"}}`)
action := NewPatchActionWithOptions(cmResource, "default", "cm-1", types.ApplyPatchType, patch,
metav1.PatchOptions{FieldManager: "test-manager"})
handled, configMap, err := reaction(action)
assert.True(t, handled)
if err != nil {
t.Errorf("Failed to create a resource with apply: %v", err)
}
cm := configMap.(*v1.ConfigMap)
assert.Equal(t, cm.Data, map[string]string{"k": "v"})
}
func TestApplyUpdateMultipleFieldManagers(t *testing.T) {
cmResource := schema.GroupVersionResource{Group: "", Version: "v1", Resource: "configMaps"}
scheme := runtime.NewScheme()
scheme.AddKnownTypes(cmResource.GroupVersion(), &v1.ConfigMap{})
codecs := serializer.NewCodecFactory(scheme)
o := NewFieldManagedObjectTracker(scheme, codecs.UniversalDecoder(), fakeTypeConverter)
reaction := ObjectReaction(o)
action := NewCreateAction(cmResource, "default", &v1.ConfigMap{
TypeMeta: metav1.TypeMeta{
APIVersion: "v1",
Kind: "ConfigMap",
},
ObjectMeta: metav1.ObjectMeta{
Name: "cm-1",
},
Data: map[string]string{
"k0": "v0",
},
})
handled, _, err := reaction(action)
assert.True(t, handled)
if err != nil {
t.Errorf("Failed to create resource: %v", err)
}
// Apply with test-manager-1
// Expect data to be shared with initial create
patch := []byte(`{"apiVersion": "v1", "kind": "ConfigMap", "metadata": {"name": "cm-1"}, "data": {"k1": "v1"}}`)
applyAction := NewPatchActionWithOptions(cmResource, "default", "cm-1", types.ApplyPatchType, patch,
metav1.PatchOptions{FieldManager: "test-manager-1"})
handled, configMap, err := reaction(applyAction)
assert.True(t, handled)
if err != nil {
t.Errorf("Failed to apply resource: %v", err)
}
cm := configMap.(*v1.ConfigMap)
assert.Equal(t, map[string]string{"k0": "v0", "k1": "v1"}, cm.Data)
// Apply conflicting with test-manager-2, expect apply to fail
patch = []byte(`{"apiVersion": "v1", "kind": "ConfigMap", "metadata": {"name": "cm-1"}, "data": {"k1": "xyz"}}`)
applyAction = NewPatchActionWithOptions(cmResource, "default", "cm-1", types.ApplyPatchType, patch,
metav1.PatchOptions{FieldManager: "test-manager-2"})
handled, _, err = reaction(applyAction)
assert.True(t, handled)
if assert.Error(t, err) {
assert.Equal(t, "Apply failed with 1 conflict: conflict with \"test-manager-1\": .data.k1", err.Error())
}
// Apply with test-manager-2
// Expect data to be shared with initial create and test-manager-1
patch = []byte(`{"apiVersion": "v1", "kind": "ConfigMap", "metadata": {"name": "cm-1"}, "data": {"k2": "v2"}}`)
applyAction = NewPatchActionWithOptions(cmResource, "default", "cm-1", types.ApplyPatchType, patch,
metav1.PatchOptions{FieldManager: "test-manager-2"})
handled, configMap, err = reaction(applyAction)
assert.True(t, handled)
if err != nil {
t.Errorf("Failed to apply resource: %v", err)
}
cm = configMap.(*v1.ConfigMap)
assert.Equal(t, map[string]string{"k0": "v0", "k1": "v1", "k2": "v2"}, cm.Data)
// Apply with test-manager-1
// Expect owned data to be updated
patch = []byte(`{"apiVersion": "v1", "kind": "ConfigMap", "metadata": {"name": "cm-1"}, "data": {"k1": "v101"}}`)
applyAction = NewPatchActionWithOptions(cmResource, "default", "cm-1", types.ApplyPatchType, patch,
metav1.PatchOptions{FieldManager: "test-manager-1"})
handled, configMap, err = reaction(applyAction)
assert.True(t, handled)
if err != nil {
t.Errorf("Failed to apply resource: %v", err)
}
cm = configMap.(*v1.ConfigMap)
assert.Equal(t, map[string]string{"k0": "v0", "k1": "v101", "k2": "v2"}, cm.Data)
// Force apply with test-manager-2
// Expect data owned by test-manager-1 to be updated, expect data already owned but not in apply configuration to be removed
patch = []byte(`{"apiVersion": "v1", "kind": "ConfigMap", "metadata": {"name": "cm-1"}, "data": {"k1": "v202"}}`)
applyAction = NewPatchActionWithOptions(cmResource, "default", "cm-1", types.ApplyPatchType, patch,
metav1.PatchOptions{FieldManager: "test-manager-2", Force: ptr.To(true)})
handled, configMap, err = reaction(applyAction)
assert.True(t, handled)
if err != nil {
t.Errorf("Failed to apply resource: %v", err)
}
cm = configMap.(*v1.ConfigMap)
assert.Equal(t, map[string]string{"k0": "v0", "k1": "v202"}, cm.Data)
// Update with test-manager-1 to perform a force update of the entire resource
reaction = ObjectReaction(o)
updateAction := NewUpdateActionWithOptions(cmResource, "default", &v1.ConfigMap{
TypeMeta: metav1.TypeMeta{
APIVersion: "v1",
Kind: "ConfigMap",
},
ObjectMeta: metav1.ObjectMeta{
Name: "cm-1",
},
Data: map[string]string{
"k99": "v99",
},
}, metav1.UpdateOptions{FieldManager: "test-manager-1"})
handled, configMap, err = reaction(updateAction)
assert.True(t, handled)
if err != nil {
t.Errorf("Failed to apply resource: %v", err)
}
typedCm := configMap.(*v1.ConfigMap)
assert.Equal(t, map[string]string{"k99": "v99"}, typedCm.Data)
}
func TestGetWithExactMatch(t *testing.T) { func TestGetWithExactMatch(t *testing.T) {
scheme := runtime.NewScheme() scheme := runtime.NewScheme()
codecs := serializer.NewCodecFactory(scheme) codecs := serializer.NewCodecFactory(scheme)
@ -408,3 +548,25 @@ func Test_resourceCovers(t *testing.T) {
}) })
} }
} }
var fakeTypeConverter = func() managedfields.TypeConverter {
data, err := os.ReadFile(filepath.Join(strings.Repeat(".."+string(filepath.Separator), 5),
"api", "openapi-spec", "swagger.json"))
if err != nil {
panic(err)
}
swag := spec.Swagger{}
if err := json.Unmarshal(data, &swag); err != nil {
panic(err)
}
convertedDefs := map[string]*spec.Schema{}
for k, v := range swag.Definitions {
vCopy := v
convertedDefs[k] = &vCopy
}
typeConverter, err := managedfields.NewTypeConverter(convertedDefs, false)
if err != nil {
panic(err)
}
return typeConverter
}()