deleted file mode 100644

@@ -1,202 +0,0 @@

-package httputils // import "github.com/docker/docker/api/server/httputils"

-

-import (

-	"fmt"

-	"net/http"

-

-	"github.com/docker/distribution/registry/api/errcode"

-	"github.com/docker/docker/api/types"

-	"github.com/docker/docker/api/types/versions"

-	"github.com/docker/docker/errdefs"

-	"github.com/gorilla/mux"

-	"github.com/sirupsen/logrus"

-	"google.golang.org/grpc/codes"

-	"google.golang.org/grpc/status"

-)

-

-type causer interface {

-	Cause() error

-}

-

-// GetHTTPErrorStatusCode retrieves status code from error message.

-func GetHTTPErrorStatusCode(err error) int {

-	if err == nil {

-		logrus.WithFields(logrus.Fields{"error": err}).Error("unexpected HTTP error handling")

-		return http.StatusInternalServerError

-	}

-

-	var statusCode int

-

-	// Stop right there

-	// Are you sure you should be adding a new error class here? Do one of the existing ones work?

-

-	// Note that the below functions are already checking the error causal chain for matches.

-	switch {

-	case errdefs.IsNotFound(err):

-		statusCode = http.StatusNotFound

-	case errdefs.IsInvalidParameter(err):

-		statusCode = http.StatusBadRequest

-	case errdefs.IsConflict(err) || errdefs.IsAlreadyExists(err):

-		statusCode = http.StatusConflict

-	case errdefs.IsUnauthorized(err):

-		statusCode = http.StatusUnauthorized

-	case errdefs.IsUnavailable(err):

-		statusCode = http.StatusServiceUnavailable

-	case errdefs.IsForbidden(err):

-		statusCode = http.StatusForbidden

-	case errdefs.IsNotModified(err):

-		statusCode = http.StatusNotModified

-	case errdefs.IsNotImplemented(err):

-		statusCode = http.StatusNotImplemented

-	case errdefs.IsSystem(err) || errdefs.IsUnknown(err) || errdefs.IsDataLoss(err) || errdefs.IsDeadline(err) || errdefs.IsCancelled(err):

-		statusCode = http.StatusInternalServerError

-	default:

-		statusCode = statusCodeFromGRPCError(err)

-		if statusCode != http.StatusInternalServerError {

-			return statusCode

-		}

-		statusCode = statusCodeFromDistributionError(err)

-		if statusCode != http.StatusInternalServerError {

-			return statusCode

-		}

-		if e, ok := err.(causer); ok {

-			return GetHTTPErrorStatusCode(e.Cause())

-		}

-

-		logrus.WithFields(logrus.Fields{

-			"module":     "api",

-			"error_type": fmt.Sprintf("%T", err),

-		}).Debugf("FIXME: Got an API for which error does not match any expected type!!!: %+v", err)

-	}

-

-	if statusCode == 0 {

-		statusCode = http.StatusInternalServerError

-	}

-

-	return statusCode

-}

-

-// FromStatusCode creates an errdef error, based on the provided status-code

-func FromStatusCode(err error, statusCode int) error {

-	if err == nil {

-		return err

-	}

-	switch statusCode {

-	case http.StatusNotFound:

-		err = errdefs.NotFound(err)

-	case http.StatusBadRequest:

-		err = errdefs.InvalidParameter(err)

-	case http.StatusConflict:

-		err = errdefs.Conflict(err)

-	case http.StatusUnauthorized:

-		err = errdefs.Unauthorized(err)

-	case http.StatusServiceUnavailable:

-		err = errdefs.Unavailable(err)

-	case http.StatusForbidden:

-		err = errdefs.Forbidden(err)

-	case http.StatusNotModified:

-		err = errdefs.NotModified(err)

-	case http.StatusNotImplemented:

-		err = errdefs.NotImplemented(err)

-	case http.StatusInternalServerError:

-		if !errdefs.IsSystem(err) && !errdefs.IsUnknown(err) && !errdefs.IsDataLoss(err) && !errdefs.IsDeadline(err) && !errdefs.IsCancelled(err) {

-			err = errdefs.System(err)

-		}

-	default:

-		logrus.WithFields(logrus.Fields{

-			"module":      "api",

-			"status_code": fmt.Sprintf("%d", statusCode),

-		}).Debugf("FIXME: Got an status-code for which error does not match any expected type!!!: %d", statusCode)

-

-		switch {

-		case statusCode >= 200 && statusCode < 400:

-			// it's a client error

-		case statusCode >= 400 && statusCode < 500:

-			err = errdefs.InvalidParameter(err)

-		case statusCode >= 500 && statusCode < 600:

-			err = errdefs.System(err)

-		default:

-			err = errdefs.Unknown(err)

-		}

-	}

-	return err

-}

