feat: implement client side apply

client/clientsideapply/adoptnonapplied.go

@@ -0,0 +1,63 @@
+// Copyright 2025 The KusionStack 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 clientsideapply
+
+import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager"
+)
+
+type adoptNonAppliedManager struct {
+	fieldManager  fieldmanager.Manager
+	objectCreater runtime.ObjectCreater
+	gvk           schema.GroupVersionKind
+}
+
+var _ fieldmanager.Manager = &adoptNonAppliedManager{}
+
+// NewAdoptNonAppliedManager creates a new wrapped FieldManager that only starts tracking managers after the first apply.
+//
+// This FieldManager behavior is the opposite of the other FieldManager (fieldmanager.SkipNonAppliedManager).
+// It will let the apply field manager take over all fields on liveObj before first apply.
+func NewAdoptNonAppliedManager(fieldManager fieldmanager.Manager, objectCreater runtime.ObjectCreater, gvk schema.GroupVersionKind) fieldmanager.Manager {
+	return &adoptNonAppliedManager{
+		fieldManager:  fieldManager,
+		objectCreater: objectCreater,
+		gvk:           gvk,
+	}
+}
+
+// Update implements Manager.
+func (f *adoptNonAppliedManager) Update(liveObj, newObj runtime.Object, managed fieldmanager.Managed, manager string) (runtime.Object, fieldmanager.Managed, error) {
+	return f.fieldManager.Update(liveObj, newObj, managed, manager)
+}
+
+// Apply implements Manager.
+func (f *adoptNonAppliedManager) Apply(liveObj, appliedObj runtime.Object, managed fieldmanager.Managed, fieldManager string, force bool) (runtime.Object, fieldmanager.Managed, error) {
+	if len(managed.Fields()) == 0 {
+		emptyObj, err := f.objectCreater.New(f.gvk)
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to create empty object of type %v: %w", f.gvk, err)
+		}
+		liveObj, managed, err = f.fieldManager.Apply(emptyObj, liveObj, managed, fieldManager, force)
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to create manager for existing fields: %w", err)
+		}
+	}
+	return f.fieldManager.Apply(liveObj, appliedObj, managed, fieldManager, force)
+}

client/clientsideapply/adoptnonapplied_test.go

@@ -0,0 +1,139 @@
+// Copyright 2025 The KusionStack 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 clientsideapply
+
+import (
+	"github.com/stretchr/testify/suite"
+	"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"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/yaml"
+)
+
+type fakeObjectDefaulter struct{}
+
+func (d *fakeObjectDefaulter) Default(in runtime.Object) {}
+
+func newTestFieldManager(gvk schema.GroupVersionKind, subresource string, chainFieldManager func(fieldmanager.Manager) fieldmanager.Manager) *fieldmanager.FieldManager {
+	typeConverter := fieldmanager.DeducedTypeConverter{}
+	objectConverter := &unstructuredConvertor{}
+	f, err := fieldmanager.NewStructuredMergeManager(
+		typeConverter,
+		objectConverter,
+		&fakeObjectDefaulter{},
+		gvk.GroupVersion(),
+		gvk.GroupVersion(),
+		nil,
+	)
+	if err != nil {
+		panic(err)
+	}
+
+	live := &unstructured.Unstructured{}
+	live.SetGroupVersionKind(gvk)
+
+	f = fieldmanager.NewCapManagersManager(
+		fieldmanager.NewBuildManagerInfoManager(
+			fieldmanager.NewManagedFieldsUpdater(
+				fieldmanager.NewStripMetaManager(f),
+			), gvk.GroupVersion(), subresource,
+		), fieldmanager.DefaultMaxUpdateManagers,
+	)
+
+	if chainFieldManager != nil {
+		f = chainFieldManager(f)
+	}
+
+	return fieldmanager.NewFieldManager(f, subresource)
+}
+
+type adoptNonAppliedManagerTestSuite struct {
+	suite.Suite
+
+	fieldManager *fieldmanager.FieldManager
+}
+
+func (s *adoptNonAppliedManagerTestSuite) SetupSuite() {
+	s.fieldManager = newTestFieldManager(podGVK, "", func(m fieldmanager.Manager) fieldmanager.Manager {
+		return NewAdoptNonAppliedManager(
+			m,
+			&unstructuredCreater{},
+			podGVK,
+		)
+	})
+}
+
+func (s *adoptNonAppliedManagerTestSuite) TestNoUpdateBeforeFirstApply() {
+	liveObj := newEmptyUnstructured(podGVK)
+
+	appliedObj := &unstructured.Unstructured{Object: map[string]any{}}
+	err := yaml.Unmarshal([]byte(`{
+		"apiVersion": "v1",
+		"kind": "Pod",
+		"metadata": {
+			"name": "pod",
+			"labels": {"app": "nginx"}
+		},
+		"spec": {
+			"containers": [{
+				"name":  "nginx",
+				"image": "nginx:latest"
+			}]
+        }
+	}`), &appliedObj.Object)
+	s.Require().NoError(err)
+
+	out, err := s.fieldManager.Apply(liveObj, appliedObj, "fieldmanager_test_apply", false)
+	s.Require().NoError(err)
+	s.Require().Implements((*client.Object)(nil), out)
+	obj := out.(client.Object)
+	managedFields := obj.GetManagedFields()
+	if s.Len(managedFields, 1) {
+		s.Equal("fieldmanager_test_apply", managedFields[0].Manager)
+	}
+}
+
+func (s *adoptNonAppliedManagerTestSuite) TestUpdateBeforeFirstApply() {
+	liveObj := newEmptyUnstructured(podGVK)
+	liveObj.SetLabels(map[string]string{"app": "nginx"})
+
+	appliedObj := &unstructured.Unstructured{Object: map[string]any{}}
+	err := yaml.Unmarshal([]byte(`{
+		"apiVersion": "v1",
+		"kind": "Pod",
+		"metadata": {
+			"name": "pod",
+			"labels": {"app": "nginx"}
+		},
+		"spec": {
+			"containers": [{
+				"name":  "nginx",
+				"image": "nginx:latest"
+			}]
+        }
+	}`), &appliedObj.Object)
+	s.Require().NoError(err)
+
+	out, err := s.fieldManager.Apply(liveObj, appliedObj, "fieldmanager_test_apply", false)
+	s.Require().NoError(err)
+	s.Require().Implements((*client.Object)(nil), out)
+	obj := out.(client.Object)
+	managedFields := obj.GetManagedFields()
+	if s.Len(managedFields, 1) {
+		s.Equal("fieldmanager_test_apply", managedFields[0].Manager)
+	}
+}

