Merge pull request #270 from justinsb/smd_is_super

mockkubeapiserver: add test using SMD library

Author: k8s-ci-robot

mockkubeapiserver/Makefile

@@ -0,0 +1,4 @@
+.PHONY: update-schema
+update-schema:
+	curl https://raw.githubusercontent.com/kubernetes/kubernetes/master/staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go | \
+	awk '/typed.YAMLObject/,/`)/'  | sed 's/`)//g' | sed 's/var schemaYAML = typed.YAMLObject(`//g' > kubernetes_builtin_schema.yaml

mockkubeapiserver/apiserver.go

@@ -32,7 +32,12 @@ func NewMockKubeAPIServer(addr string) (*MockKubeAPIServer, error) {
 
 	s.httpServer = &http.Server{Addr: addr, Handler: s}
 
-	s.storage = NewMemoryStorage(NewTestClock(), NewTestUIDGenerator())
+	var err error
+
+	s.storage, err = NewMemoryStorage(NewTestClock(), NewTestUIDGenerator())
+	if err != nil {
+		return nil, err
+	}
 
 	return s, nil
 }

mockkubeapiserver/forked/README.md

@@ -0,0 +1,10 @@
+This directory contains code that we copy from various places in the
+kubernetes source code that are generally hard to import otherwise.
+
+The intent here is that we demonstrate the need & utility of exporting
+these functions in a stable location, and then if/when k/k exports
+them we can (reasonably) easily switch, because this is only
+test code.
+
+As far as possible, we try to keep the same function names and not
+change the code.  We want to reunify in the long-term.

mockkubeapiserver/forked/managedfields.go

@@ -0,0 +1,111 @@
+package forked
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"sigs.k8s.io/structured-merge-diff/v4/fieldpath"
+)
+
+// EncodeObjectManagedFields converts and stores the fieldpathManagedFields into the objects ManagedFields
+func EncodeObjectManagedFields(obj runtime.Object, fields fieldpath.ManagedFields, times map[string]*metav1.Time) error {
+	accessor, err := meta.Accessor(obj)
+	if err != nil {
+		panic(fmt.Sprintf("couldn't get accessor: %v", err))
+	}
+
+	encodedManagedFields, err := encodeManagedFields(fields, times)
+	if err != nil {
+		return fmt.Errorf("failed to convert back managed fields to API: %v", err)
+	}
+	accessor.SetManagedFields(encodedManagedFields)
+
+	return nil
+}
+
+// encodeManagedFields converts ManagedFields from the format used by
+// sigs.k8s.io/structured-merge-diff to the wire format (api format)
+func encodeManagedFields(fields fieldpath.ManagedFields, times map[string]*metav1.Time) (encodedManagedFields []metav1.ManagedFieldsEntry, err error) {
+	if len(fields) == 0 {
+		return nil, nil
+	}
+	encodedManagedFields = []metav1.ManagedFieldsEntry{}
+	for manager := range fields {
+		versionedSet := fields[manager]
+		v, err := encodeManagerVersionedSet(manager, versionedSet)
+		if err != nil {
+			return nil, fmt.Errorf("error encoding versioned set for %v: %v", manager, err)
+		}
+		if t, ok := times[manager]; ok {
+			v.Time = t
+		}
+		encodedManagedFields = append(encodedManagedFields, *v)
+	}
+	return sortEncodedManagedFields(encodedManagedFields)
+}
+
+func sortEncodedManagedFields(encodedManagedFields []metav1.ManagedFieldsEntry) (sortedManagedFields []metav1.ManagedFieldsEntry, err error) {
+	sort.Slice(encodedManagedFields, func(i, j int) bool {
+		p, q := encodedManagedFields[i], encodedManagedFields[j]
+
+		if p.Operation != q.Operation {
+			return p.Operation < q.Operation
+		}
+
+		pSeconds, qSeconds := int64(0), int64(0)
+		if p.Time != nil {
+			pSeconds = p.Time.Unix()
+		}
+		if q.Time != nil {
+			qSeconds = q.Time.Unix()
+		}
+		if pSeconds != qSeconds {
+			return pSeconds < qSeconds
+		}
+
+		if p.Manager != q.Manager {
+			return p.Manager < q.Manager
+		}
+
+		if p.APIVersion != q.APIVersion {
+			return p.APIVersion < q.APIVersion
+		}
+		return p.Subresource < q.Subresource
+	})
+
+	return encodedManagedFields, nil
+}
+
+func encodeManagerVersionedSet(manager string, versionedSet fieldpath.VersionedSet) (encodedVersionedSet *metav1.ManagedFieldsEntry, err error) {
+	encodedVersionedSet = &metav1.ManagedFieldsEntry{}
+
+	// Get as many fields as we can from the manager identifier
+	err = json.Unmarshal([]byte(manager), encodedVersionedSet)
+	if err != nil {
+		return nil, fmt.Errorf("error unmarshalling manager identifier %v: %v", manager, err)
+	}
+
+	// Get the APIVersion, Operation, and Fields from the VersionedSet
+	encodedVersionedSet.APIVersion = string(versionedSet.APIVersion())
+	if versionedSet.Applied() {
+		encodedVersionedSet.Operation = metav1.ManagedFieldsOperationApply
+	}
+	encodedVersionedSet.FieldsType = "FieldsV1"
+	fields, err := SetToFields(*versionedSet.Set())
+	if err != nil {
+		return nil, fmt.Errorf("error encoding set: %v", err)
+	}
+	encodedVersionedSet.FieldsV1 = &fields
+
+	return encodedVersionedSet, nil
+}
+
+// SetToFields creates a trie of fields from an input set of paths
+func SetToFields(s fieldpath.Set) (f metav1.FieldsV1, err error) {
+	f.Raw, err = s.ToJSON()
+	return f, err
+}

