Merge pull request #15069 from duglin/UseErrorPackage

Use the new error package

api/server/image.go

@@ -3,6 +3,7 @@ package server
 import (
 	"encoding/base64"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -343,7 +344,7 @@ func (s *Server) postBuild(ctx context.Context, w http.ResponseWriter, r *http.R
 			return err
 		}
 		sf := streamformatter.NewJSONStreamFormatter()
-		w.Write(sf.FormatError(err))
+		w.Write(sf.FormatError(errors.New(utils.GetErrorMessage(err))))
 	}
 	return nil
 }

api/server/server.go

@@ -14,6 +14,7 @@ import (
 	"github.com/gorilla/mux"
 
 	"github.com/Sirupsen/logrus"
+	"github.com/docker/distribution/registry/api/errcode"
 	"github.com/docker/docker/api"
 	"github.com/docker/docker/autogen/dockerversion"
 	"github.com/docker/docker/context"
@@ -189,28 +190,71 @@ func httpError(w http.ResponseWriter, err error) {
 		logrus.WithFields(logrus.Fields{"error": err, "writer": w}).Error("unexpected HTTP error handling")
 		return
 	}
+
 	statusCode := http.StatusInternalServerError
-	// FIXME: this is brittle and should not be necessary.
-	// If we need to differentiate between different possible error types, we should
-	// create appropriate error types with clearly defined meaning.
-	errStr := strings.ToLower(err.Error())
-	for keyword, status := range map[string]int{
-		"not found":             http.StatusNotFound,
-		"no such":               http.StatusNotFound,
-		"bad parameter":         http.StatusBadRequest,
-		"conflict":              http.StatusConflict,
-		"impossible":            http.StatusNotAcceptable,
-		"wrong login/password":  http.StatusUnauthorized,
-		"hasn't been activated": http.StatusForbidden,
-	} {
-		if strings.Contains(errStr, keyword) {
-			statusCode = status
-			break
+	errMsg := err.Error()
+
+	// Based on the type of error we get we need to process things
+	// slightly differently to extract the error message.
+	// In the 'errcode.*' cases there are two different type of
+	// error that could be returned. errocode.ErrorCode is the base
+	// type of error object - it is just an 'int' that can then be
+	// used as the look-up key to find the message. errorcode.Error
+	// extends errorcode.Error by adding error-instance specific
+	// data, like 'details' or variable strings to be inserted into
+	// the message.
+	//
+	// Ideally, we should just be able to call err.Error() for all
+	// cases but the errcode package doesn't support that yet.
+	//
+	// Additionally, in both errcode cases, there might be an http
+	// status code associated with it, and if so use it.
+	switch err.(type) {
+	case errcode.ErrorCode:
+		daError, _ := err.(errcode.ErrorCode)
+		statusCode = daError.Descriptor().HTTPStatusCode
+		errMsg = daError.Message()
+
+	case errcode.Error:
+		// For reference, if you're looking for a particular error
+		// then you can do something like :
+		//   import ( derr "github.com/docker/docker/api/errors" )
+		//   if daError.ErrorCode() == derr.ErrorCodeNoSuchContainer { ... }
+
+		daError, _ := err.(errcode.Error)
+		statusCode = daError.ErrorCode().Descriptor().HTTPStatusCode
+		errMsg = daError.Message
+
+	default:
+		// This part of will be removed once we've
+		// converted everything over to use the errcode package
+
+		// FIXME: this is brittle and should not be necessary.
+		// If we need to differentiate between different possible error types,
+		// we should create appropriate error types with clearly defined meaning
+		errStr := strings.ToLower(err.Error())
+		for keyword, status := range map[string]int{
+			"not found":             http.StatusNotFound,
+			"no such":               http.StatusNotFound,
+			"bad parameter":         http.StatusBadRequest,
+			"conflict":              http.StatusConflict,
+			"impossible":            http.StatusNotAcceptable,
+			"wrong login/password":  http.StatusUnauthorized,
+			"hasn't been activated": http.StatusForbidden,
+		} {
+			if strings.Contains(errStr, keyword) {
+				statusCode = status
+				break
+			}
 		}
 	}
 
+	if statusCode == 0 {
+		statusCode = http.StatusInternalServerError
+	}
+
 	logrus.WithFields(logrus.Fields{"statusCode": statusCode, "err": err}).Error("HTTP Error")
-	http.Error(w, err.Error(), statusCode)
+	http.Error(w, errMsg, statusCode)
 }
 
 // writeJSON writes the value v to the http response stream as json with standard