Introduce GroupVersioner for capturing desired target version

Convert single GV and lists of GVs into an interface that can handle
more complex scenarios (everything internal, nothing supported). Pass
the interface down into conversion.

pkg/runtime/serializer/codec_factory.go

@@ -188,13 +188,17 @@ func (f CodecFactory) SupportedStreamingMediaTypes() []string {
 	return f.streamingAccepts
 }
 
-// LegacyCodec encodes output to a given API version, and decodes output into the internal form from
-// any recognized source. The returned codec will always encode output to JSON.
+// LegacyCodec encodes output to a given API versions, and decodes output into the internal form from
+// any recognized source. The returned codec will always encode output to JSON. If a type is not
+// found in the list of versions an error will be returned.
 //
 // This method is deprecated - clients and servers should negotiate a serializer by mime-type and
 // invoke CodecForVersions. Callers that need only to read data should use UniversalDecoder().
+//
+// TODO: make this call exist only in pkg/api, and initialize it with the set of default versions.
+//   All other callers will be forced to request a Codec directly.
 func (f CodecFactory) LegacyCodec(version ...unversioned.GroupVersion) runtime.Codec {
-	return versioning.NewCodecForScheme(f.scheme, f.legacySerializer, f.universal, version, nil)
+	return versioning.NewCodecForScheme(f.scheme, f.legacySerializer, f.universal, unversioned.GroupVersions(version), runtime.InternalGroupVersioner)
 }
 
 // UniversalDeserializer can convert any stored data recognized by this factory into a Go object that satisfies
