[type: refactor] refactor the envcd errors. (#107)

Author: qicz

README.md

@@ -33,4 +33,3 @@ environment configurations detector/discovery/dictionary
 func NewAsyncWriter(w io.Writer, bufSize int, block bool) *AsyncLogWriter {
 }
 ```
-

internal/core/openapi/dictionary.go

@@ -19,7 +19,6 @@ package openapi
 
 import (
 	"fmt"
-	"net/http"
 	"time"
 
 	"github.com/acmestack/envcd/internal/core/storage/dao"
@@ -45,7 +44,7 @@ func (openapi *Openapi) dictionary(ginCtx *gin.Context) {
 		dict := entity.Dictionary{Id: dictId, UserId: userId, ScopeSpaceId: scopeSpaceId}
 		dictionary, err := dao.New(openapi.storage).SelectDictionary(dict)
 		if err != nil {
-			return result.InternalServerErrorFailure(err.Error())
+			return result.InternalFailure(err)
 		}
 		return result.Success(dictionary)
 	})
@@ -56,7 +55,7 @@ func (openapi *Openapi) createDictionary(ginCtx *gin.Context) {
 		param := dictParams{}
 		if err := ginCtx.ShouldBindJSON(&param); err != nil {
 			fmt.Printf("Bind error, %v\n", err)
-			return result.InternalServerErrorFailure(result.EnvcdErrors[result.IllegalJsonBindingErrorCode])
+			return result.InternalFailure(err)
 		}
 		// get userId and appId from gin context
 		userId := stringsx.ToInt(ginCtx.Param("userId"))
@@ -108,18 +107,18 @@ func (openapi *Openapi) removeDictionary(ginCtx *gin.Context) {
 		daoAction := dao.New(openapi.storage)
 		dictionary, err := daoAction.SelectDictionary(dict)
 		if err != nil {
-			return result.InternalServerErrorFailure(err.Error())
+			return result.InternalFailure(err)
 		}
 		if len(dictionary) == 0 {
-			return result.Failure0(result.DictionaryNotExistErrorCode, result.EnvcdErrors[result.DictionaryNotExistErrorCode], http.StatusBadRequest)
+			return result.Failure0(result.ErrorDictionaryNotExist)
 		}
 		exchangeErr := openapi.exchange.Remove(getFirstDictionary(dictionary).DictKey)
 		if exchangeErr != nil {
-			return result.InternalServerErrorFailure(exchangeErr.Error())
+			return result.InternalFailure(exchangeErr)
 		}
 		retId, delErr := daoAction.DeleteDictionary(getFirstDictionary(dictionary))
 		if delErr != nil {
-			return result.InternalServerErrorFailure(delErr.Error())
+			return result.InternalFailure(delErr)
 		}
 		return result.Success(retId)
 	})

internal/core/openapi/openapi.go

@@ -31,6 +31,7 @@ import (
 	"github.com/acmestack/envcd/internal/pkg/context"
 	"github.com/acmestack/envcd/internal/pkg/executor"
 	"github.com/acmestack/envcd/pkg/entity/result"
+	"github.com/acmestack/godkits/gox/errorsx"
 	"github.com/acmestack/godkits/log"
 	"github.com/gin-gonic/gin"
 )
@@ -85,7 +86,7 @@ func (openapi *Openapi) buildRouter() *gin.Engine {
 	// Recovery middleware recovers from any panics and writes a 500 if there was one.
 	router.Use(gin.CustomRecovery(func(ginCtx *gin.Context, recovered interface{}) {
 		if err, ok := recovered.(string); ok {
-			failure := result.InternalServerErrorFailure(fmt.Sprintf("error: %s", err))
+			failure := result.InternalFailure(errorsx.Err(fmt.Sprintf("error: %s", err)))
 			ginCtx.JSON(failure.HttpStatusCode, failure.Data)
 		}
 		ginCtx.AbortWithStatus(http.StatusInternalServerError)
@@ -150,7 +151,7 @@ func (openapi *Openapi) buildRouter() *gin.Engine {
 func (openapi *Openapi) response(ginCtx *gin.Context, permissionAction context.EnvcdActionFunc, action context.EnvcdActionFunc) {
 	requestId := ginCtx.Request.Header.Get(requestIdHeader)
 	c := openapi.contexts[requestId]
-	ret := result.InternalServerErrorFailure(http.StatusText(http.StatusInternalServerError))
+	ret := result.InternalFailure0()
 	if c != nil && c.RequestId == requestId {
 		c.PermissionAction = permissionAction
 		c.Action = action

internal/core/openapi/user.go

@@ -19,7 +19,6 @@ package openapi
 
 import (
 	"fmt"
-	"net/http"
 	"time"
 
 	"github.com/acmestack/envcd/internal/core/storage/dao"
@@ -49,7 +48,7 @@ const (
 	// hmacSecret secret
 	hmacSecret = "9C035514A15F78"
 	userIdKey  = "userId"
-	tokenKey   = "token"
+	tokenKey   = "accessToken"
 
 	userStateEnabled  = "enabled"
 	userStateDisabled = "disabled"
@@ -79,27 +78,24 @@ func (openapi *Openapi) login(ginCtx *gin.Context) {
 		param := loginParam{}
 		if err := ginCtx.ShouldBindJSON(&param); err != nil {
 			log.Error("Bind error, %v", err)
-			return result.InternalServerErrorFailure("Illegal params !")
+			return result.InternalFailure(err)
 		}
 
 		users, err := dao.New(openapi.storage).SelectUser(entity.User{
 			Name: param.Username,
 		})
 		if err != nil {
 			log.Error("Query User error: %v", err)
-			// todo error code : result.Failure0(code, message, httpStatusCode)
-			return result.Failure("System Error!", http.StatusBadRequest)
+			return result.InternalFailure(err)
 		}
 
 		if len(users) == 0 {
-			// todo error code : result.Failure0(code, message, httpStatusCode)
 			log.Error("User does not exist : %v", param)
-			return result.Failure("User does not exist!", http.StatusOK)
+			return result.Failure0(result.ErrorUserNotFound)
 		}
 		user := users[0]
 		if saltPassword(param.Password, user.Salt) != user.Password {
-			// todo error code : result.Failure0(code, message, httpStatusCode)
-			return result.Failure("password error!", http.StatusOK)
+			return result.Failure0(result.ErrorUserPasswordIncorrect)
 		}
 		token := newJWTToken(claims{
 			RegisteredClaims: &jwt.RegisteredClaims{
@@ -129,7 +125,7 @@ func (openapi *Openapi) createUser(ginCtx *gin.Context) {
 		param := userParam{}
 		if err := ginCtx.ShouldBindJSON(&param); err != nil {
 			log.Error("Bind error, %v", err)
-			return result.InternalServerErrorFailure("Illegal params !")
+			return result.InternalFailure(err)
 		}
 		daoAction := dao.New(openapi.storage)
 		// check if the user already exists in the database
@@ -138,11 +134,11 @@ func (openapi *Openapi) createUser(ginCtx *gin.Context) {
 		})
 		if err != nil {
 			log.Error("Query User error: %v", err)
-			return result.InternalServerErrorFailure("System Error!")
+			return result.InternalFailure(err)
 		}
 		if len(users) > 0 {
 			log.Error("User Has exists: %v", users)
-			return result.InternalServerErrorFailure("User Has Exists!")
+			return result.Failure0(result.ErrorUserExisted)
 		}
 		// generate database password by salt
 		salt := randomSalt()
@@ -159,7 +155,7 @@ func (openapi *Openapi) createUser(ginCtx *gin.Context) {
 		// save user
 		if _, _, err := daoAction.InsertUser(user); err != nil {
 			log.Error("insert error=%v", err)
-			return result.InternalServerErrorFailure("Save User Error!")
+			return result.Failure(result.ErrorCreateUser, err)
 		}
 		// fixme update success message or response token and id ?
 		return result.Success("ok")
@@ -181,11 +177,11 @@ func (openapi *Openapi) user(ginCtx *gin.Context) {
 		users, err := dao.New(openapi.storage).SelectUser(param)
 		if err != nil {
 			log.Error("select user error = %v", err)
-			return result.InternalServerErrorFailure("Get User Error!")
+			return result.Failure(result.ErrorUserNotFound, err)
 		}
 		if len(users) == 0 {
 			log.Error("User does not exist : %v", param)
-			return result.Failure("User does not exist!", http.StatusOK)
+			return result.Failure0(result.ErrorUserNotFound)
 		}
 		return result.Success(userVO{
 			Id:        users[0].Id,
@@ -238,7 +234,7 @@ func (openapi *Openapi) users(ginCtx *gin.Context) {
 		users, err := dao.New(openapi.storage).PageSelectUser(pageParam)
 		if err != nil {
 			log.Error("select users error = %v", err)
-			return result.InternalServerErrorFailure("Get Users Error!")
+			return result.Failure(result.ErrorUserNotFound, err)
 		}
 		return result.Success(pageUserVO{
 			page, pageSize, userTransfer(users),

internal/core/plugin/chain.go

@@ -24,6 +24,7 @@ import (
 	"github.com/acmestack/envcd/internal/pkg/context"
 	"github.com/acmestack/envcd/internal/pkg/executor"
 	"github.com/acmestack/envcd/pkg/entity/result"
+	"github.com/acmestack/godkits/gox/errorsx"
 )
 
 // executorArray for sort.Sort(Interface)
@@ -54,7 +55,7 @@ func NewChain(executors executorArray) *Chain {
 //  @param context chain context
 func (chain *Chain) Execute(context *context.Context) *result.EnvcdResult {
 	if chain == nil || chain.executors == nil || len(chain.executors) == 0 {
-		return result.InternalServerErrorFailure("IIllegal state for plugin chain.")
+		return result.InternalFailure(errorsx.Err("IIllegal state for plugin chain."))
 	}
 	if chain.index < len(chain.executors) {
 		currentExecutor := chain.executors[chain.index]

internal/core/plugin/chain_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/acmestack/envcd/internal/pkg/context"
 	"github.com/acmestack/envcd/internal/pkg/executor"
 	"github.com/acmestack/envcd/pkg/entity/result"
+	"github.com/acmestack/godkits/gox/errorsx"
 )
 
 func TestNewChain(t *testing.T) {
@@ -79,7 +80,7 @@ func TestExecutorChain_Execute(t *testing.T) {
 				index:     0,
 			},
 			args:    args{context: &context.Context{}},
-			wantRet: result.InternalServerErrorFailure("IIllegal state for plugin chain."),
+			wantRet: result.InternalFailure(errorsx.Err("IIllegal state for plugin chain.")),
 		},
 		{
 			fields: fields{

pkg/entity/result/envcd_result.go

@@ -18,12 +18,12 @@
 package result
 
 import (
+	"fmt"
 	"net/http"
 )
 
 const (
 	successCode = "success"
-	failureCode = "failure"
 )
 
 var (
@@ -54,32 +54,48 @@ func Success(data interface{}) *EnvcdResult {
 	}
 }
 
-// InternalServerErrorFailure response
-//  @param message of error reason
+// InternalFailure response
 //  @return *EnvcdResult
-func InternalServerErrorFailure(message string) *EnvcdResult {
-	return Failure0(failureCode, message, http.StatusInternalServerError)
+func InternalFailure(err error) *EnvcdResult {
+	return failure(errorEnvcdInternalServerError, err)
+}
+
+// InternalFailure0 response
+//  @return *EnvcdResult
+func InternalFailure0() *EnvcdResult {
+	return failure(errorEnvcdInternalServerError, nil)
 }
 
 // Failure response
-//  @param message of error reason
-//  @param httpStatusCode of response http status code
+//  @param envcdError of envcd error
+//  @param err of handler error
 //  @return *EnvcdResult
-func Failure(message string, httpStatusCode int) *EnvcdResult {
-	return Failure0(failureCode, message, httpStatusCode)
+func Failure(envcdError envcdError, err error) *EnvcdResult {
+	return failure(envcdError, err)
 }
 
 // Failure0 response
-//  @param code of error code
-//  @param message of error reason
-//  @param httpStatusCode of response http status code
+//  @param envcdError of envcd error
 //  @return *EnvcdResult
-func Failure0(code string, message string, httpStatusCode int) *EnvcdResult {
+func Failure0(envcdErr envcdError) *EnvcdResult {
+	return failure(envcdErr, nil)
+}
+
+// failure response, error format: envcd internal error message [code: detail error]
+//  @param envcdError of envcd error
+//  @param err of error instance
+//  @return *EnvcdResult
+func failure(envcdErr envcdError, err error) *EnvcdResult {
+	message := envcdErr.message
+	envcdErr.message = fmt.Sprintf("%s [%s]", message, envcdErr.code)
+	if err != nil && err.Error() != "" {
+		envcdErr.message = fmt.Sprintf("%s [%s: %s]", message, envcdErr.code, err.Error())
+	}
 	return &EnvcdResult{
 		Data: map[string]interface{}{
-			CodeKey:    code,
-			MessageKey: message,
+			CodeKey:    envcdErr.code,
+			MessageKey: envcdErr.message,
 		},
-		HttpStatusCode: httpStatusCode,
+		HttpStatusCode: envcdErr.httpStatusCode,
 	}
 }