Error code standardization

install_im_compose.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+internet_ip=`curl ifconfig.me -s`
+echo $internet_ip
+
+source .env
+echo $MINIO_ENDPOINT
+if [ $MINIO_ENDPOINT == "http://127.0.0.1:10005" ]; then
+	sed -i "s/127.0.0.1/${internet_ip}/" .env
+
+fi
+
+cd script ;
+chmod +x *.sh ;
+./init_pwd.sh
+./env_check.sh;
+cd .. ;
+docker-compose -f im-compose.yaml up -d
+docker ps
+
+
+

internal/api/group/group.go

@@ -6,6 +6,7 @@ import (
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/common/trace_log"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	rpc "Open_IM/pkg/proto/group"
 	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
@@ -1020,44 +1021,45 @@ func MuteGroupMember(c *gin.Context) {
 // @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
 // @Router /group/cancel_mute_group_member [post]
 func CancelMuteGroupMember(c *gin.Context) {
+	x := trace_log.NewCtx(c, utils.GetSelfFuncName())
+	defer trace_log.ShowLog(c)
+
 	params := api.CancelMuteGroupMemberReq{}
 	if err := c.BindJSON(&params); err != nil {
-		log.NewError("0", "BindJSON failed ", err.Error())
+		trace_log.WriteErrorResponse(c, err)
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		trace_log.SetContextInfo(c, "BindJSON", err)
 		return
 	}
+	constant.SetContextInfo(c, "BindJSON", nil, "params", params)
 	req := &rpc.CancelMuteGroupMemberReq{}
 	utils.CopyStructFields(req, &params)
 
-	var ok bool
+	var err error
-	var errInfo string
+	err, req.OpUserID, _ = token_verify.ParseUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
-	ok, req.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if err != nil {
-	if !ok {
+		constant.WriteErrorResponse(c, err)
-		errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		constant.SetContextInfo(c, "ParseUserIDFromToken", err)
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
 		return
 	}
+	constant.SetContextInfo(c, "ParseUserIDFromToken", nil, "token", c.Request.Header.Get("token"), "OpUserID", req.OpUserID)
 
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
+	etcdConn, err := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
-
+	if err != nil {
-	etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
+		constant.WriteErrorResponse(c, err)
-	if etcdConn == nil {
+		constant.SetContextInfo(c, "GetDefaultConn", err)
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
 		return
 	}
+
 	client := rpc.NewGroupClient(etcdConn)
-	reply, err := client.CancelMuteGroupMember(context.Background(), req)
+	reply, err := client.CancelMuteGroupMember(x, req)
 	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), " failed ", req.String())
+		constant.WriteErrorResponse(c, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		constant.SetContextInfo(c, "CancelMuteGroupMember", err)
 		return
 	}
 
+	constant.SetContextInfo(c, "CancelMuteGroupMember", nil, "req", req.String(), "resp", reply.String())
 	resp := api.CancelMuteGroupMemberResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
 	c.JSON(http.StatusOK, resp)
 }
 

pkg/common/constant/error.go

@@ -1,63 +1,51 @@
 package constant
 
-import "errors"
-
-// key = errCode, string = errMsg
 type ErrInfo struct {
 	ErrCode int32
 	ErrMsg  string
 }
 
-var (
+func (e ErrInfo) Error() string {
-	OK        = ErrInfo{0, ""}
+	return e.ErrMsg
-	ErrServer = ErrInfo{500, "server error"}
+}
 
-	ErrParseToken = ErrInfo{700, ParseTokenMsg.Error()}
+func (e ErrInfo) Code() int32 {
+	return e.ErrCode
+}
 
-	ErrTencentCredential = ErrInfo{400, ThirdPartyMsg.Error()}
+var (
+	ErrNone           = ErrInfo{0, ""}
+	ErrArgs           = ErrInfo{ArgsError, "ArgsError"}
+	ErrDatabase       = ErrInfo{DatabaseError, "DatabaseError"}
+	ErrInternalServer = ErrInfo{ServerInternalError, "ServerInternalError"}
+	ErrNetwork        = ErrInfo{NetworkError, "NetworkError"}
+	ErrNoPermission   = ErrInfo{NoPermissionError, "NoPermissionError"}
 
-	ErrTokenExpired             = ErrInfo{701, TokenExpiredMsg.Error()}
+	ErrUserIDNotFound  = ErrInfo{UserIDNotFoundError, "UserIDNotFoundError"}
-	ErrTokenInvalid             = ErrInfo{702, TokenInvalidMsg.Error()}
+	ErrGroupIDNotFound = ErrInfo{GroupIDNotFoundError, "GroupIDNotFoundError"}
-	ErrTokenMalformed           = ErrInfo{703, TokenMalformedMsg.Error()}
-	ErrTokenNotValidYet         = ErrInfo{704, TokenNotValidYetMsg.Error()}
-	ErrTokenUnknown             = ErrInfo{705, TokenUnknownMsg.Error()}
-	ErrTokenKicked              = ErrInfo{706, TokenUserKickedMsg.Error()}
-	ErrTokenDifferentPlatformID = ErrInfo{707, TokenDifferentPlatformIDMsg.Error()}
-	ErrTokenDifferentUserID     = ErrInfo{708, TokenDifferentUserIDMsg.Error()}
 
-	ErrAccess                = ErrInfo{ErrCode: 801, ErrMsg: AccessMsg.Error()}
+	ErrRelationshipAlready = ErrInfo{RelationshipAlreadyError, "RelationshipAlreadyError"}
-	ErrDB                    = ErrInfo{ErrCode: 802, ErrMsg: DBMsg.Error()}
+	ErrNotRelationshipYet  = ErrInfo{NotRelationshipYetError, "NotRelationshipYetError"}
-	ErrArgs                  = ErrInfo{ErrCode: 803, ErrMsg: ArgsMsg.Error()}
-	ErrStatus                = ErrInfo{ErrCode: 804, ErrMsg: StatusMsg.Error()}
-	ErrCallback              = ErrInfo{ErrCode: 809, ErrMsg: CallBackMsg.Error()}
-	ErrSendLimit             = ErrInfo{ErrCode: 810, ErrMsg: "send msg limit, to many request, try again later"}
-	ErrMessageHasReadDisable = ErrInfo{ErrCode: 811, ErrMsg: "message has read disable"}
-	ErrInternal              = ErrInfo{ErrCode: 812, ErrMsg: "internal error"}
-	ErrWsConnNotExist        = ErrInfo{ErrCode: 813, ErrMsg: "ws conn not exist"}
-)
 
-var (
+	ErrOnlyOneOwner        = ErrInfo{OnlyOneOwnerError, "OnlyOneOwnerError"}
-	ParseTokenMsg               = errors.New("parse token failed")
+	ErrInGroupAlready      = ErrInfo{InGroupAlreadyError, "InGroupAlreadyError"}
-	TokenExpiredMsg             = errors.New("token is timed out, please log in again")
+	ErrNotInGroupYet       = ErrInfo{NotInGroupYetError, "NotInGroupYetError"}
-	TokenInvalidMsg             = errors.New("token has been invalidated")
+	ErrDismissedAlready    = ErrInfo{DismissedAlreadyError, "DismissedAlreadyError"}
-	TokenNotValidYetMsg         = errors.New("token not active yet")
+	ErrOwnerNotAllowedQuit = ErrInfo{OwnerNotAllowedQuitError, "OwnerNotAllowedQuitError"}
-	TokenMalformedMsg           = errors.New("that's not even a token")
+	ErrRegisteredAlready   = ErrInfo{RegisteredAlreadyError, "RegisteredAlreadyError"}
-	TokenUnknownMsg             = errors.New("couldn't handle this token")
-	TokenUserKickedMsg          = errors.New("user has been kicked")
-	TokenDifferentPlatformIDMsg = errors.New("different platformID")
-	TokenDifferentUserIDMsg     = errors.New("different userID")
-	AccessMsg                   = errors.New("no permission")
-	StatusMsg                   = errors.New("status is abnormal")
-	DBMsg                       = errors.New("db failed")
-	ArgsMsg                     = errors.New("args failed")
-	CallBackMsg                 = errors.New("callback failed")
-	InvitationMsg               = errors.New("invitationCode error")
 
-	ThirdPartyMsg = errors.New("third party error")
+	ErrTokenExpired             = ErrInfo{TokenExpiredError, "TokenExpiredError"}
+	ErrTokenInvalid             = ErrInfo{TokenInvalidError, "TokenInvalidError"}         //
+	ErrTokenMalformed           = ErrInfo{TokenMalformedError, "TokenMalformedError"}     //格式错误
+	ErrTokenNotValidYet         = ErrInfo{TokenNotValidYetError, "TokenNotValidYetError"} //还未生效
+	ErrTokenUnknown             = ErrInfo{TokenUnknownError, "TokenUnknownError"}         //未知错误
+	ErrTokenKicked              = ErrInfo{TokenKickedError, "TokenKickedError"}
+	ErrTokenNotExist            = ErrInfo{TokenNotExistError, "TokenNotExistError"} //在redis中不存在
+	ErrTokenDifferentPlatformID = ErrInfo{TokenDifferentPlatformIDError, "TokenDifferentPlatformIDError"}
+	ErrTokenDifferentUserID     = ErrInfo{TokenDifferentUserIDError, "TokenDifferentUserIDError"}
 )
 
 const (
-	NoError              = 0
 	FormattingError      = 10001
 	HasRegistered        = 10002
 	NotRegistered        = 10003
@@ -72,17 +60,53 @@ const (
 	RegisterLimit        = 10012
 	LoginLimit           = 10013
 	InvitationError      = 10014
-	DatabaseError        = 10002
-	ServerError          = 10004
-	HttpError            = 10005
-	IoError              = 10006
-	IntentionalError     = 10007
 )
 
-func (e ErrInfo) Error() string {
+// 通用错误码
-	return e.ErrMsg
+const (
-}
+	NoError             = 0     //无错误
+	ArgsError           = 90001 //输入参数错误
+	DatabaseError       = 90002 //redis/mysql等db错误
+	ServerInternalError = 90003 //服务器内部错误
+	NetworkError        = 90004 //网络错误
+	NoPermissionError   = 90005 //权限不足
+)
 
-func (e *ErrInfo) Code() int32 {
+// 账号错误码
-	return e.ErrCode
+const (
-}
+	UserIDNotFoundError  = 91001 //UserID不存在 或未注册
+	GroupIDNotFoundError = 91002 //GroupID不存在
+)
+
+// 关系链错误码
+const (
+	RelationshipAlreadyError = 92001 //已经是好友关系（或者黑名单）
+	NotRelationshipYetError  = 92002 //不是好友关系（或者黑名单）
+)
+
+// 群组错误码
+const (
+	OnlyOneOwnerError        = 93001 //只能有一个群主
+	InGroupAlreadyError      = 93003 //已在群组中
+	NotInGroupYetError       = 93004 //不在群组中
+	DismissedAlreadyError    = 93004 //群组已经解散
+	OwnerNotAllowedQuitError = 93004 //群主不能退群
+)
+
+// 用户错误码
+const (
+	RegisteredAlreadyError = 94001 //用户已经注册过了
+)
+
+// token错误码
+const (
+	TokenExpiredError             = 95001
+	TokenInvalidError             = 95002
+	TokenMalformedError           = 95003
+	TokenNotValidYetError         = 95004
+	TokenUnknownError             = 95005
+	TokenKickedError              = 95006
+	TokenDifferentPlatformIDError = 95007
+	TokenDifferentUserIDError     = 95008
+	TokenNotExistError            = 95009
+)

pkg/common/token_verify/jwt_token.go

@@ -110,13 +110,13 @@ func GetClaimFromToken(tokensString string) (*Claims, error) {
 				return nil, utils.Wrap(constant.ErrTokenUnknown, "")
 			}
 		} else {
-			return nil, utils.Wrap(constant.ErrTokenNotValidYet, "")
+			return nil, utils.Wrap(constant.ErrTokenUnknown, "")
 		}
 	} else {
 		if claims, ok := token.Claims.(*Claims); ok && token.Valid {
 			return claims, nil
 		}
-		return nil, utils.Wrap(constant.ErrTokenNotValidYet, "")
+		return nil, utils.Wrap(constant.ErrTokenUnknown, "")
 	}
 }
 
@@ -159,6 +159,16 @@ func GetUserIDFromToken(token string, operationID string) (bool, string, string)
 	return true, claims.UID, ""
 }
 
