Merge branch 'v2.3.0release' into del

pkg/base_info/group_api_struct.go

@@ -203,7 +203,7 @@ type SetGroupInfoReq struct {
 	FaceURL           string `json:"faceURL"`
 	Ex                string `json:"ex"`
 	OperationID       string `json:"operationID" binding:"required"`
-	NeedVerification  *int32 `json:"needVerification" `
+	NeedVerification  *int32 `json:"needVerification"`
 	LookMemberInfo    *int32 `json:"lookMemberInfo"`
 	ApplyMemberFriend *int32 `json:"applyMemberFriend"`
 }

pkg/base_info/third_api_struct.go

@@ -99,3 +99,16 @@ type GetRTCInvitationInfoStartAppReq struct {
 type GetRTCInvitationInfoStartAppResp struct {
 	GetRTCInvitationInfoResp
 }
+
+/**
+ * FCM第三方上报Token
+ */
+type FcmUpdateTokenReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+	Platform    int    `json:"platform" binding:"required,min=1,max=2"` //only for ios + android
+	FcmToken    string `json:"fcmToken" binding:"required"`
+}
+
+type FcmUpdateTokenResp struct {
+	CommResp
+}

pkg/common/config/config.go

@@ -535,7 +535,7 @@ func init() {
 		if err != nil {
 			bytes, err = ioutil.ReadFile(filepath.Join(Root, "config", "config.yaml"))
 			if err != nil {
-				panic(err.Error())
+				panic(err.Error() + " config: " + filepath.Join(cfgName, "config", "config.yaml"))
 			}
 		} else {
 			Root = cfgName
@@ -552,5 +552,4 @@ func init() {
 			panic(err.Error())
 		}
 	}
-
 }

pkg/common/db/RedisModel.go

