Fix SSA and client apply migration cleanup

Author: michael-burt

internal/remote/client.go

@@ -690,6 +690,31 @@ func stripApplyHistoryAnnotations(obj model.K8sLocalObject) model.K8sLocalObject
 	return ret
 }
 
+func markLegacyApplyAnnotationsForDeletion(obj model.K8sLocalObject, remObj *unstructured.Unstructured) model.K8sLocalObject {
+	if !hasLegacyClientSideApplyState(remObj) {
+		return obj
+	}
+	ret := cloneLocalObject(obj)
+	metadata, found, err := unstructured.NestedMap(ret.ToUnstructured().Object, "metadata")
+	if err != nil || !found {
+		metadata = map[string]interface{}{}
+	}
+	annotations, found, err := unstructured.NestedMap(metadata, "annotations")
+	if err != nil || !found {
+		annotations = map[string]interface{}{}
+	}
+	remoteAnnotations := remObj.GetAnnotations()
+	if remoteAnnotations[model.QbecNames.PristineAnnotation] != "" {
+		annotations[model.QbecNames.PristineAnnotation] = nil
+	}
+	if remoteAnnotations[kubectlLastConfig] != "" {
+		annotations[kubectlLastConfig] = nil
+	}
+	metadata["annotations"] = annotations
+	ret.ToUnstructured().Object["metadata"] = metadata
+	return ret
+}
+
 func managedFieldSet(obj *unstructured.Unstructured, fieldManager string) (*fieldpath.Set, error) {
 	set := fieldpath.NewSet()
 	if obj == nil {
@@ -872,8 +897,20 @@ func sameObject(lhs, rhs *unstructured.Unstructured, desired model.K8sLocalObjec
 	), nil
 }
 
+func hasLegacyClientSideApplyState(obj *unstructured.Unstructured) bool {
+	if obj == nil {
+		return false
+	}
+	annotations := obj.GetAnnotations()
+	if len(annotations) == 0 {
+		return false
+	}
+	return annotations[model.QbecNames.PristineAnnotation] != "" || annotations[kubectlLastConfig] != ""
+}
+
 func (c *Client) serverSideApply(ctx context.Context, obj model.K8sLocalObject, remObj *unstructured.Unstructured, opts SyncOptions, operation string) (*updateResult, error) {
 	obj = stripApplyHistoryAnnotations(obj)
+	obj = markLegacyApplyAnnotationsForDeletion(obj, remObj)
 	b, err := json.Marshal(obj)
 	if err != nil {
 		return nil, errors.Wrap(err, "json marshal")
@@ -897,7 +934,7 @@ func (c *Client) serverSideApply(ctx context.Context, obj model.K8sLocalObject,
 	if opts.DryRun {
 		patchOpts.DryRun = []string{metav1.DryRunAll}
 	}
-	if opts.ForceConflicts {
+	if opts.ForceConflicts || hasLegacyClientSideApplyState(remObj) {
 		force := true
 		patchOpts.Force = &force
 	}

internal/remote/client_ssa_test.go

@@ -350,6 +350,40 @@ func TestMaybeUpdateServerSideApplyDetectsRemovedManagedFields(t *testing.T) {
 	assert.Equal(t, apiTypes.ApplyPatchType, recorder.patchType)
 }
 
+func TestMaybeUpdateServerSideApplyForcesLegacyClientSideMigration(t *testing.T) {
+	existing := newConfigMap("default", "ssa-config").ToUnstructured()
+	annotations := existing.GetAnnotations()
+	annotations[model.QbecNames.PristineAnnotation] = "pristine"
+	existing.SetAnnotations(annotations)
+
+	client, recorder := newServerSideApplyClient(t, existing.DeepCopy())
+	result, err := client.maybeUpdate(context.Background(), newConfigMap("default", "ssa-config"), existing.DeepCopy(), SyncOptions{
+		ApplyStrategy:   model.ApplyStrategyServer,
+		DisableUpdateFn: func(model.K8sMeta) bool { return false },
+	}, internalSyncOptions{})
+	require.NoError(t, err)
+	assert.Equal(t, identicalObjects, result.SkipReason)
+	require.NotNil(t, recorder.patchOptions.Force)
+	assert.True(t, *recorder.patchOptions.Force)
+}
+
+func TestMaybeUpdateServerSideApplyForcesKubectlMigration(t *testing.T) {
+	existing := newConfigMap("default", "ssa-config").ToUnstructured()
+	annotations := existing.GetAnnotations()
+	annotations[kubectlLastConfig] = `{"apiVersion":"v1"}`
+	existing.SetAnnotations(annotations)
+
+	client, recorder := newServerSideApplyClient(t, existing.DeepCopy())
+	result, err := client.maybeUpdate(context.Background(), newConfigMap("default", "ssa-config"), existing.DeepCopy(), SyncOptions{
+		ApplyStrategy:   model.ApplyStrategyServer,
+		DisableUpdateFn: func(model.K8sMeta) bool { return false },
+	}, internalSyncOptions{})
+	require.NoError(t, err)
+	assert.Equal(t, identicalObjects, result.SkipReason)
+	require.NotNil(t, recorder.patchOptions.Force)
+	assert.True(t, *recorder.patchOptions.Force)
+}
+
 func TestMaybeUpdateServerSideApplyTreatsEmptyDesiredCollectionAsUpdate(t *testing.T) {
 	existing := newConfigMapWithData("default", "ssa-config", map[string]interface{}{
 		"foo": "bar",

internal/remote/pristine.go

@@ -19,6 +19,7 @@ import (
 	"compress/gzip"
 	"encoding/base64"
 	"encoding/json"
+	"strings"
 
 	"github.com/pkg/errors"
 	"github.com/splunk/qbec/internal/model"
@@ -196,11 +197,42 @@ func pristineFromManagedFields(obj *unstructured.Unstructured, fieldManager stri
 	return base, nil
 }
 
-func pristineBytesForClientSideApply(obj *unstructured.Unstructured) ([]byte, error) {
-	pristine, _ := getPristineVersion(obj, false)
+func mergeQbecMetadata(pristine, obj *unstructured.Unstructured) *unstructured.Unstructured {
 	if pristine == nil {
 		pristine = objectIdentityBase(obj)
 	}
+
+	annotations := pristine.GetAnnotations()
+	if annotations == nil {
+		annotations = map[string]string{}
+	}
+	for k, v := range obj.GetAnnotations() {
+		if strings.HasPrefix(k, model.QBECMetadataPrefix) || strings.HasPrefix(k, model.QBECDirectivesNamespace) {
+			annotations[k] = v
+		}
+	}
+	if len(annotations) > 0 {
+		pristine.SetAnnotations(annotations)
+	}
+
+	labels := pristine.GetLabels()
+	if labels == nil {
+		labels = map[string]string{}
+	}
+	for k, v := range obj.GetLabels() {
+		if strings.HasPrefix(k, model.QBECMetadataPrefix) {
+			labels[k] = v
+		}
+	}
+	if len(labels) > 0 {
+		pristine.SetLabels(labels)
+	}
+	return pristine
+}
+
+func pristineBytesForClientSideApply(obj *unstructured.Unstructured) ([]byte, error) {
+	pristine, _ := getPristineVersion(obj, false)
+	pristine = mergeQbecMetadata(pristine, obj)
 	return json.Marshal(pristine)
 }
 

internal/remote/pristine_test.go

@@ -304,6 +304,38 @@ func TestClientSideApplyUsesManagedFieldsPristineForMetadataDeletion(t *testing.
 	assert.Contains(t, string(pristineBytes), `"qbec.io/component"`)
 }
 
+func TestClientSideApplyUsesManagedFieldsPristineForDirectiveDeletion(t *testing.T) {
+	desired := newConfigMap("default", "ssa-config")
+	annotations := desired.ToUnstructured().GetAnnotations()
+	delete(annotations, model.QbecNames.Directives.ApplyStrategy)
+	desired.ToUnstructured().SetAnnotations(annotations)
+
+	serverObj := newConfigMap("default", "ssa-config").ToUnstructured()
+	annotations = serverObj.GetAnnotations()
+	annotations[model.QbecNames.Directives.ApplyStrategy] = string(model.ApplyStrategyServer)
+	serverObj.SetAnnotations(annotations)
+	serverObj.SetManagedFields([]metav1.ManagedFieldsEntry{
+		{
+			Manager:    ssaFieldManager,
+			Operation:  metav1.ManagedFieldsOperationApply,
+			FieldsType: "FieldsV1",
+			FieldsV1: &metav1.FieldsV1{
+				Raw: []byte(`{"f:data":{"f:foo":{}},"f:metadata":{"f:annotations":{"f:qbec.io~1component":{}},"f:labels":{"f:qbec.io~1application":{},"f:qbec.io~1environment":{}}}}`),
+			},
+		},
+	})
+
+	p := patcher{cfgProvider: pristineBytesForClientSideApply}
+	result, err := p.getPatchContents(serverObj, desired)
+	require.NoError(t, err)
+	assert.Empty(t, result.SkipReason)
+	assert.Contains(t, string(result.patch), `"directives.qbec.io/apply-strategy":null`)
+
+	pristineBytes, err := pristineBytesForClientSideApply(serverObj)
+	require.NoError(t, err)
+	assert.Contains(t, string(pristineBytes), `"directives.qbec.io/apply-strategy":"server"`)
+}
+
 func TestClientServerClientRoundTripNoop(t *testing.T) {
 	desired := newConfigMap("default", "ssa-config")
 	clientApplied, err := qbecPristine{}.createFromPristine(desired)