add yaml support

api/server.go

@@ -2,7 +2,6 @@ package api
 
 import (
 	"net/http"
-
 	"sync"
 
 	"github.com/rancher/norman/api/access"
@@ -51,8 +50,20 @@ func NewAPIServer() *Server {
 	s := &Server{
 		Schemas: types.NewSchemas(),
 		ResponseWriters: map[string]ResponseWriter{
-			"json": &writer.JSONResponseWriter{},
-			"html": &writer.HTMLResponseWriter{},
+			"json": &writer.EncodingResponseWriter{
+				ContentType: "application/json",
+				Encoder:     types.JSONEncoder,
+			},
+			"html": &writer.HTMLResponseWriter{
+				EncodingResponseWriter: writer.EncodingResponseWriter{
+					Encoder:     types.JSONEncoder,
+					ContentType: "application/json",
+				},
+			},
+			"yaml": &writer.EncodingResponseWriter{
+				ContentType: "application/yaml",
+				Encoder:     types.YAMLEncoder,
+			},
 		},
 		SubContextAttributeProvider: &parse.DefaultSubContextAttributeProvider{},
 		Resolver:                    parse.DefaultResolver,

api/writer/html.go

@@ -25,7 +25,7 @@ var data =
 )
 
 type HTMLResponseWriter struct {
-	JSONResponseWriter
+	EncodingResponseWriter
 }
 
 func (h *HTMLResponseWriter) start(apiContext *types.APIContext, code int, obj interface{}) {

api/writer/json.go

@@ -1,7 +1,6 @@
 package writer
 
 import (
-	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
@@ -13,26 +12,28 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-type JSONResponseWriter struct {
+type EncodingResponseWriter struct {
+	ContentType string
+	Encoder     func(io.Writer, interface{}) error
 }
 
-func (j *JSONResponseWriter) start(apiContext *types.APIContext, code int, obj interface{}) {
+func (j *EncodingResponseWriter) start(apiContext *types.APIContext, code int, obj interface{}) {
 	AddCommonResponseHeader(apiContext)
-	apiContext.Response.Header().Set("content-type", "application/json")
+	apiContext.Response.Header().Set("content-type", j.ContentType)
 	apiContext.Response.WriteHeader(code)
 }
 
-func (j *JSONResponseWriter) Write(apiContext *types.APIContext, code int, obj interface{}) {
+func (j *EncodingResponseWriter) Write(apiContext *types.APIContext, code int, obj interface{}) {
 	j.start(apiContext, code, obj)
 	j.Body(apiContext, apiContext.Response, obj)
 }
 
-func (j *JSONResponseWriter) Body(apiContext *types.APIContext, writer io.Writer, obj interface{}) error {
+func (j *EncodingResponseWriter) Body(apiContext *types.APIContext, writer io.Writer, obj interface{}) error {
 	return j.VersionBody(apiContext, apiContext.Version, writer, obj)
 
 }
 
-func (j *JSONResponseWriter) VersionBody(apiContext *types.APIContext, version *types.APIVersion, writer io.Writer, obj interface{}) error {
+func (j *EncodingResponseWriter) VersionBody(apiContext *types.APIContext, version *types.APIVersion, writer io.Writer, obj interface{}) error {
 	var output interface{}
 
 	builder := builder.NewBuilder(apiContext)
@@ -50,12 +51,12 @@ func (j *JSONResponseWriter) VersionBody(apiContext *types.APIContext, version *
 	}
 
 	if output != nil {
-		return json.NewEncoder(writer).Encode(output)
+		return j.Encoder(writer, output)
 	}
 
 	return nil
 }
-func (j *JSONResponseWriter) writeMapSlice(builder *builder.Builder, apiContext *types.APIContext, input []map[string]interface{}) *types.GenericCollection {
+func (j *EncodingResponseWriter) writeMapSlice(builder *builder.Builder, apiContext *types.APIContext, input []map[string]interface{}) *types.GenericCollection {
 	collection := newCollection(apiContext)
 	for _, value := range input {
 		converted := j.convert(builder, apiContext, value)
@@ -71,7 +72,7 @@ func (j *JSONResponseWriter) writeMapSlice(builder *builder.Builder, apiContext
 	return collection
 }
 
-func (j *JSONResponseWriter) writeInterfaceSlice(builder *builder.Builder, apiContext *types.APIContext, input []interface{}) *types.GenericCollection {
+func (j *EncodingResponseWriter) writeInterfaceSlice(builder *builder.Builder, apiContext *types.APIContext, input []interface{}) *types.GenericCollection {
 	collection := newCollection(apiContext)
 	for _, value := range input {
 		switch v := value.(type) {
@@ -99,7 +100,7 @@ func toString(val interface{}) string {
 	return fmt.Sprint(val)
 }
 
-func (j *JSONResponseWriter) convert(b *builder.Builder, context *types.APIContext, input map[string]interface{}) *types.RawResource {
+func (j *EncodingResponseWriter) convert(b *builder.Builder, context *types.APIContext, input map[string]interface{}) *types.RawResource {
 	schema := context.Schemas.Schema(context.Version, definition.GetFullType(input))
 	if schema == nil {
 		return nil
@@ -133,7 +134,7 @@ func (j *JSONResponseWriter) convert(b *builder.Builder, context *types.APIConte
 	return rawResource
 }
 
-func (j *JSONResponseWriter) addLinks(b *builder.Builder, schema *types.Schema, context *types.APIContext, input map[string]interface{}, rawResource *types.RawResource) {
+func (j *EncodingResponseWriter) addLinks(b *builder.Builder, schema *types.Schema, context *types.APIContext, input map[string]interface{}, rawResource *types.RawResource) {
 	if rawResource.ID == "" {
 		return
 	}

parse/parse.go

@@ -23,6 +23,7 @@ var (
 	allowedFormats   = map[string]bool{
 		"html": true,
 		"json": true,
+		"yaml": true,
 	}
 )
 
@@ -259,9 +260,17 @@ func parseResponseFormat(req *http.Request) string {
 	if IsBrowser(req, true) {
 		return "html"
 	}
+
+	if isYaml(req) {
+		return "yaml"
+	}
 	return "json"
 }
 
+func isYaml(req *http.Request) bool {
+	return strings.Contains(req.Header.Get("Accept"), "application/yaml")
+}
+
 func parseMethod(req *http.Request) string {
 	method := req.URL.Query().Get("_method")
 	if method == "" {

parse/read_input.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 
 	"github.com/rancher/norman/httperror"
+	"k8s.io/apimachinery/pkg/util/yaml"
 )
 
 const reqMaxSize = (2 * 1 << 20) + 1
@@ -16,19 +17,29 @@ var bodyMethods = map[string]bool{
 	http.MethodPost: true,
 }
 
+type Decode func(interface{}) error
+
 func ReadBody(req *http.Request) (map[string]interface{}, error) {
 	if !bodyMethods[req.Method] {
 		return nil, nil
 	}
 
-	dec := json.NewDecoder(io.LimitReader(req.Body, reqMaxSize))
-	dec.UseNumber()
+	decode := getDecoder(req, io.LimitReader(req.Body, maxFormSize))
 
 	data := map[string]interface{}{}
-	if err := dec.Decode(&data); err != nil {
+	if err := decode(&data); err != nil {
 		return nil, httperror.NewAPIError(httperror.InvalidBodyContent,
 			fmt.Sprintf("Failed to parse body: %v", err))
 	}
 
 	return data, nil
 }
+
+func getDecoder(req *http.Request, reader io.Reader) Decode {
+	if req.Header.Get("Content-type") == "application/yaml" {
+		return yaml.NewYAMLToJSONDecoder(reader).Decode
+	}
+	decoder := json.NewDecoder(reader)
+	decoder.UseNumber()
+	return decoder.Decode
+}

pkg/subscribe/handler.go

@@ -85,7 +85,10 @@ func handler(apiContext *types.APIContext) error {
 		close(events)
 	}()
 
-	jsonWriter := writer.JSONResponseWriter{}
+	jsonWriter := writer.EncodingResponseWriter{
+		ContentType: "application/json",
+		Encoder:     types.JSONEncoder,
+	}
 	t := time.NewTicker(5 * time.Second)
 	defer t.Stop()
 

types/encoder.go

@@ -0,0 +1,25 @@
+package types
+
+import (
+	"encoding/json"
+	"io"
+
+	"github.com/ghodss/yaml"
+)
+
+func JSONEncoder(writer io.Writer, v interface{}) error {
+	return json.NewEncoder(writer).Encode(v)
+}
+
+func YAMLEncoder(writer io.Writer, v interface{}) error {
+	data, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+	buf, err := yaml.JSONToYAML(data)
+	if err != nil {
+		return err
+	}
+	_, err = writer.Write(buf)
+	return err
+}