-

-func apiVersionSupportsJSONErrors(version string) bool {

-	const firstAPIVersionWithJSONErrors = "1.23"

-	return version == "" || versions.GreaterThan(version, firstAPIVersionWithJSONErrors)

-}

-

-// MakeErrorHandler makes an HTTP handler that decodes a Docker error and

-// returns it in the response.

-func MakeErrorHandler(err error) http.HandlerFunc {

-	return func(w http.ResponseWriter, r *http.Request) {

-		statusCode := GetHTTPErrorStatusCode(err)

-		vars := mux.Vars(r)

-		if apiVersionSupportsJSONErrors(vars["version"]) {

-			response := &types.ErrorResponse{

-				Message: err.Error(),

-			}

-			WriteJSON(w, statusCode, response)

-		} else {

-			http.Error(w, status.Convert(err).Message(), statusCode)

-		}

-	}

-}

-

-// statusCodeFromGRPCError returns status code according to gRPC error

-func statusCodeFromGRPCError(err error) int {

-	switch status.Code(err) {

-	case codes.InvalidArgument: // code 3

-		return http.StatusBadRequest

-	case codes.NotFound: // code 5

-		return http.StatusNotFound

-	case codes.AlreadyExists: // code 6

-		return http.StatusConflict

-	case codes.PermissionDenied: // code 7

-		return http.StatusForbidden

-	case codes.FailedPrecondition: // code 9

-		return http.StatusBadRequest

-	case codes.Unauthenticated: // code 16

-		return http.StatusUnauthorized

-	case codes.OutOfRange: // code 11

-		return http.StatusBadRequest

-	case codes.Unimplemented: // code 12

-		return http.StatusNotImplemented

-	case codes.Unavailable: // code 14

-		return http.StatusServiceUnavailable

-	default:

-		if e, ok := err.(causer); ok {

-			return statusCodeFromGRPCError(e.Cause())

-		}

-		// codes.Canceled(1)

-		// codes.Unknown(2)

-		// codes.DeadlineExceeded(4)

-		// codes.ResourceExhausted(8)

-		// codes.Aborted(10)

-		// codes.Internal(13)

-		// codes.DataLoss(15)

-		return http.StatusInternalServerError

-	}

-}

-

-// statusCodeFromDistributionError returns status code according to registry errcode

-// code is loosely based on errcode.ServeJSON() in docker/distribution

-func statusCodeFromDistributionError(err error) int {

-	switch errs := err.(type) {

-	case errcode.Errors:

-		if len(errs) < 1 {

-			return http.StatusInternalServerError

-		}

-		if _, ok := errs[0].(errcode.ErrorCoder); ok {

-			return statusCodeFromDistributionError(errs[0])

-		}

-	case errcode.ErrorCoder:

-		return errs.ErrorCode().Descriptor().HTTPStatusCode

-	default:

-		if e, ok := err.(causer); ok {

-			return statusCodeFromDistributionError(e.Cause())

-		}

-	}

-	return http.StatusInternalServerError

-}

new file mode 100644

@@ -0,0 +1,9 @@

+package httputils // import "github.com/docker/docker/api/server/httputils"

+import "github.com/docker/docker/errdefs"

+

+// GetHTTPErrorStatusCode retrieves status code from error message.

+//

+// Deprecated: use errdefs.GetHTTPErrorStatusCode

+func GetHTTPErrorStatusCode(err error) int {

+	return errdefs.GetHTTPErrorStatusCode(err)

+}

deleted file mode 100644