@@ -211,25 +215,39 @@ func (f CodecFactory) UniversalDeserializer() runtime.Decoder {
 // defaulting.
 //
 // TODO: the decoder will eventually be removed in favor of dealing with objects in their versioned form
+// TODO: only accept a group versioner
 func (f CodecFactory) UniversalDecoder(versions ...unversioned.GroupVersion) runtime.Decoder {
-	return f.CodecForVersions(nil, f.universal, nil, versions)
+	var versioner runtime.GroupVersioner
+	if len(versions) == 0 {
+		versioner = runtime.InternalGroupVersioner
+	} else {
+		versioner = unversioned.GroupVersions(versions)
+	}
+	return f.CodecForVersions(nil, f.universal, nil, versioner)
 }
 
 // CodecForVersions creates a codec with the provided serializer. If an object is decoded and its group is not in the list,
 // it will default to runtime.APIVersionInternal. If encode is not specified for an object's group, the object is not
 // converted. If encode or decode are nil, no conversion is performed.
-func (f CodecFactory) CodecForVersions(encoder runtime.Encoder, decoder runtime.Decoder, encode []unversioned.GroupVersion, decode []unversioned.GroupVersion) runtime.Codec {
+func (f CodecFactory) CodecForVersions(encoder runtime.Encoder, decoder runtime.Decoder, encode runtime.GroupVersioner, decode runtime.GroupVersioner) runtime.Codec {
+	// TODO: these are for backcompat, remove them in the future
+	if encode == nil {
+		encode = runtime.DisabledGroupVersioner
+	}
+	if decode == nil {
+		decode = runtime.InternalGroupVersioner
+	}
 	return versioning.NewCodecForScheme(f.scheme, encoder, decoder, encode, decode)
 }
 
 // DecoderToVersion returns a decoder that targets the provided group version.
-func (f CodecFactory) DecoderToVersion(decoder runtime.Decoder, gv unversioned.GroupVersion) runtime.Decoder {
-	return f.CodecForVersions(nil, decoder, nil, []unversioned.GroupVersion{gv})
+func (f CodecFactory) DecoderToVersion(decoder runtime.Decoder, gv runtime.GroupVersioner) runtime.Decoder {
+	return f.CodecForVersions(nil, decoder, nil, gv)
 }
 
 // EncoderForVersion returns an encoder that targets the provided group version.
-func (f CodecFactory) EncoderForVersion(encoder runtime.Encoder, gv unversioned.GroupVersion) runtime.Encoder {
-	return f.CodecForVersions(encoder, nil, []unversioned.GroupVersion{gv}, nil)
+func (f CodecFactory) EncoderForVersion(encoder runtime.Encoder, gv runtime.GroupVersioner) runtime.Encoder {
+	return f.CodecForVersions(encoder, nil, gv, nil)
 }
 
 // SerializerForMediaType returns a serializer that matches the provided RFC2046 mediaType, or false if no such
@@ -317,7 +335,7 @@ type DirectCodecFactory struct {
 }
 
 // EncoderForVersion returns an encoder that does not do conversion. gv is ignored.
-func (f DirectCodecFactory) EncoderForVersion(serializer runtime.Encoder, gv unversioned.GroupVersion) runtime.Encoder {
+func (f DirectCodecFactory) EncoderForVersion(serializer runtime.Encoder, _ runtime.GroupVersioner) runtime.Encoder {
 	return DirectCodec{
 		runtime.NewCodec(serializer, nil),
 		f.CodecFactory.scheme,
@@ -325,7 +343,7 @@ func (f DirectCodecFactory) EncoderForVersion(serializer runtime.Encoder, gv unv
 }
 
 // DecoderToVersion returns an decoder that does not do conversion. gv is ignored.
-func (f DirectCodecFactory) DecoderToVersion(serializer runtime.Decoder, gv unversioned.GroupVersion) runtime.Decoder {
+func (f DirectCodecFactory) DecoderToVersion(serializer runtime.Decoder, _ runtime.GroupVersioner) runtime.Decoder {
 	return DirectCodec{
 		runtime.NewCodec(nil, serializer),
 		nil,

pkg/runtime/serializer/codec_test.go

@@ -254,7 +254,7 @@ func TestVersionedEncoding(t *testing.T) {
 	cf := newCodecFactory(s, newSerializersForScheme(s, testMetaFactory{}))
 	encoder, _ := cf.SerializerForFileExtension("json")
 
-	codec := cf.CodecForVersions(encoder, nil, []unversioned.GroupVersion{{Version: "v2"}}, nil)
+	codec := cf.CodecForVersions(encoder, nil, unversioned.GroupVersion{Version: "v2"}, nil)
 	out, err := runtime.Encode(codec, &TestType1{})
 	if err != nil {
 		t.Fatal(err)
@@ -263,19 +263,19 @@ func TestVersionedEncoding(t *testing.T) {
 		t.Fatal(string(out))
 	}
 
-	codec = cf.CodecForVersions(encoder, nil, []unversioned.GroupVersion{{Version: "v3"}}, nil)
+	codec = cf.CodecForVersions(encoder, nil, unversioned.GroupVersion{Version: "v3"}, nil)
 	_, err = runtime.Encode(codec, &TestType1{})
 	if err == nil {
 		t.Fatal(err)
 	}
 
 	// unversioned encode with no versions is written directly to wire
-	codec = cf.CodecForVersions(encoder, nil, nil, nil)
+	codec = cf.CodecForVersions(encoder, nil, runtime.InternalGroupVersioner, nil)
 	out, err = runtime.Encode(codec, &TestType1{})
 	if err != nil {
 		t.Fatal(err)
 	}
-	if string(out) != `{"myVersionKey":"__internal","myKindKey":"TestType1"}`+"\n" {
+	if string(out) != `{}`+"\n" {
 		t.Fatal(string(out))
 	}
 }

pkg/runtime/serializer/negotiated_codec.go

@@ -17,7 +17,6 @@ limitations under the License.
 package serializer
 
 import (
-	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
 )
 
@@ -48,10 +47,10 @@ func (n *negotiatedSerializerWrapper) StreamingSerializerForMediaType(mediaType
 	return n.streamInfo, true
 }
 
-func (n *negotiatedSerializerWrapper) EncoderForVersion(e runtime.Encoder, _ unversioned.GroupVersion) runtime.Encoder {
+func (n *negotiatedSerializerWrapper) EncoderForVersion(e runtime.Encoder, _ runtime.GroupVersioner) runtime.Encoder {
 	return e
 }
 
-func (n *negotiatedSerializerWrapper) DecoderToVersion(d runtime.Decoder, _gv unversioned.GroupVersion) runtime.Decoder {
+func (n *negotiatedSerializerWrapper) DecoderToVersion(d runtime.Decoder, _gv runtime.GroupVersioner) runtime.Decoder {
 	return d
 }

pkg/runtime/serializer/versioning/versioning.go

@@ -17,59 +17,20 @@ limitations under the License.
 package versioning
 
 import (
-	"fmt"
 	"io"
 
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
 )
 
-// EnableCrossGroupDecoding modifies the given decoder in place, if it is a codec
-// from this package. It allows objects from one group to be auto-decoded into
-// another group. 'destGroup' must already exist in the codec.
-// TODO: this is an encapsulation violation and should be refactored
-func EnableCrossGroupDecoding(d runtime.Decoder, sourceGroup, destGroup string) error {
-	internal, ok := d.(*codec)
-	if !ok {
-		return fmt.Errorf("unsupported decoder type")
-	}
-
-	dest, ok := internal.decodeVersion[destGroup]
-	if !ok {
-		return fmt.Errorf("group %q is not a possible destination group in the given codec", destGroup)
-	}
-	internal.decodeVersion[sourceGroup] = dest
-
-	return nil
-}
-
-// EnableCrossGroupEncoding modifies the given encoder in place, if it is a codec
-// from this package. It allows objects from one group to be auto-decoded into
-// another group. 'destGroup' must already exist in the codec.
-// TODO: this is an encapsulation violation and should be refactored
-func EnableCrossGroupEncoding(e runtime.Encoder, sourceGroup, destGroup string) error {
-	internal, ok := e.(*codec)
-	if !ok {
-		return fmt.Errorf("unsupported encoder type")
-	}
-
-	dest, ok := internal.encodeVersion[destGroup]
-	if !ok {
-		return fmt.Errorf("group %q is not a possible destination group in the given codec", destGroup)
-	}
-	internal.encodeVersion[sourceGroup] = dest
-
-	return nil
-}
-
 // NewCodecForScheme is a convenience method for callers that are using a scheme.
 func NewCodecForScheme(
 	// TODO: I should be a scheme interface?
 	scheme *runtime.Scheme,
 	encoder runtime.Encoder,
 	decoder runtime.Decoder,
-	encodeVersion []unversioned.GroupVersion,
-	decodeVersion []unversioned.GroupVersion,
+	encodeVersion runtime.GroupVersioner,
+	decodeVersion runtime.GroupVersioner,
 ) runtime.Codec {
 	return NewCodec(encoder, decoder, runtime.UnsafeObjectConvertor(scheme), scheme, scheme, scheme, encodeVersion, decodeVersion)
 }
@@ -84,8 +45,8 @@ func NewCodec(
 	creater runtime.ObjectCreater,
 	copier runtime.ObjectCopier,
 	typer runtime.ObjectTyper,
-	encodeVersion []unversioned.GroupVersion,
-	decodeVersion []unversioned.GroupVersion,
+	encodeVersion runtime.GroupVersioner,
+	decodeVersion runtime.GroupVersioner,
 ) runtime.Codec {
 	internal := &codec{
 		encoder:   encoder,
@@ -94,33 +55,10 @@ func NewCodec(
 		creater:   creater,
 		copier:    copier,
 		typer:     typer,
-	}
-	if encodeVersion != nil {
-		internal.encodeVersion = make(map[string]unversioned.GroupVersion)
-		for _, v := range encodeVersion {
-			// first one for a group wins.  This is consistent with best to worst order throughout the codebase
-			if _, ok := internal.encodeVersion[v.Group]; ok {
-				continue
-			}
-			internal.encodeVersion[v.Group] = v
-		}
-		if len(internal.encodeVersion) == 1 {
-			for _, v := range internal.encodeVersion {
-				internal.preferredEncodeVersion = []unversioned.GroupVersion{v}
-			}
-		}
-	}
-	if decodeVersion != nil {
-		internal.decodeVersion = make(map[string]unversioned.GroupVersion)
-		for _, v := range decodeVersion {
-			// first one for a group wins.  This is consistent with best to worst order throughout the codebase
-			if _, ok := internal.decodeVersion[v.Group]; ok {
-				continue
-			}
-			internal.decodeVersion[v.Group] = v
-		}
-	}
 
+		encodeVersion: encodeVersion,
+		decodeVersion: decodeVersion,
+	}
 	return internal
 }
 
@@ -132,10 +70,8 @@ type codec struct {
 	copier    runtime.ObjectCopier
 	typer     runtime.ObjectTyper
 
-	encodeVersion map[string]unversioned.GroupVersion
-	decodeVersion map[string]unversioned.GroupVersion
-
-	preferredEncodeVersion []unversioned.GroupVersion
+	encodeVersion runtime.GroupVersioner
+	decodeVersion runtime.GroupVersioner
 }
 
 // Decode attempts a decode of the object, then tries to convert it to the internal version. If into is provided and the decoding is
@@ -170,37 +106,7 @@ func (c *codec) Decode(data []byte, defaultGVK *unversioned.GroupVersionKind, in
 		return into, gvk, nil
 	}
 
-	// invoke a version conversion
-	group := gvk.Group
-	if defaultGVK != nil {
-		group = defaultGVK.Group
-	}
-	var targetGV unversioned.GroupVersion
-	if c.decodeVersion == nil {
-		// convert to internal by default
-		targetGV.Group = group
-		targetGV.Version = runtime.APIVersionInternal
-	} else {
-		gv, ok := c.decodeVersion[group]
-		if !ok {
-			// unknown objects are left in their original version
-			if isVersioned {
-				versioned.Objects = []runtime.Object{obj}
-				return versioned, gvk, nil
-			}
-			return obj, gvk, nil
-		}
-		targetGV = gv
-	}
-
-	if gvk.GroupVersion() == targetGV {
-		if isVersioned {
-			versioned.Objects = []runtime.Object{obj}
-			return versioned, gvk, nil
-		}
-		return obj, gvk, nil
-	}
-
+	// Convert if needed.
 	if isVersioned {
 		// create a copy, because ConvertToVersion does not guarantee non-mutation of objects
 		copied, err := c.copier.Copy(obj)
@@ -209,14 +115,14 @@ func (c *codec) Decode(data []byte, defaultGVK *unversioned.GroupVersionKind, in
 		}
 		versioned.Objects = []runtime.Object{copied}
 	}
-
-	// Convert if needed.
-	out, err := c.convertor.ConvertToVersion(obj, targetGV)
+	out, err := c.convertor.ConvertToVersion(obj, c.decodeVersion)
 	if err != nil {
 		return nil, gvk, err
 	}
 	if isVersioned {
-		versioned.Objects = append(versioned.Objects, out)
+		if versioned.Last() != out {
+			versioned.Objects = append(versioned.Objects, out)
+		}
 		return versioned, gvk, nil
 	}
 	return out, gvk, nil
@@ -225,50 +131,47 @@ func (c *codec) Decode(data []byte, defaultGVK *unversioned.GroupVersionKind, in
 // Encode ensures the provided object is output in the appropriate group and version, invoking
 // conversion if necessary. Unversioned objects (according to the ObjectTyper) are output as is.
 func (c *codec) Encode(obj runtime.Object, w io.Writer) error {
-	if _, ok := obj.(*runtime.Unknown); ok {
+	switch t := obj.(type) {
+	case *runtime.Unknown:
+		if gv, ok := runtime.PreferredGroupVersion(c.encodeVersion); ok {
+			t.APIVersion = gv.String()
+		}
+		return c.encoder.Encode(obj, w)
+	case *runtime.Unstructured:
+		if gv, ok := runtime.PreferredGroupVersion(c.encodeVersion); ok {
+			t.SetAPIVersion(gv.String())
+		}
+		return c.encoder.Encode(obj, w)
+	case *runtime.UnstructuredList:
+		if gv, ok := runtime.PreferredGroupVersion(c.encodeVersion); ok {
+			t.SetAPIVersion(gv.String())
+		}
 		return c.encoder.Encode(obj, w)
 	}
+
 	gvks, isUnversioned, err := c.typer.ObjectKinds(obj)
 	if err != nil {
 		return err
 	}
-	gvk := gvks[0]
 
 	if c.encodeVersion == nil || isUnversioned {
 		objectKind := obj.GetObjectKind()
 		old := objectKind.GroupVersionKind()
-		objectKind.SetGroupVersionKind(gvk)
+		objectKind.SetGroupVersionKind(gvks[0])
 		err = c.encoder.Encode(obj, w)
 		objectKind.SetGroupVersionKind(old)
 		return err
 	}
 
-	targetGV, ok := c.encodeVersion[gvk.Group]
-
-	// attempt a conversion to the sole encode version
-	if !ok && c.preferredEncodeVersion != nil {
-		ok = true
-		targetGV = c.preferredEncodeVersion[0]
-	}
-
-	// if no fallback is available, error
-	if !ok {
-		return fmt.Errorf("the codec does not recognize group %q for kind %q and cannot encode it", gvk.Group, gvk.Kind)
-	}
-
 	// Perform a conversion if necessary
 	objectKind := obj.GetObjectKind()
 	old := objectKind.GroupVersionKind()
-	out, err := c.convertor.ConvertToVersion(obj, targetGV)
+	out, err := c.convertor.ConvertToVersion(obj, c.encodeVersion)
 	if err != nil {
-		if ok {
-			return err
-		}
-	} else {
-		obj = out
+		return err
 	}
 	// Conversion is responsible for setting the proper group, version, and kind onto the outgoing object
-	err = c.encoder.Encode(obj, w)
+	err = c.encoder.Encode(out, w)
 	// restore the old GVK, in case conversion returned the same object
 	objectKind.SetGroupVersionKind(old)
 	return err

pkg/runtime/serializer/versioning/versioning_test.go

@@ -53,7 +53,7 @@ func TestDecode(t *testing.T) {
 		yaml       bool
 		pretty     bool
 
-		encodes, decodes []unversioned.GroupVersion
+		encodes, decodes runtime.GroupVersioner
 
 		defaultGVK *unversioned.GroupVersionKind
 		into       runtime.Object
@@ -67,12 +67,14 @@ func TestDecode(t *testing.T) {
 			serializer:  &mockSerializer{actual: gvk1},
 			convertor:   &checkConvertor{groupVersion: unversioned.GroupVersion{Group: "other", Version: "__internal"}},
 			expectedGVK: gvk1,
+			decodes:     unversioned.GroupVersion{Group: "other", Version: "__internal"},
 		},
 		{
 			serializer:  &mockSerializer{actual: gvk1, obj: decodable1},
 			convertor:   &checkConvertor{in: decodable1, obj: decodable2, groupVersion: unversioned.GroupVersion{Group: "other", Version: "__internal"}},
 			expectedGVK: gvk1,
 			sameObject:  decodable2,
+			decodes:     unversioned.GroupVersion{Group: "other", Version: "__internal"},
 		},
 		// defaultGVK.Group is allowed to force a conversion to the destination group
 		{
@@ -81,6 +83,7 @@ func TestDecode(t *testing.T) {
 			convertor:   &checkConvertor{in: decodable1, obj: decodable2, groupVersion: unversioned.GroupVersion{Group: "force", Version: "__internal"}},
 			expectedGVK: gvk1,
 			sameObject:  decodable2,
+			decodes:     unversioned.GroupVersion{Group: "force", Version: "__internal"},
 		},
 		// uses direct conversion for into when objects differ
 		{
@@ -121,6 +124,7 @@ func TestDecode(t *testing.T) {
 			convertor:      &checkConvertor{in: decodable1, obj: decodable2, groupVersion: unversioned.GroupVersion{Group: "other", Version: "__internal"}},
 			expectedGVK:    gvk1,
 			expectedObject: &runtime.VersionedObjects{Objects: []runtime.Object{decodable1, decodable2}},
+			decodes:        unversioned.GroupVersion{Group: "other", Version: "__internal"},
 		},
 		{
 			into: &runtime.VersionedObjects{Objects: []runtime.Object{}},
@@ -130,38 +134,45 @@ func TestDecode(t *testing.T) {
 			convertor:      &checkConvertor{in: decodable1, obj: decodable2, groupVersion: unversioned.GroupVersion{Group: "other", Version: "__internal"}},
 			expectedGVK:    gvk1,
 			expectedObject: &runtime.VersionedObjects{Objects: []runtime.Object{decodable1, decodable2}},
+			decodes:        unversioned.GroupVersion{Group: "other", Version: "__internal"},
 		},
 
 		// decode into the same version as the serialized object
 		{
-			decodes: []unversioned.GroupVersion{gvk1.GroupVersion()},
+			decodes: unversioned.GroupVersions{gvk1.GroupVersion()},
 
 			serializer:     &mockSerializer{actual: gvk1, obj: decodable1},
+			convertor:      &checkConvertor{in: decodable1, obj: decodable1, groupVersion: unversioned.GroupVersions{{Group: "other", Version: "blah"}}},
 			expectedGVK:    gvk1,
 			expectedObject: decodable1,
 		},
 		{
 			into:    &runtime.VersionedObjects{Objects: []runtime.Object{}},
-			decodes: []unversioned.GroupVersion{gvk1.GroupVersion()},
+			decodes: unversioned.GroupVersions{gvk1.GroupVersion()},
 
 			serializer:     &mockSerializer{actual: gvk1, obj: decodable1},
+			convertor:      &checkConvertor{in: decodable1, obj: decodable1, groupVersion: unversioned.GroupVersions{{Group: "other", Version: "blah"}}},
+			copier:         &checkCopy{in: decodable1, obj: decodable1, err: nil},
 			expectedGVK:    gvk1,
 			expectedObject: &runtime.VersionedObjects{Objects: []runtime.Object{decodable1}},
 		},
 
 		// codec with non matching version skips conversion altogether
 		{
-			decodes: []unversioned.GroupVersion{{Group: "something", Version: "else"}},
+			decodes: unversioned.GroupVersions{{Group: "something", Version: "else"}},
 
 			serializer:     &mockSerializer{actual: gvk1, obj: decodable1},
+			convertor:      &checkConvertor{in: decodable1, obj: decodable1, groupVersion: unversioned.GroupVersions{{Group: "something", Version: "else"}}},
 			expectedGVK:    gvk1,
 			expectedObject: decodable1,
 		},
 		{
 			into:    &runtime.VersionedObjects{Objects: []runtime.Object{}},
-			decodes: []unversioned.GroupVersion{{Group: "something", Version: "else"}},
+			decodes: unversioned.GroupVersions{{Group: "something", Version: "else"}},
 
 			serializer:     &mockSerializer{actual: gvk1, obj: decodable1},
+			convertor:      &checkConvertor{in: decodable1, obj: decodable1, groupVersion: unversioned.GroupVersions{{Group: "something", Version: "else"}}},
+			copier:         &checkCopy{in: decodable1, obj: decodable1, err: nil},
 			expectedGVK:    gvk1,
 			expectedObject: &runtime.VersionedObjects{Objects: []runtime.Object{decodable1}},
 		},
@@ -228,7 +239,7 @@ func (c *checkCopy) Copy(obj runtime.Object) (runtime.Object, error) {
 type checkConvertor struct {
 	err           error
 	in, obj       runtime.Object
-	groupVersion  unversioned.GroupVersion
+	groupVersion  runtime.GroupVersioner
 	directConvert bool
 }
 
@@ -244,15 +255,15 @@ func (c *checkConvertor) Convert(in, out interface{}) error {
 	}
 	return c.err
 }
-func (c *checkConvertor) ConvertToVersion(in runtime.Object, outVersion unversioned.GroupVersion) (out runtime.Object, err error) {
+func (c *checkConvertor) ConvertToVersion(in runtime.Object, outVersion runtime.GroupVersioner) (out runtime.Object, err error) {
 	if c.directConvert {
 		return nil, fmt.Errorf("unexpected call to ConvertToVersion")
 	}
 	if c.in != nil && c.in != in {
 		return nil, fmt.Errorf("unexpected in: %s", in)
 	}
-	if c.groupVersion != outVersion {
-		return nil, fmt.Errorf("unexpected outversion: %s", outVersion)
+	if !reflect.DeepEqual(c.groupVersion, outVersion) {
+		return nil, fmt.Errorf("unexpected outversion: %s (%s)", outVersion, c.groupVersion)
 	}
 	return c.obj, c.err
 }