mockkubeapiserver/go.mod

@@ -3,15 +3,16 @@ module sigs.k8s.io/kubebuilder-declarative-pattern/mockkubeapiserver
 go 1.19
 
 require (
+	github.com/google/go-cmp v0.5.8
 	k8s.io/apimachinery v0.23.0
 	k8s.io/klog/v2 v2.70.1
+	sigs.k8s.io/structured-merge-diff/v4 v4.2.3
 	sigs.k8s.io/yaml v1.3.0
 )
 
 require (
 	github.com/go-logr/logr v1.2.3 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/google/go-cmp v0.5.8 // indirect
 	github.com/google/gofuzz v1.1.0 // indirect
 	github.com/google/uuid v1.1.2 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
@@ -23,5 +24,4 @@ require (
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	k8s.io/utils v0.0.0-20220728103510-ee6ede2d64ed // indirect
 	sigs.k8s.io/json v0.0.0-20220713155537-f223a00ba0e2 // indirect
-	sigs.k8s.io/structured-merge-diff/v4 v4.2.3 // indirect
 )

mockkubeapiserver/kubernetes_builtin_schema.go

@@ -0,0 +1,39 @@
+package mockkubeapiserver
+
+import (
+	"fmt"
+	"sync"
+
+	"sigs.k8s.io/structured-merge-diff/v4/typed"
+
+	_ "embed"
+)
+
+//go:embed kubernetes_builtin_schema.yaml
+var kubernetesBuiltinSchemaYAML string
+
+type Schema struct {
+	Parser *typed.Parser
+}
+
+var cacheKubernetesBuiltinSchema *Schema
+
+var mutexKubernetesBuiltinSchema sync.Mutex
+
+func KubernetesBuiltInSchema() (*Schema, error) {
+	mutexKubernetesBuiltinSchema.Lock()
+	defer mutexKubernetesBuiltinSchema.Unlock()
+
+	if cacheKubernetesBuiltinSchema != nil {
+		return cacheKubernetesBuiltinSchema, nil
+	}
+
+	schemaYAML := kubernetesBuiltinSchemaYAML
+
+	parser, err := typed.NewParser(typed.YAMLObject(schemaYAML))
+	if err != nil {
+		return nil, fmt.Errorf("error parsing schema: %w", err)
+	}
+	cacheKubernetesBuiltinSchema = &Schema{Parser: parser}
+	return cacheKubernetesBuiltinSchema, nil
+}