client/clientsideapply/clientapply.go

@@ -0,0 +1,118 @@
+// Copyright 2025 The KusionStack 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 clientsideapply
+
+import (
+	"encoding/json"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apiserver/pkg/endpoints/handlers/fieldmanager"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+const (
+	ClientSideApplyManagedFieldsAnnotationKey = "meta.k8s.io/client-side-apply-managed-fields"
+)
+
+type FieldManager interface {
+	Apply(liveObj, appliedObj client.Object, fieldManager string, force bool) (client.Object, error)
+}
+
+type clientApplyFieldManager struct {
+	fieldmanager *fieldmanager.FieldManager
+	gvk          schema.GroupVersionKind
+}
+
+var _ FieldManager = &clientApplyFieldManager{}
+
+func (f *clientApplyFieldManager) Apply(liveObj, appliedObj client.Object, fieldManager string, force bool) (client.Object, error) {
+	if liveObj.GetObjectKind().GroupVersionKind().Empty() {
+		liveObj.GetObjectKind().SetGroupVersionKind(f.gvk)
+	}
+	if appliedObj.GetObjectKind().GroupVersionKind().Empty() {
+		appliedObj.GetObjectKind().SetGroupVersionKind(f.gvk)
+	}
+
+	f.decodeManagedFieldsFromAnnotation(liveObj)
+	obj, err := f.fieldmanager.Apply(liveObj, appliedObj, fieldManager, force)
+	if err != nil {
+		return nil, err
+	}
+	clientObj := obj.(client.Object)
+	f.encodeManagedFieldsFromAnnotation(clientObj)
+	return clientObj, nil
+}
+
+func (f *clientApplyFieldManager) decodeManagedFieldsFromAnnotation(obj client.Object) {
+	if len(obj.GetManagedFields()) > 0 {
+		// managedFields already exist, skip
+		return
+	}
+	// get managed fields from annotation
+	annotations := obj.GetAnnotations()
+	if len(annotations) == 0 {
+		return
+	}
+	mf := annotations[ClientSideApplyManagedFieldsAnnotationKey]
+	if len(mf) == 0 {
+		return
+	}
+
+	fields := decodeManagedFields(mf)
+	if len(fields) == 0 {
+		return
+	}
+	obj.SetManagedFields(fields)
+}
+
+func (f *clientApplyFieldManager) encodeManagedFieldsFromAnnotation(obj client.Object) {
+	managedFields := obj.GetManagedFields()
+	if len(managedFields) == 0 {
+		// managedFields already exist, skip
+		return
+	}
+
+	fieldsValue := encodeManagedFields(managedFields)
+	// get managed fields from annotation
+	annotations := obj.GetAnnotations()
+	if len(annotations) == 0 {
+		annotations = make(map[string]string)
+	}
+	annotations[ClientSideApplyManagedFieldsAnnotationKey] = fieldsValue
+	obj.SetAnnotations(annotations)
+	obj.SetManagedFields(nil)
+}
+
+func encodeManagedFields(managedFields []metav1.ManagedFieldsEntry) string {
+	meta := &struct {
+		ManagedFields []metav1.ManagedFieldsEntry `json:"managedFields"`
+	}{
+		ManagedFields: managedFields,
+	}
+	mfStr, _ := json.Marshal(meta)
+	return string(mfStr)
+}
+
+func decodeManagedFields(value string) []metav1.ManagedFieldsEntry {
+	meta := &struct {
+		ManagedFields []metav1.ManagedFieldsEntry `json:"managedFields"`
+	}{}
+	err := json.Unmarshal([]byte(value), meta)
+	if err != nil {
+		return nil
+	}
+	return meta.ManagedFields
+}