Merge pull request #70734 from yue9944882/chore/prune-runtime-versioned-objects

Remove runtime.VersionedObject from universal apimachinery

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/helpers.go

@@ -415,12 +415,6 @@ func (s unstructuredJSONScheme) decodeInto(data []byte, obj runtime.Object) erro
 		return s.decodeToUnstructured(data, x)
 	case *UnstructuredList:
 		return s.decodeToList(data, x)
-	case *runtime.VersionedObjects:
-		o, err := s.decode(data)
-		if err == nil {
-			x.Objects = []runtime.Object{o}
-		}
-		return err
 	default:
 		return json.Unmarshal(data, x)
 	}

staging/src/k8s.io/apimachinery/pkg/runtime/register.go

@@ -29,33 +29,3 @@ func (obj *TypeMeta) GroupVersionKind() schema.GroupVersionKind {
 }
 
 func (obj *TypeMeta) GetObjectKind() schema.ObjectKind { return obj }
-
-// GetObjectKind implements Object for VersionedObjects, returning an empty ObjectKind
-// interface if no objects are provided, or the ObjectKind interface of the object in the
-// highest array position.
-func (obj *VersionedObjects) GetObjectKind() schema.ObjectKind {
-	last := obj.Last()
-	if last == nil {
-		return schema.EmptyObjectKind
-	}
-	return last.GetObjectKind()
-}
-
-// First returns the leftmost object in the VersionedObjects array, which is usually the
-// object as serialized on the wire.
-func (obj *VersionedObjects) First() Object {
-	if len(obj.Objects) == 0 {
-		return nil
-	}
-	return obj.Objects[0]
-}
-
-// Last is the rightmost object in the VersionedObjects array, which is the object after
-// all transformations have been applied. This is the same object that would be returned
-// by Decode in a normal invocation (without VersionedObjects in the into argument).
-func (obj *VersionedObjects) Last() Object {
-	if len(obj.Objects) == 0 {
-		return nil
-	}
-	return obj.Objects[len(obj.Objects)-1]
-}

staging/src/k8s.io/apimachinery/pkg/runtime/serializer/json/json.go

