vendor: Update vendor logic

vendor/k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/fieldmanager.go

@@ -18,258 +18,144 @@ package fieldmanager
 
 import (
 	"fmt"
-	"time"
 
-	"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"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager/internal"
-	"k8s.io/klog"
 	openapiproto "k8s.io/kube-openapi/pkg/util/proto"
 	"sigs.k8s.io/structured-merge-diff/fieldpath"
-	"sigs.k8s.io/structured-merge-diff/merge"
-	"sigs.k8s.io/yaml"
 )
 
+// DefaultMaxUpdateManagers defines the default maximum retained number of managedFields entries from updates
+// if the number of update managers exceeds this, the oldest entries will be merged until the number is below the maximum.
+// TODO(jennybuckley): Determine if this is really the best value. Ideally we wouldn't unnecessarily merge too many entries.
+const DefaultMaxUpdateManagers int = 10
+
+// Managed groups a fieldpath.ManagedFields together with the timestamps associated with each operation.
+type Managed interface {
+	// Fields gets the fieldpath.ManagedFields.
+	Fields() fieldpath.ManagedFields
+
+	// Times gets the timestamps associated with each operation.
+	Times() map[string]*metav1.Time
+}
+
+// Manager updates the managed fields and merges applied configurations.
+type Manager interface {
+	// Update is used when the object has already been merged (non-apply
+	// use-case), and simply updates the managed fields in the output
+	// object.
+	Update(liveObj, newObj runtime.Object, managed Managed, manager string) (runtime.Object, Managed, error)
+
+	// Apply is used when server-side apply is called, as it merges the
+	// object and updates the managed fields.
+	Apply(liveObj runtime.Object, patch []byte, managed Managed, fieldManager string, force bool) (runtime.Object, Managed, error)
+}
+
 // FieldManager updates the managed fields and merge applied
 // configurations.
 type FieldManager struct {
-	typeConverter   internal.TypeConverter
-	objectConverter runtime.ObjectConvertor
-	objectDefaulter runtime.ObjectDefaulter
-	groupVersion    schema.GroupVersion
-	hubVersion      schema.GroupVersion
-	updater         merge.Updater
+	fieldManager Manager
 }
 
-// NewFieldManager creates a new FieldManager that merges apply requests
+// NewFieldManager creates a new FieldManager that decodes, manages, then re-encodes managedFields
+// on update and apply requests.
+func NewFieldManager(f Manager) *FieldManager {
+	return &FieldManager{f}
+}
+
+// NewDefaultFieldManager creates a new FieldManager that merges apply requests
 // and update managed fields for other types of requests.
-func NewFieldManager(models openapiproto.Models, objectConverter runtime.ObjectConvertor, objectDefaulter runtime.ObjectDefaulter, gv schema.GroupVersion, hub schema.GroupVersion) (*FieldManager, error) {
-	typeConverter, err := internal.NewTypeConverter(models)
+func NewDefaultFieldManager(models openapiproto.Models, objectConverter runtime.ObjectConvertor, objectDefaulter runtime.ObjectDefaulter, objectCreater runtime.ObjectCreater, kind schema.GroupVersionKind, hub schema.GroupVersion) (*FieldManager, error) {
+	f, err := NewStructuredMergeManager(models, objectConverter, objectDefaulter, kind.GroupVersion(), hub)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to create field manager: %v", err)
 	}
-
-	return &FieldManager{
-		typeConverter:   typeConverter,
-		objectConverter: objectConverter,
-		objectDefaulter: objectDefaulter,
-		groupVersion:    gv,
-		hubVersion:      hub,
-		updater: merge.Updater{
-			Converter: internal.NewVersionConverter(typeConverter, objectConverter, hub),
-		},
-	}, nil
+	return newDefaultFieldManager(f, objectCreater, kind), nil
 }
 