+func ParseUserIDFromToken(token string, operationID string) (error, string, string) {
+	claims, err := ParseToken(token, operationID)
+	if err != nil {
+		log.Error(operationID, "ParseToken failed, ", err.Error(), token)
+		return err, "", err.Error()
+	}
+	log.Debug(operationID, "token claims.ExpiresAt.Second() ", claims.ExpiresAt.Unix())
+	return nil, claims.UID, ""
+}
+
 func GetUserIDFromTokenExpireTime(token string, operationID string) (bool, string, string, int64) {
 	claims, err := ParseToken(token, operationID)
 	if err != nil {
@@ -184,12 +194,12 @@ func ParseToken(tokensString, operationID string) (claims *Claims, err error) {
 
 	m, err := commonDB.DB.GetTokenMapByUidPid(claims.UID, claims.Platform)
 	if err != nil {
-		log.NewError(operationID, "get token from redis err", err.Error(), tokensString)
+		log.NewError(operationID, "get token from redis err", err.Error(), claims.UID, claims.Platform)
-		return nil, utils.Wrap(constant.ErrTokenInvalid, "get token from redis err")
+		return nil, utils.Wrap(constant.ErrTokenNotExist, "get token from redis err")
 	}
 	if m == nil {
-		log.NewError(operationID, "get token from redis err, not in redis ", "m is nil", tokensString)
+		log.NewError(operationID, "get token from redis err, not in redis ", "m is nil ", claims.UID, claims.Platform)
-		return nil, utils.Wrap(constant.ErrTokenInvalid, "get token from redis err")
+		return nil, utils.Wrap(constant.ErrTokenNotExist, "get token from redis err")
 	}
 	if v, ok := m[tokensString]; ok {
 		switch v {
@@ -203,8 +213,8 @@ func ParseToken(tokensString, operationID string) (claims *Claims, err error) {
 			return nil, utils.Wrap(constant.ErrTokenUnknown, "")
 		}
 	}
-	log.NewError(operationID, "redis token map not find", constant.ErrTokenUnknown)
+	log.NewError(operationID, "redis token map not find ", constant.ErrTokenNotExist, tokensString)
-	return nil, utils.Wrap(constant.ErrTokenUnknown, "redis token map not find")
+	return nil, utils.Wrap(constant.ErrTokenNotExist, "redis token map not find")
 }
 
 //func MakeTheTokenInvalid(currentClaims *Claims, platformClass string) (bool, error) {
@@ -227,7 +237,7 @@ func ParseRedisInterfaceToken(redisToken interface{}) (*Claims, error) {
 	return GetClaimFromToken(string(redisToken.([]uint8)))
 }
 
-//Validation token, false means failure, true means successful verification
+// Validation token, false means failure, true means successful verification
 func VerifyToken(token, uid string) (bool, error) {
 	claims, err := ParseToken(token, "")
 	if err != nil {

pkg/common/trace_log/ctx.go

@@ -0,0 +1,77 @@
+package trace_log
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"context"
+	"errors"
+	"fmt"
+	"github.com/gin-gonic/gin"
+)
+
+const TraceLogKey = "trace_log"
+const GinContextKey = "gin_context"
+
+func ToErrInfoWithErr(errCode int32, errMsg string) *ErrInfo {
+	return nil
+}
+
+func getAPIErrorResponse(c *gin.Context, errInfo ErrInfo) {
+
+}
+
+func NewCtx(c *gin.Context, api string) context.Context {
+	req := ApiInfo{ApiName: api}
+	return context.WithValue(c, GinContextKey, req)
+}
+
+func ShowLog(ctx context.Context) {
+	t := ctx.Value(TraceLogKey).(ApiInfo)
+	log.Info(t.OperationID, "api: ", t.ApiName)
+	for _, v := range t.Funcs {
+		if v.Err != nil {
+			log.Error(v.FuncName, v.Err, v.Args)
+		} else {
+			log.Info(v.FuncName, v.Err, v.Args)
+		}
+	}
+
+}
+
+func WriteErrorResponse(c *gin.Context, err error) {
+	e := new(constant.ErrInfo)
+	if errors.As(err, &e) {
+
+	}
+}
+
+type FuncInfo struct {
+	FuncName string
+	Args     map[string]interface{}
+	Err      error
+}
+
+type ApiInfo struct {
+	ApiName     string
+	OperationID string
+	Funcs       []FuncInfo
+}
+
+func SetContextInfo(ctx context.Context, funcName string, err error, args ...interface{}) {
+	var req ReqInfo
+	t := ctx.Value("f").([]ReqInfo)
+	argsHandle(args, req.Args)
+	req.FuncName = funcName
+	req.Err = err
+	t = append(t, req)
+}
+
+func argsHandle(args []interface{}, fields map[string]interface{}) {
+	for i := 0; i < len(args); i += 2 {
+		if i+1 < len(args) {
+			fields[fmt.Sprintf("%v", args[i])] = args[i+1]
+		} else {
+			fields[fmt.Sprintf("%v", args[i])] = ""
+		}
+	}
+}

pkg/grpc-etcdv3/getcdv3/resolver.go

@@ -175,14 +175,14 @@ func GetConfigConn(serviceName string, operationID string) *grpc.ClientConn {
 	return conn
 }
 
-func GetDefaultConn(schema, etcdaddr, serviceName string, operationID string) *grpc.ClientConn {
+func GetDefaultConn(schema, etcdaddr, serviceName string, operationID string) (*grpc.ClientConn, error) {
 	con := getConn(schema, etcdaddr, serviceName, operationID)
 	if con != nil {
-		return con
+		return con, nil
 	}
 	log.NewWarn(operationID, utils.GetSelfFuncName(), "conn is nil !!!!!", schema, etcdaddr, serviceName, operationID)
 	con = GetConfigConn(serviceName, operationID)
-	return con
+	return con, nil
 }
 
 func (r *Resolver) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) {