@@ -1,93 +0,0 @@

-package httputils

-

-import (

-	"fmt"

-	"net/http"

-	"testing"

-

-	"github.com/docker/docker/errdefs"

-	"gotest.tools/assert"

-)

-

-func TestFromStatusCode(t *testing.T) {

-	testErr := fmt.Errorf("some error occurred")

-

-	testCases := []struct {

-		err    error

-		status int

-		check  func(error) bool

-	}{

-		{

-			err:    testErr,

-			status: http.StatusNotFound,

-			check:  errdefs.IsNotFound,

-		},

-		{

-			err:    testErr,

-			status: http.StatusBadRequest,

-			check:  errdefs.IsInvalidParameter,

-		},

-		{

-			err:    testErr,

-			status: http.StatusConflict,

-			check:  errdefs.IsConflict,

-		},

-		{

-			err:    testErr,

-			status: http.StatusUnauthorized,

-			check:  errdefs.IsUnauthorized,

-		},

-		{

-			err:    testErr,

-			status: http.StatusServiceUnavailable,

-			check:  errdefs.IsUnavailable,

-		},

-		{

-			err:    testErr,

-			status: http.StatusForbidden,

-			check:  errdefs.IsForbidden,

-		},

-		{

-			err:    testErr,

-			status: http.StatusNotModified,

-			check:  errdefs.IsNotModified,

-		},

-		{

-			err:    testErr,

-			status: http.StatusNotImplemented,

-			check:  errdefs.IsNotImplemented,

-		},

-		{

-			err:    testErr,

-			status: http.StatusInternalServerError,

-			check:  errdefs.IsSystem,

-		},

-		{

-			err:    errdefs.Unknown(testErr),

-			status: http.StatusInternalServerError,

-			check:  errdefs.IsUnknown,

-		},

-		{

-			err:    errdefs.DataLoss(testErr),

-			status: http.StatusInternalServerError,

-			check:  errdefs.IsDataLoss,

-		},

-		{

-			err:    errdefs.Deadline(testErr),

-			status: http.StatusInternalServerError,

-			check:  errdefs.IsDeadline,

-		},

-		{

-			err:    errdefs.Cancelled(testErr),

-			status: http.StatusInternalServerError,

-			check:  errdefs.IsCancelled,

-		},

-	}

-

-	for _, tc := range testCases {

-		t.Run(http.StatusText(tc.status), func(t *testing.T) {

-			err := FromStatusCode(tc.err, tc.status)

-			assert.Check(t, tc.check(err), "unexpected error-type %T", err)

-		})

-	}

-}

@@ -7,9 +7,13 @@ import (

 	"net/http"

 	"strings"

+	"github.com/docker/docker/api/types"

+	"github.com/docker/docker/api/types/versions"

 	"github.com/docker/docker/errdefs"

+	"github.com/gorilla/mux"

 	"github.com/pkg/errors"

 	"github.com/sirupsen/logrus"

+	"google.golang.org/grpc/status"

 )

 // APIVersionKey is the client's requested API version.

@@ -88,6 +92,28 @@ func VersionFromContext(ctx context.Context) string {

 	return ""

 }

+// MakeErrorHandler makes an HTTP handler that decodes a Docker error and

+// returns it in the response.

+func MakeErrorHandler(err error) http.HandlerFunc {

+	return func(w http.ResponseWriter, r *http.Request) {

+		statusCode := errdefs.GetHTTPErrorStatusCode(err)

+		vars := mux.Vars(r)

+		if apiVersionSupportsJSONErrors(vars["version"]) {

+			response := &types.ErrorResponse{

+				Message: err.Error(),

+			}

+			WriteJSON(w, statusCode, response)

+		} else {

+			http.Error(w, status.Convert(err).Message(), statusCode)

+		}

+	}

+}

+

+func apiVersionSupportsJSONErrors(version string) bool {

+	const firstAPIVersionWithJSONErrors = "1.23"

+	return version == "" || versions.GreaterThan(version, firstAPIVersionWithJSONErrors)

+}