-// NewCRDFieldManager creates a new FieldManager specifically for
-// CRDs. This doesn't use openapi models (and it doesn't support the
-// validation field right now).
-func NewCRDFieldManager(objectConverter runtime.ObjectConvertor, objectDefaulter runtime.ObjectDefaulter, gv schema.GroupVersion, hub schema.GroupVersion) *FieldManager {
-	return &FieldManager{
-		typeConverter:   internal.DeducedTypeConverter{},
-		objectConverter: objectConverter,
-		objectDefaulter: objectDefaulter,
-		groupVersion:    gv,
-		hubVersion:      hub,
-		updater: merge.Updater{
-			Converter: internal.NewCRDVersionConverter(internal.DeducedTypeConverter{}, objectConverter, hub),
-		},
+// NewDefaultCRDFieldManager creates a new FieldManager specifically for
+// CRDs. This allows for the possibility of fields which are not defined
+// in models, as well as having no models defined at all.
+func NewDefaultCRDFieldManager(models openapiproto.Models, objectConverter runtime.ObjectConvertor, objectDefaulter runtime.ObjectDefaulter, objectCreater runtime.ObjectCreater, kind schema.GroupVersionKind, hub schema.GroupVersion, preserveUnknownFields bool) (_ *FieldManager, err error) {
+	f, err := NewCRDStructuredMergeManager(models, objectConverter, objectDefaulter, kind.GroupVersion(), hub, preserveUnknownFields)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create field manager: %v", err)
 	}
+	return newDefaultFieldManager(f, objectCreater, kind), nil
+}
+
+// newDefaultFieldManager is a helper function which wraps a Manager with certain default logic.
+func newDefaultFieldManager(f Manager, objectCreater runtime.ObjectCreater, kind schema.GroupVersionKind) *FieldManager {
+	f = NewStripMetaManager(f)
+	f = NewBuildManagerInfoManager(f, kind.GroupVersion())
+	f = NewCapManagersManager(f, DefaultMaxUpdateManagers)
+	f = NewSkipNonAppliedManager(f, objectCreater, kind)
+	return NewFieldManager(f)
 }
 
 // Update is used when the object has already been merged (non-apply
 // use-case), and simply updates the managed fields in the output
 // object.
-func (f *FieldManager) Update(liveObj, newObj runtime.Object, manager string) (runtime.Object, error) {
+func (f *FieldManager) Update(liveObj, newObj runtime.Object, manager string) (object runtime.Object, err error) {
 	// If the object doesn't have metadata, we should just return without trying to
 	// set the managedFields at all, so creates/updates/patches will work normally.
-	if _, err := meta.Accessor(newObj); err != nil {
+	if _, err = meta.Accessor(newObj); err != nil {
 		return newObj, nil
 	}
 
 	// First try to decode the managed fields provided in the update,
 	// This is necessary to allow directly updating managed fields.
-	managed, err := internal.DecodeObjectManagedFields(newObj)
-
-	// If the managed field is empty or we failed to decode it,
-	// let's try the live object. This is to prevent clients who
-	// don't understand managedFields from deleting it accidentally.
-	if err != nil || len(managed) == 0 {
+	var managed Managed
+	if managed, err = internal.DecodeObjectManagedFields(newObj); err != nil || len(managed.Fields()) == 0 {
+		// If the managed field is empty or we failed to decode it,
+		// let's try the live object. This is to prevent clients who
+		// don't understand managedFields from deleting it accidentally.
 		managed, err = internal.DecodeObjectManagedFields(liveObj)
 		if err != nil {
 			return nil, fmt.Errorf("failed to decode managed fields: %v", err)
 		}
 	}
-	newObjVersioned, err := f.toVersioned(newObj)
-	if err != nil {
-		return nil, fmt.Errorf("failed to convert new object to proper version: %v", err)
-	}
-	liveObjVersioned, err := f.toVersioned(liveObj)
-	if err != nil {
-		return nil, fmt.Errorf("failed to convert live object to proper version: %v", err)
-	}
-	internal.RemoveObjectManagedFields(liveObjVersioned)
-	internal.RemoveObjectManagedFields(newObjVersioned)
-	newObjTyped, err := f.typeConverter.ObjectToTyped(newObjVersioned)
-	if err != nil {
-		// Return newObj and just by-pass fields update. This really shouldn't happen.
-		klog.Errorf("[SHOULD NOT HAPPEN] failed to create typed new object: %v", err)
-		return newObj, nil
-	}
-	liveObjTyped, err := f.typeConverter.ObjectToTyped(liveObjVersioned)
-	if err != nil {
-		// Return newObj and just by-pass fields update. This really shouldn't happen.
-		klog.Errorf("[SHOULD NOT HAPPEN] failed to create typed live object: %v", err)
-		return newObj, nil
-	}
-	apiVersion := fieldpath.APIVersion(f.groupVersion.String())
-	manager, err = f.buildManagerInfo(manager, metav1.ManagedFieldsOperationUpdate)
-	if err != nil {
-		return nil, fmt.Errorf("failed to build manager identifier: %v", err)
+
+	internal.RemoveObjectManagedFields(liveObj)
+	internal.RemoveObjectManagedFields(newObj)
+
+	if object, managed, err = f.fieldManager.Update(liveObj, newObj, managed, manager); err != nil {
+		return nil, err
 	}
 
-	managed, err = f.updater.Update(liveObjTyped, newObjTyped, apiVersion, managed, manager)
-	if err != nil {
-		return nil, fmt.Errorf("failed to update ManagedFields: %v", err)
-	}
-	managed = f.stripFields(managed, manager)
-
-	if err := internal.EncodeObjectManagedFields(newObj, managed); err != nil {
+	if err = internal.EncodeObjectManagedFields(object, managed); err != nil {
 		return nil, fmt.Errorf("failed to encode managed fields: %v", err)
 	}
 
-	return newObj, nil
+	return object, nil
 }
 
 // Apply is used when server-side apply is called, as it merges the
-// object and update the managed fields.
-func (f *FieldManager) Apply(liveObj runtime.Object, patch []byte, fieldManager string, force bool) (runtime.Object, error) {
+// object and updates the managed fields.
+func (f *FieldManager) Apply(liveObj runtime.Object, patch []byte, manager string, force bool) (object runtime.Object, err error) {
 	// If the object doesn't have metadata, apply isn't allowed.
-	if _, err := meta.Accessor(liveObj); err != nil {
+	if _, err = meta.Accessor(liveObj); err != nil {
 		return nil, fmt.Errorf("couldn't get accessor: %v", err)
 	}
 
-	managed, err := internal.DecodeObjectManagedFields(liveObj)
-	if err != nil {
+	// Decode the managed fields in the live object, since it isn't allowed in the patch.
+	var managed Managed
+	if managed, err = internal.DecodeObjectManagedFields(liveObj); err != nil {
 		return nil, fmt.Errorf("failed to decode managed fields: %v", err)
 	}
-	// Check that the patch object has the same version as the live object
-	patchObj := &unstructured.Unstructured{Object: map[string]interface{}{}}
 
-	if err := yaml.Unmarshal(patch, &patchObj.Object); err != nil {
-		return nil, errors.NewBadRequest(fmt.Sprintf("error decoding YAML: %v", err))
-	}
-	if patchObj.GetAPIVersion() != f.groupVersion.String() {
-		return nil,
-			errors.NewBadRequest(
-				fmt.Sprintf("Incorrect version specified in apply patch. "+
-					"Specified patch version: %s, expected: %s",
-					patchObj.GetAPIVersion(), f.groupVersion.String()))
-	}
+	internal.RemoveObjectManagedFields(liveObj)
 
-	liveObjVersioned, err := f.toVersioned(liveObj)
-	if err != nil {
-		return nil, fmt.Errorf("failed to convert live object to proper version: %v", err)
-	}
-	internal.RemoveObjectManagedFields(liveObjVersioned)
-
-	patchObjTyped, err := f.typeConverter.YAMLToTyped(patch)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create typed patch object: %v", err)
-	}
-	liveObjTyped, err := f.typeConverter.ObjectToTyped(liveObjVersioned)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create typed live object: %v", err)
-	}
-	manager, err := f.buildManagerInfo(fieldManager, metav1.ManagedFieldsOperationApply)
-	if err != nil {
-		return nil, fmt.Errorf("failed to build manager identifier: %v", err)
-	}
-
-	apiVersion := fieldpath.APIVersion(f.groupVersion.String())
-	newObjTyped, managed, err := f.updater.Apply(liveObjTyped, patchObjTyped, apiVersion, managed, manager, force)
-	if err != nil {
-		if conflicts, ok := err.(merge.Conflicts); ok {
-			return nil, internal.NewConflictError(conflicts)
-		}
+	if object, managed, err = f.fieldManager.Apply(liveObj, patch, managed, manager, force); err != nil {
 		return nil, err
 	}
-	managed = f.stripFields(managed, manager)
 
-	newObj, err := f.typeConverter.TypedToObject(newObjTyped)
-	if err != nil {
-		return nil, fmt.Errorf("failed to convert new typed object to object: %v", err)
-	}
-
-	if err := internal.EncodeObjectManagedFields(newObj, managed); err != nil {
+	if err = internal.EncodeObjectManagedFields(object, managed); err != nil {
 		return nil, fmt.Errorf("failed to encode managed fields: %v", err)
 	}
 
-	newObjVersioned, err := f.toVersioned(newObj)
-	if err != nil {
-		return nil, fmt.Errorf("failed to convert new object to proper version: %v", err)
-	}
-	f.objectDefaulter.Default(newObjVersioned)
-
-	newObjUnversioned, err := f.toUnversioned(newObjVersioned)
-	if err != nil {
-		return nil, fmt.Errorf("failed to convert to unversioned: %v", err)
-	}
-	return newObjUnversioned, nil
-}
-
-func (f *FieldManager) toVersioned(obj runtime.Object) (runtime.Object, error) {
-	return f.objectConverter.ConvertToVersion(obj, f.groupVersion)
-}
-
-func (f *FieldManager) toUnversioned(obj runtime.Object) (runtime.Object, error) {
-	return f.objectConverter.ConvertToVersion(obj, f.hubVersion)
-}
-
-func (f *FieldManager) buildManagerInfo(prefix string, operation metav1.ManagedFieldsOperationType) (string, error) {
-	managerInfo := metav1.ManagedFieldsEntry{
-		Manager:    prefix,
-		Operation:  operation,
-		APIVersion: f.groupVersion.String(),
-		Time:       &metav1.Time{Time: time.Now().UTC()},
-	}
-	if managerInfo.Manager == "" {
-		managerInfo.Manager = "unknown"
-	}
-	return internal.BuildManagerIdentifier(&managerInfo)
-}
-
-// stripSet is the list of fields that should never be part of a mangedFields.
-var stripSet = fieldpath.NewSet(
-	fieldpath.MakePathOrDie("apiVersion"),
-	fieldpath.MakePathOrDie("kind"),
-	fieldpath.MakePathOrDie("metadata", "name"),
-	fieldpath.MakePathOrDie("metadata", "namespace"),
-	fieldpath.MakePathOrDie("metadata", "creationTimestamp"),
-	fieldpath.MakePathOrDie("metadata", "selfLink"),
-	fieldpath.MakePathOrDie("metadata", "uid"),
-	fieldpath.MakePathOrDie("metadata", "clusterName"),
-	fieldpath.MakePathOrDie("metadata", "generation"),
-	fieldpath.MakePathOrDie("metadata", "managedFields"),
-	fieldpath.MakePathOrDie("metadata", "resourceVersion"),
-)
-
-// stripFields removes a predefined set of paths found in typed from managed and returns the updated ManagedFields
-func (f *FieldManager) stripFields(managed fieldpath.ManagedFields, manager string) fieldpath.ManagedFields {
-	vs, ok := managed[manager]
-	if ok {
-		if vs == nil {
-			panic(fmt.Sprintf("Found unexpected nil manager which should never happen: %s", manager))
-		}
-		vs.Set = vs.Set.Difference(stripSet)
-		if vs.Set.Empty() {
-			delete(managed, manager)
-		}
-	}
-
-	return managed
+	return object, nil
 }