Merge pull request kubernetes#5533 from smarterclayton/burn_yaml_with…

…_fire Burn YAML with fire (kind of)
duda · Mar 23, 2015 · d19aac8 · d19aac8
2 parents 75a25b5 + 6918a4d
commit d19aac8
Show file tree

Hide file tree

Showing 13 changed files with 142 additions and 157 deletions.
diff --git a/examples/examples_test.go b/examples/examples_test.go
@@ -29,6 +29,7 @@ import (
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/latest"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/validation"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util/yaml"
 	"github.com/golang/glog"
 )
 
@@ -88,6 +89,15 @@ func walkJSONFiles(inDir string, fn func(name, path string, data []byte)) error
 				return err
 			}
 			name := strings.TrimSuffix(file, ext)
+
+			if ext == ".yaml" {
+				out, err := yaml.ToJSON(data)
+				if err != nil {
+					return err
+				}
+				data = out
+			}
+
 			fn(name, path, data)
 		}
 		return nil
@@ -215,14 +225,18 @@ func TestReadme(t *testing.T) {
 
 			//t.Logf("testing (%s): \n%s", subtype, content)
 			expectedType := &api.Pod{}
-			if err := latest.Codec.DecodeInto([]byte(content), expectedType); err != nil {
+			json, err := yaml.ToJSON([]byte(content))
+			if err != nil {
+				t.Errorf("%s could not be converted to JSON: %v\n%s", path, err, string(content))
+			}
+			if err := latest.Codec.DecodeInto(json, expectedType); err != nil {
 				t.Errorf("%s did not decode correctly: %v\n%s", path, err, string(content))
 				continue
 			}
 			if errors := validateObject(expectedType); len(errors) > 0 {
 				t.Errorf("%s did not validate correctly: %v", path, errors)
 			}
-			_, err := latest.Codec.Encode(expectedType)
+			_, err = latest.Codec.Encode(expectedType)
 			if err != nil {
 				t.Errorf("Could not encode object: %v", err)
 				continue

diff --git a/examples/limitrange/valid-pod.json b/examples/limitrange/valid-pod.json
@@ -13,8 +13,8 @@
         "name": "kubernetes-serve-hostname",
         "image": "kubernetes/serve_hostname",        
         "cpu": 1000,
-        "memory": 1048576,
+        "memory": 1048576
       }]
     }
-  },
+  }
 }