@@ -226,16 +226,6 @@ func gvkWithDefaults(actual, defaultGVK schema.GroupVersionKind) schema.GroupVer
 // On success or most errors, the method will return the calculated schema kind.
 // The gvk calculate priority will be originalData > default gvk > into
 func (s *Serializer) Decode(originalData []byte, gvk *schema.GroupVersionKind, into runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
-	if versioned, ok := into.(*runtime.VersionedObjects); ok {
-		into = versioned.Last()
-		obj, actual, err := s.Decode(originalData, gvk, into)
-		if err != nil {
-			return nil, actual, err
-		}
-		versioned.Objects = []runtime.Object{obj}
-		return versioned, actual, nil
-	}
-
 	data := originalData
 	if s.options.Yaml {
 		altered, err := yaml.YAMLToJSON(data)

staging/src/k8s.io/apimachinery/pkg/runtime/serializer/json/json_test.go

@@ -226,39 +226,6 @@ func TestDecode(t *testing.T) {
 				Value: 1,
 			},
 		},
-
-		// runtime.VersionedObjects are decoded
-		{
-			data:        []byte(`{"value":1,"Other":"test"}`),
-			into:        &runtime.VersionedObjects{Objects: []runtime.Object{}},
-			creater:     &mockCreater{obj: &testDecodable{}},
-			typer:       &mockTyper{gvk: &schema.GroupVersionKind{Kind: "Test", Group: "other", Version: "blah"}},
-			defaultGVK:  &schema.GroupVersionKind{Kind: "Test", Group: "other", Version: "blah"},
-			expectedGVK: &schema.GroupVersionKind{Kind: "Test", Group: "other", Version: "blah"},
-			expectedObject: &runtime.VersionedObjects{
-				Objects: []runtime.Object{
-					&testDecodable{
-						Other: "test",
-						Value: 1,
-					},
-				},
-			},
-		},
-		// runtime.VersionedObjects with an object are decoded into
-		{
-			data:        []byte(`{"Other":"test"}`),
-			into:        &runtime.VersionedObjects{Objects: []runtime.Object{&testDecodable{Value: 2}}},
-			typer:       &mockTyper{gvk: &schema.GroupVersionKind{Kind: "Test", Group: "other", Version: "blah"}},
-			expectedGVK: &schema.GroupVersionKind{Kind: "Test", Group: "other", Version: "blah"},
-			expectedObject: &runtime.VersionedObjects{
-				Objects: []runtime.Object{
-					&testDecodable{
-						Other: "test",
-						Value: 2,
-					},
-				},
-			},
-		},
 		// Error on invalid number
 		{
 			data:        []byte(`{"kind":"Test","apiVersion":"other/blah","interface":1e1000}`),

staging/src/k8s.io/apimachinery/pkg/runtime/serializer/protobuf/protobuf.go

@@ -95,23 +95,6 @@ const serializerIdentifier runtime.Identifier = "protobuf"
 // not fully qualified with kind/version/group, the type of the into will be used to alter the returned gvk. On success or most
 // errors, the method will return the calculated schema kind.
 func (s *Serializer) Decode(originalData []byte, gvk *schema.GroupVersionKind, into runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
-	if versioned, ok := into.(*runtime.VersionedObjects); ok {
-		into = versioned.Last()
-		obj, actual, err := s.Decode(originalData, gvk, into)
-		if err != nil {
-			return nil, actual, err
-		}
-		// the last item in versioned becomes into, so if versioned was not originally empty we reset the object
-		// array so the first position is the decoded object and the second position is the outermost object.
-		// if there were no objects in the versioned list passed to us, only add ourselves.
-		if into != nil && into != obj {
-			versioned.Objects = []runtime.Object{obj, into}
-		} else {
-			versioned.Objects = []runtime.Object{obj}
-		}
-		return versioned, actual, err
-	}
-
 	prefixLen := len(s.prefix)
 	switch {
 	case len(originalData) == 0:
@@ -348,20 +331,6 @@ func (s *RawSerializer) Decode(originalData []byte, gvk *schema.GroupVersionKind
 		return nil, nil, fmt.Errorf("this serializer requires an object to decode into: %#v", s)
 	}
 
-	if versioned, ok := into.(*runtime.VersionedObjects); ok {
-		into = versioned.Last()
-		obj, actual, err := s.Decode(originalData, gvk, into)
-		if err != nil {
-			return nil, actual, err
-		}
-		if into != nil && into != obj {
-			versioned.Objects = []runtime.Object{obj, into}
-		} else {
-			versioned.Objects = []runtime.Object{obj}
-		}
-		return versioned, actual, err
-	}
-
 	if len(originalData) == 0 {
 		// TODO: treat like decoding {} from JSON with defaulting
 		return nil, nil, fmt.Errorf("empty data")

staging/src/k8s.io/apimachinery/pkg/runtime/serializer/versioning/versioning.go

@@ -110,11 +110,6 @@ func identifier(encodeGV runtime.GroupVersioner, encoder runtime.Encoder) runtim
 // successful, the returned runtime.Object will be the value passed as into. Note that this may bypass conversion if you pass an
 // into that matches the serialized version.
 func (c *codec) Decode(data []byte, defaultGVK *schema.GroupVersionKind, into runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
-	versioned, isVersioned := into.(*runtime.VersionedObjects)
-	if isVersioned {
-		into = versioned.Last()
-	}
-
 	// If the into object is unstructured and expresses an opinion about its group/version,
 	// create a new instance of the type so we always exercise the conversion path (skips short-circuiting on `into == obj`)
 	decodeInto := into
@@ -139,22 +134,11 @@ func (c *codec) Decode(data []byte, defaultGVK *schema.GroupVersionKind, into ru
 	if into != nil {
 		// perform defaulting if requested
 		if c.defaulter != nil {
-			// create a copy to ensure defaulting is not applied to the original versioned objects
-			if isVersioned {
-				versioned.Objects = []runtime.Object{obj.DeepCopyObject()}
-			}
 			c.defaulter.Default(obj)
-		} else {
-			if isVersioned {
-				versioned.Objects = []runtime.Object{obj}
-			}
 		}
 
 		// Short-circuit conversion if the into object is same object
 		if into == obj {
-			if isVersioned {
-				return versioned, gvk, nil
-			}
 			return into, gvk, nil
 		}
 
@@ -162,19 +146,9 @@ func (c *codec) Decode(data []byte, defaultGVK *schema.GroupVersionKind, into ru
 			return nil, gvk, err
 		}
 
-		if isVersioned {
-			versioned.Objects = append(versioned.Objects, into)
-			return versioned, gvk, nil
-		}
 		return into, gvk, nil
 	}
 
-	// Convert if needed.
-	if isVersioned {
-		// create a copy, because ConvertToVersion does not guarantee non-mutation of objects
-		versioned.Objects = []runtime.Object{obj.DeepCopyObject()}
-	}
-
 	// perform defaulting if requested
 	if c.defaulter != nil {
 		c.defaulter.Default(obj)
@@ -184,12 +158,6 @@ func (c *codec) Decode(data []byte, defaultGVK *schema.GroupVersionKind, into ru
 	if err != nil {
 		return nil, gvk, err
 	}
-	if isVersioned {
-		if versioned.Last() != out {
-			versioned.Objects = append(versioned.Objects, out)
-		}
-		return versioned, gvk, nil
-	}
 	return out, gvk, nil
 }
 

staging/src/k8s.io/apimachinery/pkg/runtime/serializer/versioning/versioning_test.go

@@ -130,7 +130,6 @@ func TestDecode(t *testing.T) {
 	decodable1 := &testDecodable{}
 	decodable2 := &testDecodable{}
 	decodable3 := &testDecodable{}
-	versionedDecodable1 := &runtime.VersionedObjects{Objects: []runtime.Object{decodable1}}
 
 	testCases := []struct {
 		serializer runtime.Serializer
@@ -181,39 +180,6 @@ func TestDecode(t *testing.T) {
 			expectedGVK: gvk1,
 			sameObject:  decodable3,
 		},
-		{
-			into:        versionedDecodable1,
-			serializer:  &mockSerializer{actual: gvk1, obj: decodable3},
-			convertor:   &checkConvertor{in: decodable3, obj: decodable1, directConvert: true},
-			expectedGVK: gvk1,
-			sameObject:  versionedDecodable1,
-		},
-		// returns directly when serializer returns into
-		{
-			into:        decodable3,
-			serializer:  &mockSerializer{actual: gvk1, obj: decodable3},
-			expectedGVK: gvk1,
-			sameObject:  decodable3,
-		},
-		// returns directly when serializer returns into
-		{
-			into:        versionedDecodable1,
-			serializer:  &mockSerializer{actual: gvk1, obj: decodable1},
-			expectedGVK: gvk1,
-			sameObject:  versionedDecodable1,
-		},
-
-		// runtime.VersionedObjects are decoded
-		{
-			into: &runtime.VersionedObjects{Objects: []runtime.Object{}},
-
-			serializer:     &mockSerializer{actual: gvk1, obj: decodable1},
-			convertor:      &checkConvertor{in: decodable1, obj: decodable2, groupVersion: schema.GroupVersion{Group: "other", Version: runtime.APIVersionInternal}},
-			expectedGVK:    gvk1,
-			expectedObject: &runtime.VersionedObjects{Objects: []runtime.Object{decodable1, decodable2}},
-			decodes:        schema.GroupVersion{Group: "other", Version: runtime.APIVersionInternal},
-		},
-
 		// decode into the same version as the serialized object
 		{
 			decodes: schema.GroupVersions{gvk1.GroupVersion()},
@@ -223,34 +189,6 @@ func TestDecode(t *testing.T) {
 			expectedGVK:    gvk1,
 			expectedObject: decodable1,
 		},
-		{
-			into:    &runtime.VersionedObjects{Objects: []runtime.Object{}},
-			decodes: schema.GroupVersions{gvk1.GroupVersion()},
-
-			serializer:     &mockSerializer{actual: gvk1, obj: decodable1},
-			convertor:      &checkConvertor{in: decodable1, obj: decodable1, groupVersion: schema.GroupVersions{{Group: "other", Version: "blah"}}},
-			expectedGVK:    gvk1,
-			expectedObject: &runtime.VersionedObjects{Objects: []runtime.Object{decodable1}},
-		},
-
-		// codec with non matching version skips conversion altogether
-		{
-			decodes: schema.GroupVersions{{Group: "something", Version: "else"}},
-
-			serializer:     &mockSerializer{actual: gvk1, obj: decodable1},
-			convertor:      &checkConvertor{in: decodable1, obj: decodable1, groupVersion: schema.GroupVersions{{Group: "something", Version: "else"}}},
-			expectedGVK:    gvk1,
-			expectedObject: decodable1,
-		},
-		{
-			into:    &runtime.VersionedObjects{Objects: []runtime.Object{}},
-			decodes: schema.GroupVersions{{Group: "something", Version: "else"}},
-
-			serializer:     &mockSerializer{actual: gvk1, obj: decodable1},
-			convertor:      &checkConvertor{in: decodable1, obj: decodable1, groupVersion: schema.GroupVersions{{Group: "something", Version: "else"}}},
-			expectedGVK:    gvk1,
-			expectedObject: &runtime.VersionedObjects{Objects: []runtime.Object{decodable1}},
-		},
 	}
 
 	for i, test := range testCases {

staging/src/k8s.io/apimachinery/pkg/runtime/types.go

@@ -124,16 +124,3 @@ type Unknown struct {
 	// Unspecified means ContentTypeJSON.
 	ContentType string `protobuf:"bytes,4,opt,name=contentType"`
 }
-
-// VersionedObjects is used by Decoders to give callers a way to access all versions
-// of an object during the decoding process.
-//
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-// +k8s:deepcopy-gen=true
-type VersionedObjects struct {
-	// Objects is the set of objects retrieved during decoding, in order of conversion.
-	// The 0 index is the object as serialized on the wire. If conversion has occurred,
-	// other objects may be present. The right most object is the same as would be returned
-	// by a normal Decode call.
-	Objects []Object
-}

staging/src/k8s.io/apimachinery/pkg/runtime/zz_generated.deepcopy.go

@@ -73,36 +73,3 @@ func (in *Unknown) DeepCopyObject() Object {
 	}
 	return nil
 }
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *VersionedObjects) DeepCopyInto(out *VersionedObjects) {
-	*out = *in
-	if in.Objects != nil {
-		in, out := &in.Objects, &out.Objects
-		*out = make([]Object, len(*in))
-		for i := range *in {
-			if (*in)[i] != nil {
-				(*out)[i] = (*in)[i].DeepCopyObject()
-			}
-		}
-	}
-	return
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VersionedObjects.
-func (in *VersionedObjects) DeepCopy() *VersionedObjects {
-	if in == nil {
-		return nil
-	}
-	out := new(VersionedObjects)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new Object.
-func (in *VersionedObjects) DeepCopyObject() Object {
-	if c := in.DeepCopy(); c != nil {
-		return c
-	}
-	return nil
-}