@@ -185,14 +185,14 @@ func (d *DataBases) GetMessageListBySeq(userID string, seqList []uint32, operati
 		if err != nil {
 			errResult = err
 			failedSeqList = append(failedSeqList, v)
-			log2.NewWarn(operationID, "redis get message error:", err.Error(), v)
+			log2.Debug(operationID, "redis get message error: ", err.Error(), v)
 		} else {
 			msg := pbCommon.MsgData{}
 			err = jsonpb.UnmarshalString(result, &msg)
 			if err != nil {
 				errResult = err
 				failedSeqList = append(failedSeqList, v)
-				log2.NewWarn(operationID, "Unmarshal err", result, err.Error())
+				log2.NewWarn(operationID, "Unmarshal err ", result, err.Error())
 			} else {
 				log2.NewDebug(operationID, "redis get msg is ", msg.String())
 				seqMsg = append(seqMsg, &msg)

pkg/common/token_verify/jwt_token.go

@@ -6,9 +6,10 @@ import (
 	commonDB "Open_IM/pkg/common/db"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/utils"
+	"time"
+
 	go_redis "github.com/go-redis/redis/v8"
 	"github.com/golang-jwt/jwt/v4"
-	"time"
 )
 
 //var (
@@ -27,13 +28,14 @@ type Claims struct {
 
 func BuildClaims(uid, platform string, ttl int64) Claims {
 	now := time.Now()
+	before := now.Add(-time.Minute * 5)
 	return Claims{
 		UID:      uid,
 		Platform: platform,
 		RegisteredClaims: jwt.RegisteredClaims{
 			ExpiresAt: jwt.NewNumericDate(now.Add(time.Duration(ttl*24) * time.Hour)), //Expiration time
 			IssuedAt:  jwt.NewNumericDate(now),                                        //Issuing time
-			NotBefore: jwt.NewNumericDate(now),                                        //Begin Effective time
+			NotBefore: jwt.NewNumericDate(before),                                     //Begin Effective time
 		}}
 }
 
@@ -99,23 +101,22 @@ 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, utils.Wrap(constant.ErrTokenMalformed, "")
 			} else if ve.Errors&jwt.ValidationErrorExpired != 0 {
-				return nil, constant.ErrTokenExpired
+				return nil, utils.Wrap(constant.ErrTokenExpired, "")
 			} else if ve.Errors&jwt.ValidationErrorNotValidYet != 0 {
-				return nil, constant.ErrTokenNotValidYet
+				return nil, utils.Wrap(constant.ErrTokenNotValidYet, "")
 			} else {
-				return nil, constant.ErrTokenUnknown
+				return nil, utils.Wrap(constant.ErrTokenUnknown, "")
 			}
 		} else {
-			return nil, constant.ErrTokenNotValidYet
+			return nil, utils.Wrap(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, utils.Wrap(constant.ErrTokenNotValidYet, "")
 	}
 }
 

pkg/tools/retry/retry.go

@@ -0,0 +1,184 @@
+package retry
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"runtime/debug"
+	"time"
+)
+
+var (
+	ErrorAbort                 = errors.New("stop retry")
+	ErrorTimeout               = errors.New("retry timeout")
+	ErrorContextDeadlineExceed = errors.New("context deadline exceeded")
+	ErrorEmptyRetryFunc        = errors.New("empty retry function")
+	ErrorTimeFormat            = errors.New("time out err")
+)
+
+type RetriesFunc func() error
+type Option func(c *Config)
+type HookFunc func()
+type RetriesChecker func(err error) (needRetry bool)
+type Config struct {
+	MaxRetryTimes int
+	Timeout       time.Duration
+	RetryChecker  RetriesChecker
+	Strategy      Strategy
+	RecoverPanic  bool
+	BeforeTry     HookFunc
+	AfterTry      HookFunc
+}
+
+var (
+	DefaultMaxRetryTimes = 3
+	DefaultTimeout       = time.Minute
+	DefaultInterval      = time.Second * 2
+	DefaultRetryChecker  = func(err error) bool {
+		return !errors.Is(err, ErrorAbort) // not abort error, should continue retry
+	}
+)
+
+func newDefaultConfig() *Config {
+	return &Config{
+		MaxRetryTimes: DefaultMaxRetryTimes,
+		RetryChecker:  DefaultRetryChecker,
+		Timeout:       DefaultTimeout,
+		Strategy:      NewLinear(DefaultInterval),
+		BeforeTry:     func() {},
+		AfterTry:      func() {},
+	}
+}
+
+func WithTimeout(timeout time.Duration) Option {
+	return func(c *Config) {
+		c.Timeout = timeout
+	}
+}
+
+func WithMaxRetryTimes(times int) Option {
+	return func(c *Config) {
+		c.MaxRetryTimes = times
+	}
+}
+
+func WithRecoverPanic() Option {
+	return func(c *Config) {
+		c.RecoverPanic = true
+	}
+}
+
+func WithBeforeHook(hook HookFunc) Option {
+	return func(c *Config) {
+		c.BeforeTry = hook
+	}
+}
+
+func WithAfterHook(hook HookFunc) Option {
+	return func(c *Config) {
+		c.AfterTry = hook
+	}
+}
+
+func WithRetryChecker(checker RetriesChecker) Option {
+	return func(c *Config) {
+		c.RetryChecker = checker
+	}
+}
+
+func WithBackOffStrategy(s BackoffStrategy, duration time.Duration) Option {
+	return func(c *Config) {
+		switch s {
+		case StrategyConstant:
+			c.Strategy = NewConstant(duration)
+		case StrategyLinear:
+			c.Strategy = NewLinear(duration)
+		case StrategyFibonacci:
+			c.Strategy = NewFibonacci(duration)
+		}
+	}
+}
+
+func WithCustomStrategy(s Strategy) Option {
+	return func(c *Config) {
+		c.Strategy = s
+	}
+}
+
+func Do(ctx context.Context, fn RetriesFunc, opts ...Option) error {
+	if fn == nil {
+		return ErrorEmptyRetryFunc
+	}
+	var (
+		abort         = make(chan struct{}, 1) // caller choose to abort retry
+		run           = make(chan error, 1)
+		panicInfoChan = make(chan string, 1)
+
+		timer  *time.Timer
+		runErr error
+	)
+	config := newDefaultConfig()
+	for _, o := range opts {
+		o(config)
+	}
+	if config.Timeout > 0 {
+		timer = time.NewTimer(config.Timeout)
+	} else {
+		return ErrorTimeFormat
+	}
+	go func() {
+		var err error
+		defer func() {
+			if e := recover(); e == nil {
+				return
+			} else {
+				panicInfoChan <- fmt.Sprintf("retry function panic has occured, err=%v, stack:%s", e, string(debug.Stack()))
+			}
+		}()
+		for i := 0; i < config.MaxRetryTimes; i++ {
+			config.BeforeTry()
+			err = fn()
+			config.AfterTry()
+			if err == nil {
+				run <- nil
+				return
+			}
+			// check whether to retry
+			if config.RetryChecker != nil {
+				needRetry := config.RetryChecker(err)
+				if !needRetry {
+					abort <- struct{}{}
+					return
+				}
+			}
+			if config.Strategy != nil {
+				interval := config.Strategy.Sleep(i + 1)
+				<-time.After(interval)
+			}
+		}
+		run <- err
+	}()
+	select {
+	case <-ctx.Done():
+		// context deadline exceed
+		return ErrorContextDeadlineExceed
+	case <-timer.C:
+		// timeout
+		return ErrorTimeout
+	case <-abort:
+		// caller abort
+		return ErrorAbort
+	case msg := <-panicInfoChan:
+		// panic occurred
+		if !config.RecoverPanic {
+			panic(msg)
+		}
+		runErr = fmt.Errorf("panic occurred=%s", msg)
+	case e := <-run:
+		// normal run
+		if e != nil {
+			runErr = fmt.Errorf("retry failed, err=%w", e)
+		}
+	}
+	return runErr
+}

pkg/tools/retry/stratey.go

@@ -0,0 +1,56 @@
+package retry
+
+import "time"
+
+type BackoffStrategy int
+
+const (
+	StrategyConstant BackoffStrategy = iota
+	StrategyLinear
+	StrategyFibonacci
+)
+
+type Strategy interface {
+	Sleep(times int) time.Duration
+}
+type Constant struct {
+	startInterval time.Duration
+}
+
+func NewConstant(d time.Duration) *Constant {
+	return &Constant{startInterval: d}
+}
+
+type Linear struct {
+	startInterval time.Duration
+}
+
+func NewLinear(d time.Duration) *Linear {
+	return &Linear{startInterval: d}
+}
+
+type Fibonacci struct {
+	startInterval time.Duration
+}
+
+func NewFibonacci(d time.Duration) *Fibonacci {
+	return &Fibonacci{startInterval: d}
+}
+
+func (c *Constant) Sleep(_ int) time.Duration {
+	return c.startInterval
+}
+func (l *Linear) Sleep(times int) time.Duration {
+	return l.startInterval * time.Duration(times)
+
+}
+func (f *Fibonacci) Sleep(times int) time.Duration {
+	return f.startInterval * time.Duration(fibonacciNumber(times))
+
+}
+func fibonacciNumber(n int) int {
+	if n == 0 || n == 1 {
+		return n
+	}
+	return fibonacciNumber(n-1) + fibonacciNumber(n-2)
+}