Merge branch 'superGroup' of github.com:OpenIMSDK/Open-IM-Server into superGroup

docker-compose.yaml

@@ -20,6 +20,7 @@ services:
     ports:
       - 37017:27017
     container_name: mongo
+    command: --wiredTigerCacheSizeGB 5
     volumes:
       - ./components/mongodb/data/db:/data/db
       - ./components/mongodb/data/logs:/data/logs

internal/msg_gateway/gate/ws_server.go

@@ -10,7 +10,9 @@ import (
 	"bytes"
 	"encoding/gob"
 	go_redis "github.com/go-redis/redis/v8"
-	"gopkg.in/errgo.v2/errors"
+	"github.com/pkg/errors"
+
+	//"gopkg.in/errgo.v2/errors"
 	"net/http"
 	"sync"
 	"time"
@@ -290,25 +292,50 @@ func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request, operation
 	query := r.URL.Query()
 	if len(query["token"]) != 0 && len(query["sendID"]) != 0 && len(query["platformID"]) != 0 {
 		if ok, err, msg := token_verify.WsVerifyToken(query["token"][0], query["sendID"][0], query["platformID"][0], operationID); !ok {
-			switch errors.Cause(err) {
+			if errors.Is(err, constant.ErrTokenExpired) {
-			case constant.ErrTokenExpired:
 				status = int(constant.ErrTokenExpired.ErrCode)
-			case constant.ErrTokenInvalid:
+			}
+			if errors.Is(err, constant.ErrTokenInvalid) {
 				status = int(constant.ErrTokenInvalid.ErrCode)
-			case constant.ErrTokenMalformed:
+			}
+			if errors.Is(err, constant.ErrTokenMalformed) {
 				status = int(constant.ErrTokenMalformed.ErrCode)
-			case constant.ErrTokenNotValidYet:
+			}
+			if errors.Is(err, constant.ErrTokenNotValidYet) {
 				status = int(constant.ErrTokenNotValidYet.ErrCode)
-			case constant.ErrTokenUnknown:
+			}
+			if errors.Is(err, constant.ErrTokenUnknown) {
 				status = int(constant.ErrTokenUnknown.ErrCode)
-			case constant.ErrTokenKicked:
+			}
+			if errors.Is(err, constant.ErrTokenKicked) {
 				status = int(constant.ErrTokenKicked.ErrCode)
-			case constant.ErrTokenDifferentPlatformID:
+			}
+			if errors.Is(err, constant.ErrTokenDifferentPlatformID) {
 				status = int(constant.ErrTokenDifferentPlatformID.ErrCode)
-			case constant.ErrTokenDifferentUserID:
+			}
+			if errors.Is(err, constant.ErrTokenDifferentUserID) {
 				status = int(constant.ErrTokenDifferentUserID.ErrCode)
 			}
-			log.Error(operationID, "Token verify failed ", "query ", query, msg, err.Error())
+			//switch errors.Cause(err) {
+			//case constant.ErrTokenExpired:
+			//	status = int(constant.ErrTokenExpired.ErrCode)
+			//case constant.ErrTokenInvalid:
+			//	status = int(constant.ErrTokenInvalid.ErrCode)
+			//case constant.ErrTokenMalformed:
+			//	status = int(constant.ErrTokenMalformed.ErrCode)
+			//case constant.ErrTokenNotValidYet:
+			//	status = int(constant.ErrTokenNotValidYet.ErrCode)
+			//case constant.ErrTokenUnknown:
+			//	status = int(constant.ErrTokenUnknown.ErrCode)
+			//case constant.ErrTokenKicked:
+			//	status = int(constant.ErrTokenKicked.ErrCode)
+			//case constant.ErrTokenDifferentPlatformID:
+			//	status = int(constant.ErrTokenDifferentPlatformID.ErrCode)
+			//case constant.ErrTokenDifferentUserID:
+			//	status = int(constant.ErrTokenDifferentUserID.ErrCode)
+			//}
+
+			log.Error(operationID, "Token verify failed ", "query ", query, msg, err.Error(), "status: ", status)
 			w.Header().Set("Sec-Websocket-Version", "13")
 			w.Header().Set("ws_err_msg", err.Error())
 			http.Error(w, err.Error(), status)

pkg/common/constant/error.go

@@ -12,36 +12,10 @@ var (
 	OK        = ErrInfo{0, ""}
 	ErrServer = ErrInfo{500, "server error"}
 
-	//	ErrMysql             = ErrInfo{100, ""}
-	//	ErrMongo             = ErrInfo{110, ""}
-	//	ErrRedis             = ErrInfo{120, ""}
 	ErrParseToken = ErrInfo{700, ParseTokenMsg.Error()}
-	//	ErrCreateToken       = ErrInfo{201, "Create token failed"}
+
-	//	ErrAppServerKey      = ErrInfo{300, "key error"}
 	ErrTencentCredential = ErrInfo{400, ThirdPartyMsg.Error()}
 
-	//	ErrorUserRegister             = ErrInfo{600, "User registration failed"}
-	//	ErrAccountExists              = ErrInfo{601, "The account is already registered and cannot be registered again"}
-	//	ErrUserPassword               = ErrInfo{602, "User password error"}
-	//	ErrRefreshToken               = ErrInfo{605, "Failed to refresh token"}
-	//	ErrAddFriend                  = ErrInfo{606, "Failed to add friends"}
-	//	ErrAgreeToAddFriend           = ErrInfo{607, "Failed to agree application"}
-	//	ErrAddFriendToBlack           = ErrInfo{608, "Failed to add friends to the blacklist"}
-	//	ErrGetBlackList               = ErrInfo{609, "Failed to get blacklist"}
-	//	ErrDeleteFriend               = ErrInfo{610, "Failed to delete friend"}
-	//	ErrGetFriendApplyList         = ErrInfo{611, "Failed to get friend application list"}
-	//	ErrGetFriendList              = ErrInfo{612, "Failed to get friend list"}
-	//	ErrRemoveBlackList            = ErrInfo{613, "Failed to remove blacklist"}
-	//	ErrSearchUserInfo             = ErrInfo{614, "Can't find the user information"}
-	//	ErrDelAppleDeviceToken        = ErrInfo{615, ""}
-	//	ErrModifyUserInfo             = ErrInfo{616, "update user some attribute failed"}
-	//	ErrSetFriendComment           = ErrInfo{617, "set friend comment failed"}
-	//	ErrSearchUserInfoFromTheGroup = ErrInfo{618, "There is no such group or the user not in the group"}
-	//	ErrCreateGroup                = ErrInfo{619, "create group chat failed"}
-	//	ErrJoinGroupApplication       = ErrInfo{620, "Failed to apply to join the group"}
-	//	ErrQuitGroup                  = ErrInfo{621, "Failed to quit the group"}
-	//	ErrSetGroupInfo               = ErrInfo{622, "Failed to set group info"}
-	//	ErrParam                      = ErrInfo{700, "param failed"}
 	ErrTokenExpired             = ErrInfo{701, TokenExpiredMsg.Error()}
 	ErrTokenInvalid             = ErrInfo{702, TokenInvalidMsg.Error()}
 	ErrTokenMalformed           = ErrInfo{703, TokenMalformedMsg.Error()}

pkg/common/db/newRedisModel.go

@@ -95,7 +95,11 @@ func (d *DataBases) GetTokenMapByUidPid(userID, platformID string) (map[string]i
 }
 func (d *DataBases) SetTokenMapByUidPid(userID string, platformID int, m map[string]int) error {
 	key := uidPidToken + userID + ":" + constant.PlatformIDToName(platformID)
-	return d.rdb.HMSet(context.Background(), key, m).Err()
+	mm := make(map[string]interface{})
+	for k, v := range m {
+		mm[k] = v
+	}
+	return d.rdb.HSet(context.Background(), key, mm).Err()
 }
 func (d *DataBases) DeleteTokenByUidPid(userID string, platformID int, fields []string) error {
 	key := uidPidToken + userID + ":" + constant.PlatformIDToName(platformID)

pkg/common/db/redisModel_test.go

@@ -16,7 +16,8 @@ func Test_SetTokenMapByUidPid(t *testing.T) {
 	m["test1"] = 1
 	m["test2"] = 2
 	m["2332"] = 4
-	_ = DB.SetTokenMapByUidPid("1234", 2, m)
+	err := DB.SetTokenMapByUidPid("1234", 2, m)
+	assert.Nil(t, err)
 
 }
 func Test_GetTokenMapByUidPid(t *testing.T) {

pkg/common/token_verify/jwt_token.go

@@ -99,23 +99,23 @@ func GetClaimFromToken(tokensString string) (*Claims, error) {
 	if err != nil {
 		if ve, ok := err.(*jwt.ValidationError); ok {
 			if ve.Errors&jwt.ValidationErrorMalformed != 0 {
-				return nil, &constant.ErrTokenMalformed
+				return nil, constant.ErrTokenMalformed
 			} else if ve.Errors&jwt.ValidationErrorExpired != 0 {
-				return nil, &constant.ErrTokenExpired
+				return nil, constant.ErrTokenExpired
 			} else if ve.Errors&jwt.ValidationErrorNotValidYet != 0 {
-				return nil, &constant.ErrTokenNotValidYet
+				return nil, constant.ErrTokenNotValidYet
 			} else {
-				return nil, &constant.ErrTokenUnknown
+				return nil, constant.ErrTokenUnknown
 			}
 		} else {
-			return nil, &constant.ErrTokenNotValidYet
+			return nil, constant.ErrTokenNotValidYet
 		}
 	} else {
 		if claims, ok := token.Claims.(*Claims); ok && token.Valid {
 			//log.NewDebug("", claims.UID, claims.Platform)
 			return claims, nil
 		}
-		return nil, &constant.ErrTokenNotValidYet
+		return nil, constant.ErrTokenNotValidYet
 	}
 }
 
@@ -178,18 +178,30 @@ func ParseTokenGetUserID(token string, operationID string) (error, string) {
 func ParseToken(tokensString, operationID string) (claims *Claims, err error) {
 	claims, err = GetClaimFromToken(tokensString)
 	if err != nil {
-		log.NewError(operationID, "token validate err", err.Error(), tokensString)
+		//if errors.Is(err, constant.ErrTokenUnknown) {
+		//	errMsg := "GetClaimFromToken failed ErrTokenUnknown   " + err.Error()
+		//	log.Error(operationID, errMsg)
+		//}
+		//info := err.(constant.ErrInfo)
+		//log.Error(operationID, "detail info , ", info.ErrCode, info.ErrMsg)
+		//
+		//e := errors.Unwrap(err)
+		//if errors.Is(e, constant.ErrTokenUnknown) {
+		//	errMsg := "ParseToken failed ErrTokenUnknown " + e.Error()
+		//	log.Error(operationID, errMsg)
+		//}
+
 		return nil, utils.Wrap(err, "")
 	}
 
 	m, err := commonDB.DB.GetTokenMapByUidPid(claims.UID, claims.Platform)
 	if err != nil {
 		log.NewError(operationID, "get token from redis err", err.Error(), tokensString)
-		return nil, utils.Wrap(&constant.ErrTokenInvalid, "get token from redis err")
+		return nil, utils.Wrap(constant.ErrTokenInvalid, "get token from redis err")
 	}
 	if m == nil {
 		log.NewError(operationID, "get token from redis err, not in redis ", "m is nil", tokensString)
-		return nil, utils.Wrap(&constant.ErrTokenInvalid, "get token from redis err")
+		return nil, utils.Wrap(constant.ErrTokenInvalid, "get token from redis err")
 	}
 	if v, ok := m[tokensString]; ok {
 		switch v {
@@ -198,13 +210,13 @@ func ParseToken(tokensString, operationID string) (claims *Claims, err error) {
 			return claims, nil
 		case constant.KickedToken:
 			log.Error(operationID, "this token has been kicked by other same terminal ", constant.ErrTokenKicked)
-			return nil, utils.Wrap(&constant.ErrTokenKicked, "this token has been kicked by other same terminal ")
+			return nil, utils.Wrap(constant.ErrTokenKicked, "this token has been kicked by other same terminal ")
 		default:
-			return nil, utils.Wrap(&constant.ErrTokenUnknown, "")
+			return nil, utils.Wrap(constant.ErrTokenUnknown, "")
 		}
 	}
 	log.NewError(operationID, "redis token map not find", constant.ErrTokenUnknown)
-	return nil, utils.Wrap(&constant.ErrTokenUnknown, "redis token map not find")
+	return nil, utils.Wrap(constant.ErrTokenUnknown, "redis token map not find")
 }
 
 //func MakeTheTokenInvalid(currentClaims *Claims, platformClass string) (bool, error) {
@@ -242,19 +254,29 @@ func VerifyToken(token, uid string) (bool, error) {
 }
 
 func WsVerifyToken(token, uid string, platformID string, operationID string) (bool, error, string) {
-	argMsg := "token: " + token + " operationID: " + operationID + " userID: " + uid + " platformID: " + platformID
+	argMsg := "args: token: " + token + " operationID: " + operationID + " userID: " + uid + " platformID: " + constant.PlatformIDToName(utils.StringToInt(platformID))
 	claims, err := ParseToken(token, operationID)
 	if err != nil {
+		//if errors.Is(err, constant.ErrTokenUnknown) {
+		//	errMsg := "ParseToken failed ErrTokenUnknown " + err.Error()
+		//	log.Error(operationID, errMsg)
+		//}
+		//e := errors.Unwrap(err)
+		//if errors.Is(e, constant.ErrTokenUnknown) {
+		//	errMsg := "ParseToken failed ErrTokenUnknown " + e.Error()
+		//	log.Error(operationID, errMsg)
+		//}
+
 		errMsg := "parse token err " + err.Error() + argMsg
 		return false, utils.Wrap(err, errMsg), errMsg
 	}
 	if claims.UID != uid {
-		errMsg := " uid is not same to token uid " + " claims.UID " + claims.UID + argMsg
+		errMsg := " uid is not same to token uid " + argMsg + " claims.UID: " + claims.UID
-		return false, utils.Wrap(&constant.ErrTokenDifferentUserID, errMsg), errMsg
+		return false, utils.Wrap(constant.ErrTokenDifferentUserID, errMsg), errMsg
 	}
 	if claims.Platform != constant.PlatformIDToName(utils.StringToInt(platformID)) {
-		errMsg := " platform is not same to token platform " + argMsg + "claims platformID " + claims.Platform
+		errMsg := " platform is not same to token platform " + argMsg + " claims platformID: " + claims.Platform
-		return false, utils.Wrap(&constant.ErrTokenDifferentPlatformID, errMsg), errMsg
+		return false, utils.Wrap(constant.ErrTokenDifferentPlatformID, errMsg), errMsg
 	}
 	log.NewDebug(operationID, utils.GetSelfFuncName(), " check ok ", claims.UID, uid, claims.Platform)
 	return true, nil, ""