+

 // matchesContentType validates the content type against the expected one

 func matchesContentType(contentType, expectedType string) bool {

 	mimetype, _, err := mime.ParseMediaType(contentType)

@@ -589,7 +589,7 @@ func (s *containerRouter) postContainersAttach(ctx context.Context, w http.Respo

 		// Remember to close stream if error happens

 		conn, _, errHijack := hijacker.Hijack()

 		if errHijack == nil {

-			statusCode := httputils.GetHTTPErrorStatusCode(err)

+			statusCode := errdefs.GetHTTPErrorStatusCode(err)

 			statusText := http.StatusText(statusCode)

 			fmt.Fprintf(conn, "HTTP/1.1 %d %s\r\nContent-Type: application/vnd.docker.raw-stream\r\n\r\n%s\r\n", statusCode, statusText, err.Error())

 			httputils.CloseStreams(conn)

@@ -12,6 +12,7 @@ import (

 	"github.com/docker/docker/api/server/router"

 	"github.com/docker/docker/api/server/router/debug"

 	"github.com/docker/docker/dockerversion"

+	"github.com/docker/docker/errdefs"

 	"github.com/gorilla/mux"

 	"github.com/sirupsen/logrus"

 )

@@ -139,7 +140,7 @@ func (s *Server) makeHTTPHandler(handler httputils.APIFunc) http.HandlerFunc {

 		}

 		if err := handlerFunc(ctx, w, r, vars); err != nil {

-			statusCode := httputils.GetHTTPErrorStatusCode(err)

+			statusCode := errdefs.GetHTTPErrorStatusCode(err)

 			if statusCode >= 500 {

 				logrus.Errorf("Handler for %s %s returned error: %v", r.Method, r.URL.Path, err)

 			}

@@ -5,8 +5,8 @@ import (

 	"net/http"

 	"path"

-	"github.com/docker/docker/api/server/httputils"

 	"github.com/docker/docker/api/types"

+	"github.com/docker/docker/errdefs"

 )

 // Ping pings the server and returns the value of the "Docker-Experimental",

@@ -49,7 +49,7 @@ func parsePingResponse(cli *Client, resp serverResponse) (types.Ping, error) {

 	var ping types.Ping

 	if resp.header == nil {

 		err := cli.checkResponseErr(resp)

-		return ping, httputils.FromStatusCode(err, resp.statusCode)

+		return ping, errdefs.FromStatusCode(err, resp.statusCode)

 	}

 	ping.APIVersion = resp.header.Get("API-Version")

 	ping.OSType = resp.header.Get("OSType")

@@ -60,5 +60,5 @@ func parsePingResponse(cli *Client, resp serverResponse) (types.Ping, error) {

 		ping.BuilderVersion = types.BuilderVersion(bv)

 	}

 	err := cli.checkResponseErr(resp)

-	return ping, httputils.FromStatusCode(err, resp.statusCode)

+	return ping, errdefs.FromStatusCode(err, resp.statusCode)

 }

@@ -13,9 +13,9 @@ import (

 	"os"

 	"strings"

-	"github.com/docker/docker/api/server/httputils"

 	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/api/types/versions"

+	"github.com/docker/docker/errdefs"

 	"github.com/pkg/errors"

 )

@@ -121,10 +121,10 @@ func (cli *Client) sendRequest(ctx context.Context, method, path string, query u

 	}

 	resp, err := cli.doRequest(ctx, req)

 	if err != nil {

-		return resp, httputils.FromStatusCode(err, resp.statusCode)

+		return resp, errdefs.FromStatusCode(err, resp.statusCode)

 	}

 	err = cli.checkResponseErr(resp)

-	return resp, httputils.FromStatusCode(err, resp.statusCode)

+	return resp, errdefs.FromStatusCode(err, resp.statusCode)

 }

 func (cli *Client) doRequest(ctx context.Context, req *http.Request) (serverResponse, error) {

new file mode 100644

@@ -0,0 +1,172 @@

+package errdefs // import "github.com/docker/docker/errdefs"

+

+import (

+	"fmt"

+	"net/http"

+

+	"github.com/docker/distribution/registry/api/errcode"

+	"github.com/sirupsen/logrus"

+	"google.golang.org/grpc/codes"

+	"google.golang.org/grpc/status"

+)

+

+// GetHTTPErrorStatusCode retrieves status code from error message.

+func GetHTTPErrorStatusCode(err error) int {

+	if err == nil {

+		logrus.WithFields(logrus.Fields{"error": err}).Error("unexpected HTTP error handling")

+		return http.StatusInternalServerError

+	}

+

+	var statusCode int

+

+	// Stop right there

+	// Are you sure you should be adding a new error class here? Do one of the existing ones work?

+

+	// Note that the below functions are already checking the error causal chain for matches.

+	switch {

+	case IsNotFound(err):

+		statusCode = http.StatusNotFound

+	case IsInvalidParameter(err):

+		statusCode = http.StatusBadRequest

+	case IsConflict(err) || IsAlreadyExists(err):

+		statusCode = http.StatusConflict

+	case IsUnauthorized(err):

+		statusCode = http.StatusUnauthorized

+	case IsUnavailable(err):

+		statusCode = http.StatusServiceUnavailable

+	case IsForbidden(err):

+		statusCode = http.StatusForbidden

+	case IsNotModified(err):

+		statusCode = http.StatusNotModified

+	case IsNotImplemented(err):

+		statusCode = http.StatusNotImplemented

+	case IsSystem(err) || IsUnknown(err) || IsDataLoss(err) || IsDeadline(err) || IsCancelled(err):

+		statusCode = http.StatusInternalServerError

+	default:

+		statusCode = statusCodeFromGRPCError(err)

+		if statusCode != http.StatusInternalServerError {

+			return statusCode

+		}

+		statusCode = statusCodeFromDistributionError(err)

+		if statusCode != http.StatusInternalServerError {

+			return statusCode

+		}

+		if e, ok := err.(causer); ok {

+			return GetHTTPErrorStatusCode(e.Cause())

+		}

+

+		logrus.WithFields(logrus.Fields{

+			"module":     "api",

+			"error_type": fmt.Sprintf("%T", err),

+		}).Debugf("FIXME: Got an API for which error does not match any expected type!!!: %+v", err)

+	}

+

+	if statusCode == 0 {

+		statusCode = http.StatusInternalServerError

+	}

+

+	return statusCode

+}

+

+// FromStatusCode creates an errdef error, based on the provided HTTP status-code

+func FromStatusCode(err error, statusCode int) error {

+	if err == nil {

+		return err

+	}

+	switch statusCode {

+	case http.StatusNotFound:

+		err = NotFound(err)

+	case http.StatusBadRequest:

+		err = InvalidParameter(err)

+	case http.StatusConflict:

+		err = Conflict(err)

+	case http.StatusUnauthorized:

+		err = Unauthorized(err)

+	case http.StatusServiceUnavailable:

+		err = Unavailable(err)

+	case http.StatusForbidden:

+		err = Forbidden(err)

+	case http.StatusNotModified:

+		err = NotModified(err)

+	case http.StatusNotImplemented:

+		err = NotImplemented(err)

+	case http.StatusInternalServerError:

+		if !IsSystem(err) && !IsUnknown(err) && !IsDataLoss(err) && !IsDeadline(err) && !IsCancelled(err) {

+			err = System(err)

+		}

+	default:

+		logrus.WithFields(logrus.Fields{

+			"module":      "api",

+			"status_code": fmt.Sprintf("%d", statusCode),

+		}).Debugf("FIXME: Got an status-code for which error does not match any expected type!!!: %d", statusCode)

+

+		switch {

+		case statusCode >= 200 && statusCode < 400:

+			// it's a client error

+		case statusCode >= 400 && statusCode < 500:

+			err = InvalidParameter(err)

+		case statusCode >= 500 && statusCode < 600:

+			err = System(err)

+		default:

+			err = Unknown(err)

+		}

+	}

+	return err

+}

+

+// statusCodeFromGRPCError returns status code according to gRPC error

+func statusCodeFromGRPCError(err error) int {

+	switch status.Code(err) {

+	case codes.InvalidArgument: // code 3

+		return http.StatusBadRequest

+	case codes.NotFound: // code 5

+		return http.StatusNotFound

+	case codes.AlreadyExists: // code 6

+		return http.StatusConflict

+	case codes.PermissionDenied: // code 7

+		return http.StatusForbidden

+	case codes.FailedPrecondition: // code 9

+		return http.StatusBadRequest

+	case codes.Unauthenticated: // code 16

+		return http.StatusUnauthorized

+	case codes.OutOfRange: // code 11

+		return http.StatusBadRequest

+	case codes.Unimplemented: // code 12

+		return http.StatusNotImplemented

+	case codes.Unavailable: // code 14

+		return http.StatusServiceUnavailable

+	default:

+		if e, ok := err.(causer); ok {

+			return statusCodeFromGRPCError(e.Cause())

+		}

+		// codes.Canceled(1)

+		// codes.Unknown(2)

+		// codes.DeadlineExceeded(4)

+		// codes.ResourceExhausted(8)

+		// codes.Aborted(10)

+		// codes.Internal(13)

+		// codes.DataLoss(15)

+		return http.StatusInternalServerError

+	}

+}

+

+// statusCodeFromDistributionError returns status code according to registry errcode

+// code is loosely based on errcode.ServeJSON() in docker/distribution

+func statusCodeFromDistributionError(err error) int {

+	switch errs := err.(type) {

+	case errcode.Errors:

+		if len(errs) < 1 {

+			return http.StatusInternalServerError

+		}

+		if _, ok := errs[0].(errcode.ErrorCoder); ok {

+			return statusCodeFromDistributionError(errs[0])

+		}

+	case errcode.ErrorCoder:

+		return errs.ErrorCode().Descriptor().HTTPStatusCode

+	default:

+		if e, ok := err.(causer); ok {

+			return statusCodeFromDistributionError(e.Cause())

+		}

+	}

+	return http.StatusInternalServerError

+}

new file mode 100644

@@ -0,0 +1,92 @@

+package errdefs

+

+import (

+	"fmt"

+	"net/http"

+	"testing"

+

+	"gotest.tools/assert"

+)

+

+func TestFromStatusCode(t *testing.T) {

+	testErr := fmt.Errorf("some error occurred")

+

+	testCases := []struct {

+		err    error

+		status int

+		check  func(error) bool

+	}{

+		{

+			err:    testErr,

+			status: http.StatusNotFound,

+			check:  IsNotFound,

+		},

+		{

+			err:    testErr,

+			status: http.StatusBadRequest,

+			check:  IsInvalidParameter,

+		},

+		{

+			err:    testErr,

+			status: http.StatusConflict,

+			check:  IsConflict,

+		},

+		{

+			err:    testErr,

+			status: http.StatusUnauthorized,

+			check:  IsUnauthorized,

+		},

+		{

+			err:    testErr,

+			status: http.StatusServiceUnavailable,

+			check:  IsUnavailable,

+		},

+		{

+			err:    testErr,

+			status: http.StatusForbidden,

+			check:  IsForbidden,

+		},

+		{

+			err:    testErr,

+			status: http.StatusNotModified,

+			check:  IsNotModified,

+		},

+		{

+			err:    testErr,

+			status: http.StatusNotImplemented,

+			check:  IsNotImplemented,

+		},

+		{

+			err:    testErr,

+			status: http.StatusInternalServerError,

+			check:  IsSystem,

+		},

+		{

+			err:    Unknown(testErr),

+			status: http.StatusInternalServerError,

+			check:  IsUnknown,

+		},

+		{

+			err:    DataLoss(testErr),

+			status: http.StatusInternalServerError,

+			check:  IsDataLoss,

+		},

+		{

+			err:    Deadline(testErr),

+			status: http.StatusInternalServerError,

+			check:  IsDeadline,

+		},

+		{

+			err:    Cancelled(testErr),

+			status: http.StatusInternalServerError,

+			check:  IsCancelled,

+		},

+	}

+

+	for _, tc := range testCases {

+		t.Run(http.StatusText(tc.status), func(t *testing.T) {

+			err := FromStatusCode(tc.err, tc.status)

+			assert.Check(t, tc.check(err), "unexpected error-type %T", err)

+		})

+	}

+}