Make runtime less global for Codec

* Make Codec separate from Scheme
* Move EncodeOrDie off Scheme to take a Codec
* Make Copy work without a Codec
* Create a "latest" package that imports all versions and
  sets global defaults for "most recent encoding"
  * v1beta1 is the current "latest", v1beta2 exists
  * Kill DefaultCodec, replace it with "latest.Codec"
  * This updates the client and etcd to store the latest known version
* EmbeddedObject is per schema and per package now
* Move runtime.DefaultScheme to api.Scheme
* Split out WatchEvent since it's not an API object today, treat it
like a special object in api
* Kill DefaultResourceVersioner, instead place it on "latest" (as the
  package that understands all packages)
* Move objDiff to runtime.ObjectDiff

pkg/runtime/embedded.go

@@ -20,42 +20,80 @@ import (
 	"gopkg.in/v1/yaml"
 )
 
+// EmbeddedObject must have an appropriate encoder and decoder functions, such that on the
+// wire, it's stored as a []byte, but in memory, the contained object is accessable as an
+// Object via the Get() function. Only valid API objects may be stored via EmbeddedObject.
+// The purpose of this is to allow an API object of type known only at runtime to be
+// embedded within other API objects.
+//
+// Define a Codec variable in your package and import the runtime package and
+// then use the commented section below
+
+/*
+// EmbeddedObject implements a Codec specific version of an
+// embedded object.
+type EmbeddedObject struct {
+	runtime.Object
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface.
+func (a *EmbeddedObject) UnmarshalJSON(b []byte) error {
+	obj, err := runtime.CodecUnmarshalJSON(Codec, b)
+	a.Object = obj
+	return err
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (a EmbeddedObject) MarshalJSON() ([]byte, error) {
+	return runtime.CodecMarshalJSON(Codec, a.Object)
+}
+
+// SetYAML implements the yaml.Setter interface.
+func (a *EmbeddedObject) SetYAML(tag string, value interface{}) bool {
+	obj, ok := runtime.CodecSetYAML(Codec, tag, value)
+	a.Object = obj
+	return ok
+}
+
+// GetYAML implements the yaml.Getter interface.
+func (a EmbeddedObject) GetYAML() (tag string, value interface{}) {
+	return runtime.CodecGetYAML(Codec, a.Object)
+}
+*/
+
 // Encode()/Decode() are the canonical way of converting an API object to/from
 // wire format. This file provides utility functions which permit doing so
 // recursively, such that API objects of types known only at run time can be
 // embedded within other API types.
 
 // UnmarshalJSON implements the json.Unmarshaler interface.
-func (a *EmbeddedObject) UnmarshalJSON(b []byte) error {
+func CodecUnmarshalJSON(codec Codec, b []byte) (Object, error) {
 	// Handle JSON's "null": Decode() doesn't expect it.
 	if len(b) == 4 && string(b) == "null" {
-		a.Object = nil
-		return nil
+		return nil, nil
 	}
 
-	obj, err := DefaultCodec.Decode(b)
+	obj, err := codec.Decode(b)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	a.Object = obj
-	return nil
+	return obj, nil
 }
 
 // MarshalJSON implements the json.Marshaler interface.
-func (a EmbeddedObject) MarshalJSON() ([]byte, error) {
-	if a.Object == nil {
+func CodecMarshalJSON(codec Codec, obj Object) ([]byte, error) {
+	if obj == nil {
 		// Encode unset/nil objects as JSON's "null".
 		return []byte("null"), nil
 	}
 
-	return DefaultCodec.Encode(a.Object)
+	return codec.Encode(obj)
 }
 
 // SetYAML implements the yaml.Setter interface.
-func (a *EmbeddedObject) SetYAML(tag string, value interface{}) bool {
+func CodecSetYAML(codec Codec, tag string, value interface{}) (Object, bool) {
 	if value == nil {
-		a.Object = nil
-		return true
+		return nil, true
 	}
 	// Why does the yaml package send value as a map[interface{}]interface{}?
 	// It's especially frustrating because encoding/json does the right thing
@@ -67,22 +105,21 @@ func (a *EmbeddedObject) SetYAML(tag string, value interface{}) bool {
 	if err != nil {
 		panic("yaml can't reverse its own object")
 	}
-	obj, err := DefaultCodec.Decode(b)
+	obj, err := codec.Decode(b)
 	if err != nil {
-		return false
+		return nil, false
 	}
-	a.Object = obj
-	return true
+	return obj, true
 }
 
 // GetYAML implements the yaml.Getter interface.
-func (a EmbeddedObject) GetYAML() (tag string, value interface{}) {
-	if a.Object == nil {
+func CodecGetYAML(codec Codec, obj Object) (tag string, value interface{}) {
+	if obj == nil {
 		value = "null"
 		return
 	}
 	// Encode returns JSON, which is conveniently a subset of YAML.
-	v, err := DefaultCodec.Encode(a.Object)
+	v, err := codec.Encode(obj)
 	if err != nil {
 		panic("impossible to encode API object!")
 	}