diff --git a/pkg/api/validation/schema.go b/pkg/api/validation/schema.go
@@ -22,9 +22,9 @@ import (
 	"reflect"
 	"strings"
 
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util/yaml"
 	"github.com/emicklei/go-restful/swagger"
 	"github.com/golang/glog"
-	"gopkg.in/yaml.v2"
 )
 
 type InvalidTypeError struct {
@@ -65,11 +65,15 @@ func NewSwaggerSchemaFromBytes(data []byte) (Schema, error) {
 
 func (s *SwaggerSchema) ValidateBytes(data []byte) error {
 	var obj interface{}
-	err := yaml.Unmarshal(data, &obj)
+	out, err := yaml.ToJSON(data)
 	if err != nil {
 		return err
 	}
-	fields := obj.(map[interface{}]interface{})
+	data = out
+	if err := json.Unmarshal(data, &obj); err != nil {
+		return err
+	}
+	fields := obj.(map[string]interface{})
 	apiVersion := fields["apiVersion"].(string)
 	kind := fields["kind"].(string)
 	return s.ValidateObject(obj, apiVersion, "", apiVersion+"."+kind)
@@ -84,12 +88,12 @@ func (s *SwaggerSchema) ValidateObject(obj interface{}, apiVersion, fieldName, t
 		return nil
 	}
 	properties := model.Properties
-	fields := obj.(map[interface{}]interface{})
+	fields := obj.(map[string]interface{})
 	if len(fieldName) > 0 {
 		fieldName = fieldName + "."
 	}
 	for key, value := range fields {
-		details, ok := properties[key.(string)]
+		details, ok := properties[key]
 		if !ok {
 			glog.V(2).Infof("couldn't find properties for %s, skipping", key)
 			continue
@@ -99,7 +103,7 @@ func (s *SwaggerSchema) ValidateObject(obj interface{}, apiVersion, fieldName, t
 			glog.V(2).Infof("Skipping nil field: %s", key)
 			continue
 		}
-		err := s.validateField(value, apiVersion, fieldName+key.(string), fieldType, &details)
+		err := s.validateField(value, apiVersion, fieldName+key, fieldType, &details)
 		if err != nil {
 			glog.Errorf("Validation failed for: %s, %v", key, value)
 			return err

diff --git a/pkg/client/clientcmd/api/latest/latest.go b/pkg/client/clientcmd/api/latest/latest.go
@@ -18,6 +18,7 @@ package latest
 
 import (
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/client/clientcmd/api/v1"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
 )
 
 // Version is the string that represents the current external default version.
@@ -37,4 +38,4 @@ var Versions = []string{"v1"}
 // the latest supported version.  Use this Codec when writing to
 // disk, a data store that is not dynamically versioned, or in tests.
 // This codec can decode any object that Kubernetes is aware of.
-var Codec = v1.Codec
+var Codec = runtime.YAMLDecoder(v1.Codec)
diff --git a/pkg/conversion/decode.go b/pkg/conversion/decode.go
@@ -17,13 +17,12 @@ limitations under the License.
 package conversion
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
-
-	"github.com/ghodss/yaml"
 )
 
-// Decode converts a YAML or JSON string back into a pointer to an api object.
+// Decode converts a JSON string back into a pointer to an api object.
 // Deduces the type based upon the fields added by the MetaInsertionFactory
 // technique. The object will be converted, if necessary, into the
 // s.InternalVersion type before being returned. Decode will not decode
@@ -44,16 +43,12 @@ func (s *Scheme) Decode(data []byte) (interface{}, error) {
 		return nil, err
 	}
 
-	// yaml is a superset of json, so we use it to decode here. That way,
-	// we understand both.
-	err = yaml.Unmarshal(data, obj)
-	if err != nil {
+	if err := json.Unmarshal(data, obj); err != nil {
 		return nil, err
 	}
 
 	// Version and Kind should be blank in memory.
-	err = s.SetVersionAndKind("", "", obj)
-	if err != nil {
+	if err := s.SetVersionAndKind("", "", obj); err != nil {
 		return nil, err
 	}
 
@@ -63,25 +58,21 @@ func (s *Scheme) Decode(data []byte) (interface{}, error) {
 		if err != nil {
 			return nil, err
 		}
-		err = s.converter.Convert(obj, objOut, 0, s.generateConvertMeta(version, s.InternalVersion))
-		if err != nil {
+		if err := s.converter.Convert(obj, objOut, 0, s.generateConvertMeta(version, s.InternalVersion)); err != nil {
 			return nil, err
 		}
 		obj = objOut
 	}
 	return obj, nil
 }
 
-// DecodeInto parses a YAML or JSON string and stores it in obj. Returns an error
+// DecodeInto parses a JSON string and stores it in obj. Returns an error
 // if data.Kind is set and doesn't match the type of obj. Obj should be a
 // pointer to an api type.
 // If obj's version doesn't match that in data, an attempt will be made to convert
 // data into obj's version.
 func (s *Scheme) DecodeInto(data []byte, obj interface{}) error {
 	if len(data) == 0 {
-		// This is valid YAML, but it's a bad idea not to return an error
-		// for an empty string-- that's almost certainly not what the caller
-		// was expecting.
 		return errors.New("empty input")
 	}
 	dataVersion, dataKind, err := s.DataVersionAndKind(data)
@@ -107,14 +98,10 @@ func (s *Scheme) DecodeInto(data []byte, obj interface{}) error {
 	if err != nil {
 		return err
 	}
-	// yaml is a superset of json, so we use it to decode here. That way,
-	// we understand both.
-	err = yaml.Unmarshal(data, external)
-	if err != nil {
+	if err := json.Unmarshal(data, external); err != nil {
 		return err
 	}
-	err = s.converter.Convert(external, obj, 0, s.generateConvertMeta(dataVersion, objVersion))
-	if err != nil {
+	if err := s.converter.Convert(external, obj, 0, s.generateConvertMeta(dataVersion, objVersion)); err != nil {
 		return err
 	}
 

diff --git a/pkg/conversion/meta.go b/pkg/conversion/meta.go
@@ -17,10 +17,9 @@ limitations under the License.
 package conversion
 
 import (
+	"encoding/json"
 	"fmt"
 	"reflect"
-
-	"github.com/ghodss/yaml"
 )
 
 // MetaFactory is used to store and retrieve the version and kind
@@ -33,13 +32,13 @@ type MetaFactory interface {
 	Interpret(data []byte) (version, kind string, err error)
 }
 
-// DefaultMetaFactory is a default factory for versioning objects in JSON/YAML. The object
+// DefaultMetaFactory is a default factory for versioning objects in JSON. The object
 // in memory and in the default JSON serialization will use the "kind" and "apiVersion"
 // fields.
 var DefaultMetaFactory = SimpleMetaFactory{KindField: "Kind", VersionField: "APIVersion"}
 
 // SimpleMetaFactory provides default methods for retrieving the type and version of objects
-// that are identified with an "apiVersion" and "kind" fields in their JSON/YAML
+// that are identified with an "apiVersion" and "kind" fields in their JSON
 // serialization. It may be parameterized with the names of the fields in memory, or an
 // optional list of base structs to search for those fields in memory.
 type SimpleMetaFactory struct {
@@ -51,16 +50,14 @@ type SimpleMetaFactory struct {
 	BaseFields []string
 }
 
-// Interpret will return the APIVersion and Kind of the JSON/YAML wire-format
+// Interpret will return the APIVersion and Kind of the JSON wire-format
 // encoding of an object, or an error.
 func (SimpleMetaFactory) Interpret(data []byte) (version, kind string, err error) {
 	findKind := struct {
 		APIVersion string `json:"apiVersion,omitempty"`
 		Kind       string `json:"kind,omitempty"`
 	}{}
-	// yaml is a superset of json, so we use it to decode here. That way,
-	// we understand both.
-	err = yaml.Unmarshal(data, &findKind)
+	err = json.Unmarshal(data, &findKind)
 	if err != nil {
 		return "", "", fmt.Errorf("couldn't get version/kind: %v", err)
 	}

diff --git a/pkg/kubectl/cmd/rollingupdate.go b/pkg/kubectl/cmd/rollingupdate.go
@@ -23,6 +23,7 @@ import (
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl/cmd/util"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl/resource"
 	"github.com/spf13/cobra"
 )
 
@@ -72,56 +73,41 @@ func RunRollingUpdate(f *Factory, out io.Writer, cmd *cobra.Command, args []stri
 		return util.UsageError(cmd, "Must specify the controller to update")
 	}
 	oldName := args[0]
-	schema, err := f.Validator()
-	if err != nil {
-		return err
-	}
 
-	clientConfig, err := f.ClientConfig()
+	cmdNamespace, err := f.DefaultNamespace()
 	if err != nil {
 		return err
 	}
-	cmdApiVersion := clientConfig.Version
 
 	mapper, typer := f.Object()
 	// TODO: use resource.Builder instead
-	mapping, namespace, newName, data, err := util.ResourceFromFile(filename, typer, mapper, schema, cmdApiVersion)
+	obj, err := resource.NewBuilder(mapper, typer, f.ClientMapperForCommand(cmd)).
+		NamespaceParam(cmdNamespace).RequireNamespace().
+		FilenameParam(filename).
+		Do().
+		Object()
 	if err != nil {
 		return err
 	}
-	if mapping.Kind != "ReplicationController" {
+	newRc, ok := obj.(*api.ReplicationController)
+	if !ok {
 		return util.UsageError(cmd, "%s does not specify a valid ReplicationController", filename)
 	}
+	newName := newRc.Name
 	if oldName == newName {
 		return util.UsageError(cmd, "%s cannot have the same name as the existing ReplicationController %s",
 			filename, oldName)
 	}
 
-	cmdNamespace, err := f.DefaultNamespace()
-	if err != nil {
-		return err
-	}
-	// TODO: use resource.Builder instead
-	err = util.CompareNamespace(cmdNamespace, namespace)
-	if err != nil {
-		return err
-	}
-
 	client, err := f.Client()
 	if err != nil {
 		return err
 	}
 
-	obj, err := mapping.Codec.Decode(data)
-	if err != nil {
-		return err
-	}
-	newRc := obj.(*api.ReplicationController)
-
-	updater := kubectl.NewRollingUpdater(cmdNamespace, client)
+	updater := kubectl.NewRollingUpdater(newRc.Namespace, client)
 
 	// fetch rc
-	oldRc, err := client.ReplicationControllers(cmdNamespace).Get(oldName)
+	oldRc, err := client.ReplicationControllers(newRc.Namespace).Get(oldName)
 	if err != nil {
 		return err
 	}