Simplify Codec and split responsibilities

Break Codec into two general purpose interfaces, Encoder and Decoder,
and move parameter codec responsibilities to ParameterCodec.

Make unversioned types explicit when registering - these types go
through conversion without modification.

Switch to use "__internal" instead of "" to represent the internal
version. Future commits will also add group defaulting (so that "" is
expanded internally into a known group version, and only cleared during
set).

For embedded types like runtime.Object -> runtime.RawExtension, put the
responsibility on the caller of Decode/Encode to handle transformation
into destination serialization. Future commits will expand RawExtension
and Unknown to accept a content encoding as well as bytes.

Make Unknown a bit more powerful and use it to carry unrecognized types.

pkg/runtime/embedded_test.go

@@ -19,20 +19,21 @@ package runtime_test
 import (
 	"encoding/json"
 	"reflect"
+	"strings"
 	"testing"
 
-	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/runtime/serializer"
 	"k8s.io/kubernetes/pkg/util"
 )
 
 type EmbeddedTest struct {
 	runtime.TypeMeta
 	ID          string
-	Object      runtime.EmbeddedObject
-	EmptyObject runtime.EmbeddedObject
+	Object      runtime.Object
+	EmptyObject runtime.Object
 }
 
 type EmbeddedTestExternal struct {
@@ -62,16 +63,17 @@ func (obj *EmbeddedTest) GetObjectKind() unversioned.ObjectKind         { return
 func (obj *EmbeddedTestExternal) GetObjectKind() unversioned.ObjectKind { return &obj.TypeMeta }
 
 func TestDecodeEmptyRawExtensionAsObject(t *testing.T) {
-	internalGV := unversioned.GroupVersion{Group: "test.group", Version: ""}
+	internalGV := unversioned.GroupVersion{Group: "test.group", Version: runtime.APIVersionInternal}
 	externalGV := unversioned.GroupVersion{Group: "test.group", Version: "v1test"}
 	externalGVK := externalGV.WithKind("ObjectTest")
 
 	s := runtime.NewScheme()
-	s.AddInternalGroupVersion(internalGV)
 	s.AddKnownTypes(internalGV, &ObjectTest{})
 	s.AddKnownTypeWithName(externalGVK, &ObjectTestExternal{})
 
-	obj, err := s.Decode([]byte(`{"kind":"` + externalGVK.Kind + `","apiVersion":"` + externalGV.String() + `","items":[{}]}`))
+	codec := serializer.NewCodecFactory(s).LegacyCodec(externalGV)
+
+	obj, gvk, err := codec.Decode([]byte(`{"kind":"`+externalGVK.Kind+`","apiVersion":"`+externalGV.String()+`","items":[{}]}`), nil, nil)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -79,42 +81,51 @@ func TestDecodeEmptyRawExtensionAsObject(t *testing.T) {
 	if unk, ok := test.Items[0].(*runtime.Unknown); !ok || unk.Kind != "" || unk.APIVersion != "" || string(unk.RawJSON) != "{}" {
 		t.Fatalf("unexpected object: %#v", test.Items[0])
 	}
+	if *gvk != externalGVK {
+		t.Fatalf("unexpected kind: %#v", gvk)
+	}
 
-	obj, err = s.Decode([]byte(`{"kind":"` + externalGVK.Kind + `","apiVersion":"` + externalGV.String() + `","items":[{"kind":"Other","apiVersion":"v1"}]}`))
+	obj, gvk, err = codec.Decode([]byte(`{"kind":"`+externalGVK.Kind+`","apiVersion":"`+externalGV.String()+`","items":[{"kind":"Other","apiVersion":"v1"}]}`), nil, nil)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	test = obj.(*ObjectTest)
-	if unk, ok := test.Items[0].(*runtime.Unknown); !ok || unk.Kind != "Other" || unk.APIVersion != "v1" || string(unk.RawJSON) != `{"kind":"Other","apiVersion":"v1"}` {
+	if unk, ok := test.Items[0].(*runtime.Unknown); !ok || unk.Kind != "" || unk.APIVersion != "" || string(unk.RawJSON) != `{"kind":"Other","apiVersion":"v1"}` {
 		t.Fatalf("unexpected object: %#v", test.Items[0])
 	}
+	if *gvk != externalGVK {
+		t.Fatalf("unexpected kind: %#v", gvk)
+	}
 }
 
 func TestArrayOfRuntimeObject(t *testing.T) {
-	internalGV := unversioned.GroupVersion{Group: "test.group", Version: ""}
+	internalGV := unversioned.GroupVersion{Group: "test.group", Version: runtime.APIVersionInternal}
 	externalGV := unversioned.GroupVersion{Group: "test.group", Version: "v1test"}
 
 	s := runtime.NewScheme()
-	s.AddInternalGroupVersion(internalGV)
 	s.AddKnownTypes(internalGV, &EmbeddedTest{})
 	s.AddKnownTypeWithName(externalGV.WithKind("EmbeddedTest"), &EmbeddedTestExternal{})
 	s.AddKnownTypes(internalGV, &ObjectTest{})
 	s.AddKnownTypeWithName(externalGV.WithKind("ObjectTest"), &ObjectTestExternal{})
 
-	internal := &ObjectTest{
-		Items: []runtime.Object{
-			&EmbeddedTest{ID: "foo"},
-			&EmbeddedTest{ID: "bar"},
-			// TODO: until YAML is removed, this JSON must be in ascending key order to ensure consistent roundtrip serialization
-			&runtime.Unknown{RawJSON: []byte(`{"apiVersion":"unknown.group/unknown","foo":"bar","kind":"OtherTest"}`)},
-			&ObjectTest{
-				Items: []runtime.Object{
-					&EmbeddedTest{ID: "baz"},
-				},
-			},
+	codec := serializer.NewCodecFactory(s).LegacyCodec(externalGV)
+
+	innerItems := []runtime.Object{
+		&EmbeddedTest{ID: "baz"},
+	}
+	items := []runtime.Object{
+		&EmbeddedTest{ID: "foo"},
+		&EmbeddedTest{ID: "bar"},
+		// TODO: until YAML is removed, this JSON must be in ascending key order to ensure consistent roundtrip serialization
+		&runtime.Unknown{RawJSON: []byte(`{"apiVersion":"unknown.group/unknown","foo":"bar","kind":"OtherTest"}`)},
+		&ObjectTest{
+			Items: runtime.NewEncodableList(codec, innerItems),
 		},
 	}
-	wire, err := s.EncodeToVersion(internal, externalGV.String())
+	internal := &ObjectTest{
+		Items: runtime.NewEncodableList(codec, items),
+	}
+	wire, err := runtime.Encode(codec, internal)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -126,7 +137,10 @@ func TestArrayOfRuntimeObject(t *testing.T) {
 	}
 	t.Logf("exact wire is: %s", string(obj.Items[0].RawJSON))
 
-	decoded, err := runtime.Decode(s, wire)
+	items[3] = &ObjectTest{Items: innerItems}
+	internal.Items = items
+
+	decoded, err := runtime.Decode(codec, wire)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -134,7 +148,7 @@ func TestArrayOfRuntimeObject(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if errs := runtime.DecodeList(list, s); len(errs) > 0 {
+	if errs := runtime.DecodeList(list, codec); len(errs) > 0 {
 		t.Fatalf("unexpected error: %v", errs)
 	}
 
@@ -142,53 +156,65 @@ func TestArrayOfRuntimeObject(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	if errs := runtime.DecodeList(list2, s); len(errs) > 0 {
+	if errs := runtime.DecodeList(list2, codec); len(errs) > 0 {
 		t.Fatalf("unexpected error: %v", errs)
 	}
 	if err := meta.SetList(list[3], list2); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	internal.Items[2].(*runtime.Unknown).Kind = "OtherTest"
-	internal.Items[2].(*runtime.Unknown).APIVersion = "unknown.group/unknown"
+	// we want DecodeList to set type meta if possible, even on runtime.Unknown objects
+	internal.Items[2].(*runtime.Unknown).TypeMeta = runtime.TypeMeta{Kind: "OtherTest", APIVersion: "unknown.group/unknown"}
 	if e, a := internal.Items, list; !reflect.DeepEqual(e, a) {
-		t.Errorf("mismatched decoded: %s", util.ObjectDiff(e, a))
+		t.Errorf("mismatched decoded: %s", util.ObjectGoPrintSideBySide(e, a))
 	}
 }
 
-func TestEmbeddedObject(t *testing.T) {
-	internalGV := unversioned.GroupVersion{Group: "test.group", Version: ""}
+func TestNestedObject(t *testing.T) {
+	internalGV := unversioned.GroupVersion{Group: "test.group", Version: runtime.APIVersionInternal}
 	externalGV := unversioned.GroupVersion{Group: "test.group", Version: "v1test"}
 	embeddedTestExternalGVK := externalGV.WithKind("EmbeddedTest")
 
 	s := runtime.NewScheme()
-	s.AddInternalGroupVersion(internalGV)
 	s.AddKnownTypes(internalGV, &EmbeddedTest{})
 	s.AddKnownTypeWithName(embeddedTestExternalGVK, &EmbeddedTestExternal{})
 
+	codec := serializer.NewCodecFactory(s).LegacyCodec(externalGV)
+
+	inner := &EmbeddedTest{
+		ID: "inner",
+	}
 	outer := &EmbeddedTest{
-		ID: "outer",
-		Object: runtime.EmbeddedObject{
-			Object: &EmbeddedTest{
-				ID: "inner",
-			},
-		},
+		ID:     "outer",
+		Object: runtime.NewEncodable(codec, inner),
 	}
 
-	wire, err := s.EncodeToVersion(outer, externalGV.String())
+	wire, err := runtime.Encode(codec, outer)
 	if err != nil {
 		t.Fatalf("Unexpected encode error '%v'", err)
 	}
 
 	t.Logf("Wire format is:\n%v\n", string(wire))
 
-	decoded, err := runtime.Decode(s, wire)
+	decoded, err := runtime.Decode(codec, wire)
 	if err != nil {
 		t.Fatalf("Unexpected decode error %v", err)
 	}
 
+	// for later tests
+	outer.Object = inner
+
+	if e, a := outer, decoded; reflect.DeepEqual(e, a) {
+		t.Errorf("Expected unequal %#v %#v", e, a)
+	}
+
+	obj, err := runtime.Decode(codec, decoded.(*EmbeddedTest).Object.(*runtime.Unknown).RawJSON)
+	if err != nil {
+		t.Fatal(err)
+	}
+	decoded.(*EmbeddedTest).Object = obj
 	if e, a := outer, decoded; !reflect.DeepEqual(e, a) {
-		t.Errorf("Expected: %#v but got %#v", e, a)
+		t.Errorf("Expected equal %#v %#v", e, a)
 	}
 
 	// test JSON decoding of the external object, which should preserve
@@ -211,46 +237,45 @@ func TestEmbeddedObject(t *testing.T) {
 	// the external representation
 	var decodedViaJSON EmbeddedTest
 	err = json.Unmarshal(wire, &decodedViaJSON)
-	if err != nil {
+	if err == nil || !strings.Contains(err.Error(), "unmarshal object into Go value of type runtime.Object") {
 		t.Fatalf("Unexpected decode error %v", err)
 	}
-	if a := decodedViaJSON; a.Object.Object != nil || a.EmptyObject.Object != nil {
+	if a := decodedViaJSON; a.Object != nil || a.EmptyObject != nil {
 		t.Errorf("Expected embedded objects to be nil: %#v", a)
 	}
 }
 
-// TestDeepCopyOfEmbeddedObject checks to make sure that EmbeddedObject's can be passed through DeepCopy with fidelity
-func TestDeepCopyOfEmbeddedObject(t *testing.T) {
-	internalGV := unversioned.GroupVersion{Group: "test.group", Version: ""}
+// TestDeepCopyOfRuntimeObject checks to make sure that runtime.Objects's can be passed through DeepCopy with fidelity
+func TestDeepCopyOfRuntimeObject(t *testing.T) {
+	internalGV := unversioned.GroupVersion{Group: "test.group", Version: runtime.APIVersionInternal}
 	externalGV := unversioned.GroupVersion{Group: "test.group", Version: "v1test"}
 	embeddedTestExternalGVK := externalGV.WithKind("EmbeddedTest")
 
 	s := runtime.NewScheme()
-	s.AddInternalGroupVersion(internalGV)
 	s.AddKnownTypes(internalGV, &EmbeddedTest{})
 	s.AddKnownTypeWithName(embeddedTestExternalGVK, &EmbeddedTestExternal{})
 
 	original := &EmbeddedTest{
 		ID: "outer",
-		Object: runtime.EmbeddedObject{
-			Object: &EmbeddedTest{
-				ID: "inner",
-			},
+		Object: &EmbeddedTest{
+			ID: "inner",
 		},
 	}
 
-	originalData, err := s.EncodeToVersion(original, externalGV.String())
+	codec := serializer.NewCodecFactory(s).LegacyCodec(externalGV)
+
+	originalData, err := runtime.Encode(codec, original)
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	t.Logf("originalRole = %v\n", string(originalData))
 
-	copyOfOriginal, err := api.Scheme.DeepCopy(original)
+	copyOfOriginal, err := s.DeepCopy(original)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	copiedData, err := s.EncodeToVersion(copyOfOriginal.(runtime.Object), externalGV.String())
+	copiedData, err := runtime.Encode(codec, copyOfOriginal.(runtime.Object))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}