Support content-type negotiation in the API server

cmd/kube-apiserver/app/server.go

@@ -34,7 +34,6 @@ import (
 	"k8s.io/kubernetes/cmd/kube-apiserver/app/options"
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	apiutil "k8s.io/kubernetes/pkg/api/util"
 	"k8s.io/kubernetes/pkg/apimachinery/registered"

pkg/apiserver/api_installer.go

@@ -65,7 +65,13 @@ var errEmptyName = errors.NewBadRequest("name must be provided")
 func (a *APIInstaller) Install(ws *restful.WebService) (apiResources []unversioned.APIResource, errors []error) {
 	errors = make([]error, 0)
 
-	proxyHandler := (&ProxyHandler{a.prefix + "/proxy/", a.group.Storage, a.group.Codec, a.group.Context, a.info})
+	proxyHandler := (&ProxyHandler{
+		prefix:              a.prefix + "/proxy/",
+		storage:             a.group.Storage,
+		serializer:          a.group.Serializer,
+		context:             a.group.Context,
+		requestInfoResolver: a.info,
+	})
 
 	// Register the paths in a deterministic (sorted) order to get a deterministic swagger spec.
 	paths := make([]string, len(a.group.Storage))
@@ -93,9 +99,11 @@ func (a *APIInstaller) NewWebService() *restful.WebService {
 	ws.Path(a.prefix)
 	// a.prefix contains "prefix/group/version"
 	ws.Doc("API at " + a.prefix)
-	// TODO: change to restful.MIME_JSON when we set content type in client
+	// Backwards compatibilty, we accepted objects with empty content-type at V1.
+	// If we stop using go-restful, we can default empty content-type to application/json on an
+	// endpoint by endpoint basis
 	ws.Consumes("*/*")
-	ws.Produces(restful.MIME_JSON)
+	ws.Produces(a.group.Serializer.SupportedMediaTypes()...)
 	ws.ApiVersion(a.group.GroupVersion.String())
 
 	return ws
@@ -262,19 +270,14 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag
 		getOptions             runtime.Object
 		versionedGetOptions    runtime.Object
 		getOptionsInternalKind unversioned.GroupVersionKind
-		getOptionsExternalKind unversioned.GroupVersionKind
 		getSubpath             bool
-		getSubpathKey          string
 	)
 	if isGetterWithOptions {
-		getOptions, getSubpath, getSubpathKey = getterWithOptions.NewGetOptions()
+		getOptions, getSubpath, _ = getterWithOptions.NewGetOptions()
 		getOptionsInternalKind, err = a.group.Typer.ObjectKind(getOptions)
 		if err != nil {
 			return nil, err
 		}
-		// TODO this should be a list of all the different external versions we can coerce into the internalKind
-		getOptionsExternalKind = optionsExternalVersion.WithKind(getOptionsInternalKind.Kind)
-
 		versionedGetOptions, err = a.group.Creater.New(optionsExternalVersion.WithKind(getOptionsInternalKind.Kind))
 		if err != nil {
 			return nil, err
@@ -286,19 +289,15 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag
 		connectOptions             runtime.Object
 		versionedConnectOptions    runtime.Object
 		connectOptionsInternalKind unversioned.GroupVersionKind
-		connectOptionsExternalKind unversioned.GroupVersionKind
 		connectSubpath             bool
-		connectSubpathKey          string
 	)
 	if isConnecter {
-		connectOptions, connectSubpath, connectSubpathKey = connecter.NewConnectOptions()
+		connectOptions, connectSubpath, _ = connecter.NewConnectOptions()
 		if connectOptions != nil {
 			connectOptionsInternalKind, err = a.group.Typer.ObjectKind(connectOptions)
 			if err != nil {
 				return nil, err
 			}
-			// TODO this should be a list of all the different external versions we can coerce into the internalKind
-			connectOptionsExternalKind = optionsExternalVersion.WithKind(connectOptionsInternalKind.Kind)
 
 			versionedConnectOptions, err = a.group.Creater.New(optionsExternalVersion.WithKind(connectOptionsInternalKind.Kind))
 		}
@@ -434,10 +433,11 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag
 	// test/integration/auth_test.go is currently the most comprehensive status code test
 
 	reqScope := RequestScope{
-		ContextFunc: ctxFn,
-		Creater:     a.group.Creater,
-		Convertor:   a.group.Convertor,
-		Codec:       mapping.Codec,
+		ContextFunc:    ctxFn,
+		Serializer:     a.group.Serializer,
+		ParameterCodec: a.group.ParameterCodec,
+		Creater:        a.group.Creater,
+		Convertor:      a.group.Convertor,
 
 		Resource:    a.group.GroupVersion.WithResource(resource),
 		Subresource: subresource,
@@ -454,7 +454,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag
 		case "GET": // Get a resource.
 			var handler restful.RouteFunction
 			if isGetterWithOptions {
-				handler = GetResourceWithOptions(getterWithOptions, exporter, reqScope, getOptionsInternalKind, getOptionsExternalKind, getSubpath, getSubpathKey)
+				handler = GetResourceWithOptions(getterWithOptions, reqScope)
 			} else {
 				handler = GetResource(getter, exporter, reqScope)
 			}
@@ -467,7 +467,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag
 				Doc(doc).
 				Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
 				Operation("read"+namespaced+kind+strings.Title(subresource)).
-				Produces(append(storageMeta.ProducesMIMETypes(action.Verb), "application/json")...).
+				Produces(append(storageMeta.ProducesMIMETypes(action.Verb), a.group.Serializer.SupportedMediaTypes()...)...).
 				Returns(http.StatusOK, "OK", versionedObject).
 				Writes(versionedObject)
 			if isGetterWithOptions {
@@ -492,7 +492,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag
 				Doc(doc).
 				Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
 				Operation("list"+namespaced+kind+strings.Title(subresource)).
-				Produces("application/json").
+				Produces(append(storageMeta.ProducesMIMETypes(action.Verb), a.group.Serializer.SupportedMediaTypes()...)...).
 				Returns(http.StatusOK, "OK", versionedList).
 				Writes(versionedList)
 			if err := addObjectParams(ws, route, versionedListOptions); err != nil {
@@ -524,7 +524,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag
 				Doc(doc).
 				Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
 				Operation("replace"+namespaced+kind+strings.Title(subresource)).
-				Produces(append(storageMeta.ProducesMIMETypes(action.Verb), "application/json")...).
+				Produces(append(storageMeta.ProducesMIMETypes(action.Verb), a.group.Serializer.SupportedMediaTypes()...)...).
 				Returns(http.StatusOK, "OK", versionedObject).
 				Reads(versionedObject).
 				Writes(versionedObject)
@@ -541,7 +541,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag
 				Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
 				Consumes(string(api.JSONPatchType), string(api.MergePatchType), string(api.StrategicMergePatchType)).
 				Operation("patch"+namespaced+kind+strings.Title(subresource)).
-				Produces(append(storageMeta.ProducesMIMETypes(action.Verb), "application/json")...).
+				Produces(append(storageMeta.ProducesMIMETypes(action.Verb), a.group.Serializer.SupportedMediaTypes()...)...).
 				Returns(http.StatusOK, "OK", versionedObject).
 				Reads(unversioned.Patch{}).
 				Writes(versionedObject)
@@ -563,7 +563,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag
 				Doc(doc).
 				Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
 				Operation("create"+namespaced+kind+strings.Title(subresource)).
-				Produces(append(storageMeta.ProducesMIMETypes(action.Verb), "application/json")...).
+				Produces(append(storageMeta.ProducesMIMETypes(action.Verb), a.group.Serializer.SupportedMediaTypes()...)...).
 				Returns(http.StatusOK, "OK", versionedObject).
 				Reads(versionedObject).
 				Writes(versionedObject)
@@ -579,7 +579,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag
 				Doc(doc).
 				Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
 				Operation("delete"+namespaced+kind+strings.Title(subresource)).
-				Produces(append(storageMeta.ProducesMIMETypes(action.Verb), "application/json")...).
+				Produces(append(storageMeta.ProducesMIMETypes(action.Verb), a.group.Serializer.SupportedMediaTypes()...)...).
 				Writes(versionedStatus).
 				Returns(http.StatusOK, "OK", versionedStatus)
 			if isGracefulDeleter {
@@ -597,7 +597,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag
 				Doc(doc).
 				Param(ws.QueryParameter("pretty", "If 'true', then the output is pretty printed.")).
 				Operation("deletecollection"+namespaced+kind+strings.Title(subresource)).
-				Produces(append(storageMeta.ProducesMIMETypes(action.Verb), "application/json")...).
+				Produces(append(storageMeta.ProducesMIMETypes(action.Verb), a.group.Serializer.SupportedMediaTypes()...)...).
 				Writes(versionedStatus).
 				Returns(http.StatusOK, "OK", versionedStatus)
 			if err := addObjectParams(ws, route, versionedListOptions); err != nil {
@@ -658,7 +658,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag
 					doc = "connect " + method + " requests to " + subresource + " of " + kind
 				}
 				route := ws.Method(method).Path(action.Path).
-					To(ConnectResource(connecter, reqScope, admit, connectOptionsInternalKind, connectOptionsExternalKind, path, connectSubpath, connectSubpathKey)).
+					To(ConnectResource(connecter, reqScope, admit, path)).
 					Filter(m).
 					Doc(doc).
 					Operation("connect" + strings.Title(strings.ToLower(method)) + namespaced + kind + strings.Title(subresource)).

pkg/apiserver/errors.go

@@ -19,6 +19,7 @@ package apiserver
 import (
 	"fmt"
 	"net/http"
+	"strings"
 
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/storage"
@@ -105,3 +106,41 @@ func IsAPIPrefixNotFound(err error) bool {
 	_, ok := err.(*errAPIPrefixNotFound)
 	return ok
 }
+
+// errNotAcceptable indicates Accept negotiation has failed
+// TODO: move to api/errors if other code needs to return this
+type errNotAcceptable struct {
+	accepted []string
+}
+
+func (e errNotAcceptable) Error() string {
+	return fmt.Sprintf("only the following media types are accepted: %v", strings.Join(e.accepted, ", "))
+}
+
+func (e errNotAcceptable) Status() unversioned.Status {
+	return unversioned.Status{
+		Status:  unversioned.StatusFailure,
+		Code:    http.StatusNotAcceptable,
+		Reason:  unversioned.StatusReason("NotAcceptable"),
+		Message: e.Error(),
+	}
+}
+
+// errNotAcceptable indicates Content-Type is not recognized
+// TODO: move to api/errors if other code needs to return this
+type errUnsupportedMediaType struct {
+	accepted []string
+}
+
+func (e errUnsupportedMediaType) Error() string {
+	return fmt.Sprintf("the body of the request was in an unknown format - accepted media types include: %v", strings.Join(e.accepted, ", "))
+}
+
+func (e errUnsupportedMediaType) Status() unversioned.Status {
+	return unversioned.Status{
+		Status:  unversioned.StatusFailure,
+		Code:    http.StatusUnsupportedMediaType,
+		Reason:  unversioned.StatusReason("UnsupportedMediaType"),
+		Message: e.Error(),
+	}
+}

pkg/apiserver/negotiate.go

+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package apiserver
+
+import (
+	"mime"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"bitbucket.org/ww/goautoneg"
+
+	"k8s.io/kubernetes/pkg/runtime"
+)
+
+func negotiateOutputSerializer(req *http.Request, ns runtime.NegotiatedSerializer) (runtime.Serializer, string, error) {
+	acceptHeader := req.Header.Get("Accept")
+	supported := ns.SupportedMediaTypes()
+	if len(acceptHeader) == 0 && len(supported) > 0 {
+		acceptHeader = supported[0]
+	}
+	accept, ok := negotiate(acceptHeader, supported)
+	if !ok {
+		return nil, "", errNotAcceptable{supported}
+	}
+
+	pretty := isPrettyPrint(req)
+	if _, ok := accept.Params["pretty"]; !ok && pretty {
+		accept.Params["pretty"] = "1"
+	}
+	mediaType := accept.Type
+	if len(accept.SubType) > 0 {
+		mediaType += "/" + accept.SubType
+	}
+	if s, ok := ns.SerializerForMediaType(mediaType, accept.Params); ok {
+		return s, mediaType, nil
+	}
+
+	return nil, "", errNotAcceptable{supported}
+}
+
+func negotiateInputSerializer(req *http.Request, s runtime.NegotiatedSerializer) (runtime.Serializer, error) {
+	supported := s.SupportedMediaTypes()
+	mediaType := req.Header.Get("Content-Type")
+	if len(mediaType) == 0 {
+		mediaType = supported[0]
+	}
+	mediaType, options, err := mime.ParseMediaType(mediaType)
+	if err != nil {
+		return nil, errUnsupportedMediaType{supported}
+	}
+	out, ok := s.SerializerForMediaType(mediaType, options)
+	if !ok {
+		return nil, errUnsupportedMediaType{supported}
+	}
+	return out, nil
+}
+
+// isPrettyPrint returns true if the "pretty" query parameter is true or if the User-Agent
+// matches known "human" clients.
+func isPrettyPrint(req *http.Request) bool {
+	// DEPRECATED: should be part of the content type
+	if req.URL != nil {
+		pp := req.URL.Query().Get("pretty")
+		if len(pp) > 0 {
+			pretty, _ := strconv.ParseBool(pp)
+			return pretty
+		}
+	}
+	userAgent := req.UserAgent()
+	// This covers basic all browers and cli http tools
+	if strings.HasPrefix(userAgent, "curl") || strings.HasPrefix(userAgent, "Wget") || strings.HasPrefix(userAgent, "Mozilla/5.0") {
+		return true
+	}
+	return false
+}
+
+// negotiate the most appropriate content type given the accept header and a list of
+// alternatives.
+func negotiate(header string, alternatives []string) (goautoneg.Accept, bool) {
+	alternates := make([][]string, 0, len(alternatives))
+	for _, alternate := range alternatives {
+		alternates = append(alternates, strings.SplitN(alternate, "/", 2))
+	}
+	for _, clause := range goautoneg.ParseAccept(header) {
+		for _, alternate := range alternates {
+			if clause.Type == alternate[0] && clause.SubType == alternate[1] {
+				return clause, true
+			}
+			if clause.Type == alternate[0] && clause.SubType == "*" {
+				clause.SubType = alternate[1]
+				return clause, true
+			}
+			if clause.Type == "*" && clause.SubType == "*" {
+				clause.Type = alternate[0]
+				clause.SubType = alternate[1]
+				return clause, true
+			}
+		}
+	}
+	return goautoneg.Accept{}, false
+}

pkg/apiserver/negotiate_test.go

+/*
+Copyright 2015 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package apiserver
+
+import (
+	"net/http"
+	"net/url"
+	"reflect"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/runtime"
+)
+
+type fakeNegotiater struct {
+	serializer runtime.Serializer
+	types      []string
+	mediaType  string
+	options    map[string]string
+}
+
+func (n *fakeNegotiater) SupportedMediaTypes() []string {
+	return n.types
+}
+
+func (n *fakeNegotiater) SerializerForMediaType(mediaType string, options map[string]string) (runtime.Serializer, bool) {
+	n.mediaType = mediaType
+	if len(options) > 0 {
+		n.options = options
+	}
+	return n.serializer, n.serializer != nil
+}
+
+func (n *fakeNegotiater) EncoderForVersion(serializer runtime.Serializer, gv unversioned.GroupVersion) runtime.Encoder {
+	return n.serializer
+}
+
+func (n *fakeNegotiater) DecoderToVersion(serializer runtime.Serializer, gv unversioned.GroupVersion) runtime.Decoder {
+	return n.serializer
+}
+
+var fakeCodec = runtime.NewCodec(runtime.NoopEncoder{}, runtime.NoopDecoder{})
+
+func TestNegotiate(t *testing.T) {
+	testCases := []struct {
+		accept      string
+		req         *http.Request
+		ns          *fakeNegotiater
+		serializer  runtime.Serializer
+		contentType string
+		params      map[string]string
+		errFn       func(error) bool
+	}{
+		// pick a default
+		{
+			req:         &http.Request{},
+			contentType: "application/json",
+			ns:          &fakeNegotiater{serializer: fakeCodec, types: []string{"application/json"}},
+			serializer:  fakeCodec,
+		},
+		{
+			accept:      "",
+			contentType: "application/json",
+			ns:          &fakeNegotiater{serializer: fakeCodec, types: []string{"application/json"}},
+			serializer:  fakeCodec,
+		},
+		{
+			accept:      "*/*",
+			contentType: "application/json",
+			ns:          &fakeNegotiater{serializer: fakeCodec, types: []string{"application/json"}},
+			serializer:  fakeCodec,
+		},
+		{
+			accept:      "application/*",
+			contentType: "application/json",
+			ns:          &fakeNegotiater{serializer: fakeCodec, types: []string{"application/json"}},
+			serializer:  fakeCodec,
+		},
+		{
+			accept:      "application/json",
+			contentType: "application/json",
+			ns:          &fakeNegotiater{serializer: fakeCodec, types: []string{"application/json"}},
+			serializer:  fakeCodec,
+		},
+		{
+			accept:      "application/json",
+			contentType: "application/json",
+			ns:          &fakeNegotiater{serializer: fakeCodec, types: []string{"application/json", "application/protobuf"}},
+			serializer:  fakeCodec,
+		},
+		{
+			accept:      "application/protobuf",
+			contentType: "application/protobuf",
+			ns:          &fakeNegotiater{serializer: fakeCodec, types: []string{"application/json", "application/protobuf"}},
+			serializer:  fakeCodec,
+		},
+		{
+			accept:      "application/json; pretty=1",
+			contentType: "application/json",
+			ns:          &fakeNegotiater{serializer: fakeCodec, types: []string{"application/json"}},
+			serializer:  fakeCodec,
+			params:      map[string]string{"pretty": "1"},
+		},
+		{
+			accept:      "unrecognized/stuff,application/json; pretty=1",
+			contentType: "application/json",
+			ns:          &fakeNegotiater{serializer: fakeCodec, types: []string{"application/json"}},
+			serializer:  fakeCodec,
+			params:      map[string]string{"pretty": "1"},
+		},
+
+		// query param triggers pretty
+		{
+			req: &http.Request{
+				Header: http.Header{"Accept": []string{"application/json"}},
+				URL:    &url.URL{RawQuery: "pretty=1"},
+			},
+			contentType: "application/json",
+			ns:          &fakeNegotiater{serializer: fakeCodec, types: []string{"application/json"}},
+			serializer:  fakeCodec,
+			params:      map[string]string{"pretty": "1"},
+		},
+
+		// certain user agents trigger pretty
+		{
+			req: &http.Request{
+				Header: http.Header{
+					"Accept":     []string{"application/json"},
+					"User-Agent": []string{"curl"},
+				},
+			},
+			contentType: "application/json",
+			ns:          &fakeNegotiater{serializer: fakeCodec, types: []string{"application/json"}},
+			serializer:  fakeCodec,
+			params:      map[string]string{"pretty": "1"},
+		},
+		{
+			req: &http.Request{
+				Header: http.Header{
+					"Accept":     []string{"application/json"},
+					"User-Agent": []string{"Wget"},
+				},
+			},
+			contentType: "application/json",
+			ns:          &fakeNegotiater{serializer: fakeCodec, types: []string{"application/json"}},
+			serializer:  fakeCodec,
+			params:      map[string]string{"pretty": "1"},
+		},
+		{
+			req: &http.Request{
+				Header: http.Header{
+					"Accept":     []string{"application/json"},
+					"User-Agent": []string{"Mozilla/5.0"},
+				},
+			},
+			contentType: "application/json",
+			ns:          &fakeNegotiater{serializer: fakeCodec, types: []string{"application/json"}},
+			serializer:  fakeCodec,
+			params:      map[string]string{"pretty": "1"},
+		},
+
+		// "application" is not a valid media type, so the server will reject the response during
+		// negotiation (the server, in error, has specified an invalid media type)
+		{
+			accept: "application",
+			ns:     &fakeNegotiater{serializer: fakeCodec, types: []string{"application"}},
+			errFn: func(err error) bool {
+				return err.Error() == "only the following media types are accepted: application"
+			},
+		},
+		{
+			ns: &fakeNegotiater{types: []string{"a/b/c"}},
+			errFn: func(err error) bool {
+				return err.Error() == "only the following media types are accepted: a/b/c"
+			},
+		},
+		{
+			ns: &fakeNegotiater{},
+			errFn: func(err error) bool {
+				return err.Error() == "only the following media types are accepted: "
+			},
+		},
+		{
+			accept: "*/*",
+			ns:     &fakeNegotiater{},
+			errFn: func(err error) bool {
+				return err.Error() == "only the following media types are accepted: "
+			},
+		},
+		{
+			accept: "application/json",
+			ns:     &fakeNegotiater{types: []string{"application/json"}},
+			errFn: func(err error) bool {
+				return err.Error() == "only the following media types are accepted: application/json"
+			},
+		},
+	}
+
+	for i, test := range testCases {
+		req := test.req
+		if req == nil {
+			req = &http.Request{Header: http.Header{}}
+			req.Header.Set("Accept", test.accept)
+		}
+		s, contentType, err := negotiateOutputSerializer(req, test.ns)
+		switch {
+		case err == nil && test.errFn != nil:
+			t.Errorf("%d: failed: expected error", i)
+			continue
+		case err != nil && test.errFn == nil:
+			t.Errorf("%d: failed: %v", i, err)
+			continue
+		case err != nil:
+			if !test.errFn(err) {
+				t.Errorf("%d: failed: %v", i, err)
+			}
+			status, ok := err.(statusError)
+			if !ok {
+				t.Errorf("%d: failed, error should be statusError: %v", i, err)
+				continue
+			}
+			if status.Status().Status != unversioned.StatusFailure || status.Status().Code != http.StatusNotAcceptable {
+				t.Errorf("%d: failed: %v", i, err)
+				continue
+			}
+			continue
+		}
+		if test.contentType != contentType {
+			t.Errorf("%d: unexpected %s %s", i, test.contentType, contentType)
+		}
+		if s != test.serializer {
+			t.Errorf("%d: unexpected %s %s", i, test.serializer, s)
+		}
+		if !reflect.DeepEqual(test.params, test.ns.options) {
+			t.Errorf("%d: unexpected %#v %#v", i, test.params, test.ns.options)
+		}
+	}
+}

pkg/apiserver/proxy.go

@@ -29,6 +29,7 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/api/rest"
+	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/apiserver/metrics"
 	"k8s.io/kubernetes/pkg/httplog"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -44,7 +45,7 @@ import (
 type ProxyHandler struct {
 	prefix              string
 	storage             map[string]rest.Storage
-	codec               runtime.Codec
+	serializer          runtime.NegotiatedSerializer
 	context             api.RequestContextMapper
 	requestInfoResolver *RequestInfoResolver
 }
@@ -98,20 +99,19 @@ func (r *ProxyHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	}
 	apiResource = resource
 
+	gv := unversioned.GroupVersion{Group: requestInfo.APIGroup, Version: requestInfo.APIVersion}
+
 	redirector, ok := storage.(rest.Redirector)
 	if !ok {
 		httplog.LogOf(req, w).Addf("'%v' is not a redirector", resource)
-		httpCode = errorJSON(errors.NewMethodNotSupported(api.Resource(resource), "proxy"), r.codec, w)
+		httpCode = errorNegotiated(errors.NewMethodNotSupported(api.Resource(resource), "proxy"), r.serializer, gv, w, req)
 		return
 	}
 
 	location, roundTripper, err := redirector.ResourceLocation(ctx, id)
 	if err != nil {
 		httplog.LogOf(req, w).Addf("Error getting ResourceLocation: %v", err)
-		status := errToAPIStatus(err)
-		code := int(status.Code)
-		writeJSON(code, r.codec, status, w, true)
-		httpCode = code
+		httpCode = errorNegotiated(err, r.serializer, gv, w, req)
 		return
 	}
 	if location == nil {
@@ -144,11 +144,7 @@ func (r *ProxyHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 
 	newReq, err := http.NewRequest(req.Method, location.String(), req.Body)
 	if err != nil {
-		status := errToAPIStatus(err)
-		code := int(status.Code)
-		writeJSON(code, r.codec, status, w, true)
-		notFound(w, req)
-		httpCode = code
+		httpCode = errorNegotiated(err, r.serializer, gv, w, req)
 		return
 	}
 	httpCode = http.StatusOK
@@ -161,7 +157,7 @@ func (r *ProxyHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	// TODO convert this entire proxy to an UpgradeAwareProxy similar to
 	// https://github.com/openshift/origin/blob/master/pkg/util/httpproxy/upgradeawareproxy.go.
 	// That proxy needs to be modified to support multiple backends, not just 1.
-	if r.tryUpgrade(w, req, newReq, location, roundTripper) {
+	if r.tryUpgrade(w, req, newReq, location, roundTripper, gv) {
 		return
 	}
 
@@ -210,15 +206,13 @@ func (r *ProxyHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 }
 
 // tryUpgrade returns true if the request was handled.
-func (r *ProxyHandler) tryUpgrade(w http.ResponseWriter, req, newReq *http.Request, location *url.URL, transport http.RoundTripper) bool {
+func (r *ProxyHandler) tryUpgrade(w http.ResponseWriter, req, newReq *http.Request, location *url.URL, transport http.RoundTripper, gv unversioned.GroupVersion) bool {
 	if !httpstream.IsUpgradeRequest(req) {
 		return false
 	}
 	backendConn, err := proxyutil.DialURL(location, transport)
 	if err != nil {
-		status := errToAPIStatus(err)
-		code := int(status.Code)
-		writeJSON(code, r.codec, status, w, true)
+		errorNegotiated(err, r.serializer, gv, w, req)
 		return true
 	}
 	defer backendConn.Close()
@@ -228,17 +222,13 @@ func (r *ProxyHandler) tryUpgrade(w http.ResponseWriter, req, newReq *http.Reque
 	// hijack, just for reference...
 	requestHijackedConn, _, err := w.(http.Hijacker).Hijack()
 	if err != nil {
-		status := errToAPIStatus(err)
-		code := int(status.Code)
-		writeJSON(code, r.codec, status, w, true)
+		errorNegotiated(err, r.serializer, gv, w, req)
 		return true
 	}
 	defer requestHijackedConn.Close()
 
 	if err = newReq.Write(backendConn); err != nil {
-		status := errToAPIStatus(err)
-		code := int(status.Code)
-		writeJSON(code, r.codec, status, w, true)
+		errorNegotiated(err, r.serializer, gv, w, req)
 		return true
 	}
 

pkg/apiserver/resthandler_test.go

@@ -28,6 +28,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	apierrors "k8s.io/kubernetes/pkg/api/errors"
+	"k8s.io/kubernetes/pkg/api/testapi"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -155,7 +156,7 @@ func (tc *patchTestCase) Run(t *testing.T) {
 	namespace := tc.startingPod.Namespace
 	name := tc.startingPod.Name
 
-	codec := registered.GroupOrDie(api.GroupName).Codec
+	codec := testapi.Default.Codec()
 	admit := tc.admit
 	if admit == nil {
 		admit = func(updatedObject runtime.Object) error {

pkg/apiserver/watch.go

@@ -65,23 +65,34 @@ func (w *realTimeoutFactory) TimeoutCh() (<-chan time.Time, func() bool) {
 }
 
 // serveWatch handles serving requests to the server
-func serveWatch(watcher watch.Interface, scope RequestScope, w http.ResponseWriter, req *restful.Request, timeout time.Duration) {
-	watchServer := &WatchServer{watcher, scope.Codec, func(obj runtime.Object) {
+func serveWatch(watcher watch.Interface, scope RequestScope, req *restful.Request, res *restful.Response, timeout time.Duration) {
+	s, mediaType, err := negotiateOutputSerializer(req.Request, scope.Serializer)
+	if err != nil {
+		scope.err(err, req, res)
+		return
+	}
+	// TODO: replace with typed serialization
+	if mediaType != "application/json" {
+		writeRawJSON(http.StatusNotAcceptable, (errNotAcceptable{[]string{"application/json"}}).Status(), res.ResponseWriter)
+		return
+	}
+	encoder := scope.Serializer.EncoderForVersion(s, scope.Kind.GroupVersion())
+	watchServer := &WatchServer{watcher, encoder, func(obj runtime.Object) {
 		if err := setSelfLink(obj, req, scope.Namer); err != nil {
 			glog.V(5).Infof("Failed to set self link for object %v: %v", reflect.TypeOf(obj), err)
 		}
 	}, &realTimeoutFactory{timeout}}
 	if isWebsocketRequest(req.Request) {
-		websocket.Handler(watchServer.HandleWS).ServeHTTP(httplog.Unlogged(w), req.Request)
+		websocket.Handler(watchServer.HandleWS).ServeHTTP(httplog.Unlogged(res.ResponseWriter), req.Request)
 	} else {
-		watchServer.ServeHTTP(w, req.Request)
+		watchServer.ServeHTTP(res.ResponseWriter, req.Request)
 	}
 }
 
 // WatchServer serves a watch.Interface over a websocket or vanilla HTTP.
 type WatchServer struct {
 	watching watch.Interface
-	codec    runtime.Codec
+	encoder  runtime.Encoder
 	fixup    func(runtime.Object)
 	t        timeoutFactory
 }
@@ -108,7 +119,7 @@ func (w *WatchServer) HandleWS(ws *websocket.Conn) {
 				return
 			}
 			w.fixup(event.Object)
-			obj, err := watchjson.Object(w.codec, &event)
+			obj, err := watchjson.Object(w.encoder, &event)
 			if err != nil {
 				// Client disconnect.
 				w.watching.Stop()
@@ -134,20 +145,21 @@ func (self *WatchServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 
 	cn, ok := w.(http.CloseNotifier)
 	if !ok {
-		loggedW.Addf("unable to get CloseNotifier")
+		loggedW.Addf("unable to get CloseNotifier: %#v", w)
 		http.NotFound(w, req)
 		return
 	}
 	flusher, ok := w.(http.Flusher)
 	if !ok {
-		loggedW.Addf("unable to get Flusher")
+		loggedW.Addf("unable to get Flusher: %#v", w)
 		http.NotFound(w, req)
 		return
 	}
 	w.Header().Set("Transfer-Encoding", "chunked")
 	w.WriteHeader(http.StatusOK)
 	flusher.Flush()
-	encoder := watchjson.NewEncoder(w, self.codec)
+	// TODO: use arbitrary serialization on watch
+	encoder := watchjson.NewEncoder(w, self.encoder)
 	for {
 		select {
 		case <-cn.CloseNotify():

pkg/apiserver/watch_test.go

@@ -169,6 +169,34 @@ func TestWatchHTTP(t *testing.T) {
 	}
 }
 
+func TestWatchHTTPAccept(t *testing.T) {
+	simpleStorage := &SimpleRESTStorage{}
+	handler := handle(map[string]rest.Storage{"simples": simpleStorage})
+	server := httptest.NewServer(handler)
+	defer server.Close()
+	client := http.Client{}
+
+	dest, _ := url.Parse(server.URL)
+	dest.Path = "/" + prefix + "/" + testGroupVersion.Group + "/" + testGroupVersion.Version + "/watch/simples"
+	dest.RawQuery = ""
+
+	request, err := http.NewRequest("GET", dest.String(), nil)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	request.Header.Set("Accept", "application/yaml")
+	response, err := client.Do(request)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	// TODO: once this is fixed, this test will change
+	if response.StatusCode != http.StatusNotAcceptable {
+		t.Errorf("Unexpected response %#v", response)
+	}
+}
+
 func TestWatchParamParsing(t *testing.T) {
 	simpleStorage := &SimpleRESTStorage{}
 	handler := handle(map[string]rest.Storage{

pkg/genericapiserver/genericapiserver.go

@@ -148,6 +148,15 @@ type APIGroupInfo struct {
 	// If nil, defaults to groupMeta.GroupVersion.
 	// TODO: Remove this when https://github.com/kubernetes/kubernetes/issues/19018 is fixed.
 	OptionsExternalVersion *unversioned.GroupVersion
+
+	// Scheme includes all of the types used by this group and how to convert between them (or
+	// to convert objects from outside of this group that are accepted in this API).
+	// TODO: replace with interfaces
+	Scheme *runtime.Scheme
+	// NegotiatedSerializer controls how this group encodes and decodes data
+	NegotiatedSerializer runtime.NegotiatedSerializer
+	// ParameterCodec performs conversions for query parameters passed to API calls
+	ParameterCodec runtime.ParameterCodec
 }
 
 // Config is a structure used to configure a GenericAPIServer.
@@ -275,6 +284,10 @@ type GenericAPIServer struct {
 	// storage contains the RESTful endpoints exposed by this GenericAPIServer
 	storage map[string]rest.Storage
 
+	// Serializer controls how common API objects not in a group/version prefix are serialized for this server.
+	// Individual APIGroups may define their own serializers.
+	Serializer runtime.NegotiatedSerializer
+
 	// "Outputs"
 	Handler         http.Handler
 	InsecureHandler http.Handler

pkg/genericapiserver/genericapiserver_test.go

@@ -94,6 +94,7 @@ func TestInstallAPIGroups(t *testing.T) {
 	config.ProxyTLSClientConfig = &tls.Config{}
 	config.APIPrefix = "/apiPrefix"
 	config.APIGroupPrefix = "/apiGroupPrefix"
+	config.Serializer = latest.Codecs
 
 	s := New(&config)
 	apiGroupMeta := registered.GroupOrDie(api.GroupName)

test/integration/master_test.go

@@ -51,3 +51,73 @@ func TestWatchSucceedsWithoutArgs(t *testing.T) {
 	}
 	resp.Body.Close()
 }
+
+func TestAccept(t *testing.T) {
+	_, s := framework.RunAMaster(t)
+	defer s.Close()
+
+	resp, err := http.Get(s.URL + "/api/")
+	if err != nil {
+		t.Fatalf("unexpected error getting api: %v", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("got status %v instead of 200 OK", resp.StatusCode)
+	}
+
+	body, _ := ioutil.ReadAll(resp.Body)
+	if resp.Header.Get("Content-Type") != "application/json" {
+		t.Errorf("unexpected content: %s", body)
+	}
+	if err := json.Unmarshal(body, &map[string]interface{}{}); err != nil {
+		t.Fatal(err)
+	}
+
+	req, err := http.NewRequest("GET", s.URL+"/api/", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req.Header.Set("Accept", "application/yaml")
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, _ = ioutil.ReadAll(resp.Body)
+	if resp.Header.Get("Content-Type") != "application/yaml" {
+		t.Errorf("unexpected content: %s", body)
+	}
+	t.Logf("body: %s", body)
+	if err := yaml.Unmarshal(body, &map[string]interface{}{}); err != nil {
+		t.Fatal(err)
+	}
+
+	req, err = http.NewRequest("GET", s.URL+"/api/", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req.Header.Set("Accept", "application/json, application/yaml")
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, _ = ioutil.ReadAll(resp.Body)
+	if resp.Header.Get("Content-Type") != "application/json" {
+		t.Errorf("unexpected content: %s", body)
+	}
+	t.Logf("body: %s", body)
+	if err := yaml.Unmarshal(body, &map[string]interface{}{}); err != nil {
+		t.Fatal(err)
+	}
+
+	req, err = http.NewRequest("GET", s.URL+"/api/", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req.Header.Set("Accept", "application") // not a valid media type
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if resp.StatusCode != http.StatusNotAcceptable {
+		t.Errorf("unexpected error from the server")
+	}
+}