optimization: change the configuration file from being read globally … (#1935)

* optimization: change the configuration file from being read globally to being read independently. * optimization: change the configuration file from being read globally to being read independently. * optimization: change the configuration file from being read globally to being read independently. * optimization: config file changed to dependency injection. * fix: replace global config with dependency injection * fix: replace global config with dependency injection * fix: import the enough param * fix: import the enough param * fix: import the enough param * fix: fix the component check of path * fix: fix the kafka of tls is nil problem * fix: fix the TLS.CACrt is nil error * fix: fix the valiable shadows problem * fix: fix the comflect * optimization: message remove options. * fix: fix the param pass error * fix: find error * fix: find error * fix: find eror * fix: find error * fix: find error * fix: del the undifined func * fix: find error * fix: fix the error * fix: pass config * fix: find error * fix: find error * fix: find error * fix: find error * fix: find error * fix: fix the config * fix: fix the error * fix: fix the config pass error * fix: fix the eror * fix: fix the error * fix: fix the error * fix: fix the error * fix: find error * fix: fix the error * fix: fix the config * fix: add return err * fix: fix the err2 * fix: err * fix: fix the func * fix: del the chinese comment * fix: fix the func * fix: fix the gateway_test logic * fix: s3 * test * test * fix: not found --------- Co-authored-by: luhaoling <2198702716@qq.com> Co-authored-by: withchao <993506633@qq.com>
2026-05-11 20:45:57 +08:00 · 2024-03-05 17:53:22 +08:00
parent efb8310531
commit 383758782e
114 changed files with 1743 additions and 1802 deletions
@@ -38,34 +38,34 @@ const (
 )

 // NewRedis Initialize redis connection.
-func NewRedis() (redis.UniversalClient, error) {
+func NewRedis(config *config.GlobalConfig) (redis.UniversalClient, error) {
 	if redisClient != nil {
 		return redisClient, nil
 	}

 	// Read configuration from environment variables
-	overrideConfigFromEnv()
+	overrideConfigFromEnv(config)

-	if len(config.Config.Redis.Address) == 0 {
-		return nil, errs.Wrap(errors.New("redis address is empty"), "Redis configuration error")
+	if len(config.Redis.Address) == 0 {
+		return nil, errs.Wrap(errors.New("redis address is empty"))
 	}
 	specialerror.AddReplace(redis.Nil, errs.ErrRecordNotFound)
 	var rdb redis.UniversalClient
-	if len(config.Config.Redis.Address) > 1 || config.Config.Redis.ClusterMode {
+	if len(config.Redis.Address) > 1 || config.Redis.ClusterMode {
 		rdb = redis.NewClusterClient(&redis.ClusterOptions{
-			Addrs:      config.Config.Redis.Address,
-			Username:   config.Config.Redis.Username,
-			Password:   config.Config.Redis.Password, // no password set
+			Addrs:      config.Redis.Address,
+			Username:   config.Redis.Username,
+			Password:   config.Redis.Password, // no password set
 			PoolSize:   50,
 			MaxRetries: maxRetry,
 		})
 	} else {
 		rdb = redis.NewClient(&redis.Options{
-			Addr:       config.Config.Redis.Address[0],
-			Username:   config.Config.Redis.Username,
-			Password:   config.Config.Redis.Password, // no password set
-			DB:         0,                            // use default DB
-			PoolSize:   100,                          // connection pool size
+			Addr:       config.Redis.Address[0],
+			Username:   config.Redis.Username,
+			Password:   config.Redis.Password,
+			DB:         0,   // use default DB
+			PoolSize:   100, // connection pool size
 			MaxRetries: maxRetry,
 		})
 	}
@@ -75,33 +75,33 @@ func NewRedis() (redis.UniversalClient, error) {
 	defer cancel()
 	err = rdb.Ping(ctx).Err()
 	if err != nil {
-		uriFormat := "address:%v, username:%s, clusterMode:%t, enablePipeline:%t"
-		errMsg := fmt.Sprintf(uriFormat, config.Config.Redis.Address, config.Config.Redis.Username, config.Config.Redis.ClusterMode, config.Config.Redis.EnablePipeline)
-		return nil, errs.Wrap(err, "Redis connection failed: %s", errMsg)
+		errMsg := fmt.Sprintf("address:%s, username:%s, password:%s, clusterMode:%t, enablePipeline:%t", config.Redis.Address, config.Redis.Username,
+			config.Redis.Password, config.Redis.ClusterMode, config.Redis.EnablePipeline)
+		return nil, errs.Wrap(err, errMsg)
 	}
 	redisClient = rdb
 	return rdb, err
 }

 // overrideConfigFromEnv overrides configuration fields with environment variables if present.
-func overrideConfigFromEnv() {
+func overrideConfigFromEnv(config *config.GlobalConfig) {
 	if envAddr := os.Getenv("REDIS_ADDRESS"); envAddr != "" {
 		if envPort := os.Getenv("REDIS_PORT"); envPort != "" {
 			addresses := strings.Split(envAddr, ",")
 			for i, addr := range addresses {
 				addresses[i] = addr + ":" + envPort
 			}
-			config.Config.Redis.Address = addresses
+			config.Redis.Address = addresses
 		} else {
-			config.Config.Redis.Address = strings.Split(envAddr, ",")
+			config.Redis.Address = strings.Split(envAddr, ",")
 		}
 	}

 	if envUser := os.Getenv("REDIS_USERNAME"); envUser != "" {
-		config.Config.Redis.Username = envUser
+		config.Redis.Username = envUser
 	}

 	if envPass := os.Getenv("REDIS_PASSWORD"); envPass != "" {
-		config.Config.Redis.Password = envPass
+		config.Redis.Password = envPass
 	}
 }
@@ -18,13 +18,16 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"time"

+	"github.com/OpenIMSDK/tools/mw/specialerror"
+
+	"github.com/dtm-labs/rockscache"
+
 	"github.com/OpenIMSDK/tools/errs"
 	"github.com/OpenIMSDK/tools/log"
-	"github.com/OpenIMSDK/tools/mw/specialerror"
 	"github.com/OpenIMSDK/tools/utils"
-	"github.com/dtm-labs/rockscache"
 )

 const (
@@ -128,7 +131,7 @@ func getCache[T any](ctx context.Context, rcClient *rockscache.Client, key strin
 	v, err := rcClient.Fetch2(ctx, key, expire, func() (s string, err error) {
 		t, err = fn(ctx)
 		if err != nil {
-			return "", err
+			return "", errs.Wrap(err)
 		}
 		bs, err := json.Marshal(t)
 		if err != nil {
@@ -139,7 +142,7 @@ func getCache[T any](ctx context.Context, rcClient *rockscache.Client, key strin
 		return string(bs), nil
 	})
 	if err != nil {
-		return t, err
+		return t, errs.Wrap(err)
 	}
 	if write {
 		return t, nil
@@ -149,8 +152,8 @@ func getCache[T any](ctx context.Context, rcClient *rockscache.Client, key strin
 	}
 	err = json.Unmarshal([]byte(v), &t)
 	if err != nil {
-		log.ZError(ctx, "cache json.Unmarshal failed", err, "key", key, "value", v, "expire", expire)
-		return t, errs.Wrap(err, "unmarshal failed")
+		errInfo := fmt.Sprintf("cache json.Unmarshal failed, key:%s, value:%s, expire:%s", key, v, expire)
+		return t, errs.Wrap(err, errInfo)
 	}

 	return t, nil
@@ -203,7 +206,7 @@ func batchGetCache2[T any, K comparable](
 	fns func(ctx context.Context, key K) (T, error),
 ) ([]T, error) {
 	if len(keys) == 0 {
-		return nil, nil
+		return nil, errs.ErrArgs.Wrap("groupID is empty")
 	}
 	res := make([]T, 0, len(keys))
 	for _, key := range keys {
@@ -214,7 +217,7 @@ func batchGetCache2[T any, K comparable](
 			if errs.ErrRecordNotFound.Is(specialerror.ErrCode(errs.Unwrap(err))) {
 				continue
 			}
-			return nil, err
+			return nil, errs.Wrap(err)
 		}
 		res = append(res, val)
 	}
@@ -121,13 +121,14 @@ type MsgModel interface {
 	UnLockMessageTypeKey(ctx context.Context, clientMsgID string, TypeKey string) error
 }

-func NewMsgCacheModel(client redis.UniversalClient) MsgModel {
-	return &msgCache{rdb: client}
+func NewMsgCacheModel(client redis.UniversalClient, config *config.GlobalConfig) MsgModel {
+	return &msgCache{rdb: client, config: config}
 }

 type msgCache struct {
 	metaCache
-	rdb redis.UniversalClient
+	rdb    redis.UniversalClient
+	config *config.GlobalConfig
 }

 func (c *msgCache) getMaxSeqKey(conversationID string) string {
@@ -315,7 +316,7 @@ func (c *msgCache) allMessageCacheKey(conversationID string) string {
 }

 func (c *msgCache) GetMessagesBySeq(ctx context.Context, conversationID string, seqs []int64) (seqMsgs []*sdkws.MsgData, failedSeqs []int64, err error) {
-	if config.Config.Redis.EnablePipeline {
+	if c.config.Redis.EnablePipeline {
 		return c.PipeGetMessagesBySeq(ctx, conversationID, seqs)
 	}

@@ -416,7 +417,7 @@ func (c *msgCache) ParallelGetMessagesBySeq(ctx context.Context, conversationID
 }

 func (c *msgCache) SetMessageToCache(ctx context.Context, conversationID string, msgs []*sdkws.MsgData) (int, error) {
-	if config.Config.Redis.EnablePipeline {
+	if c.config.Redis.EnablePipeline {
 		return c.PipeSetMessageToCache(ctx, conversationID, msgs)
 	}
 	return c.ParallelSetMessageToCache(ctx, conversationID, msgs)
@@ -431,7 +432,7 @@ func (c *msgCache) PipeSetMessageToCache(ctx context.Context, conversationID str
 		}

 		key := c.getMessageCacheKey(conversationID, msg.Seq)
-		_ = pipe.Set(ctx, key, s, time.Duration(config.Config.MsgCacheTimeout)*time.Second)
+		_ = pipe.Set(ctx, key, s, time.Duration(c.config.MsgCacheTimeout)*time.Second)
 	}

 	results, err := pipe.Exec(ctx)
@@ -461,7 +462,7 @@ func (c *msgCache) ParallelSetMessageToCache(ctx context.Context, conversationID
 			}

 			key := c.getMessageCacheKey(conversationID, msg.Seq)
-			if err := c.rdb.Set(ctx, key, s, time.Duration(config.Config.MsgCacheTimeout)*time.Second).Err(); err != nil {
+			if err := c.rdb.Set(ctx, key, s, time.Duration(c.config.MsgCacheTimeout)*time.Second).Err(); err != nil {
 				return errs.Wrap(err)
 			}
 			return nil
@@ -496,10 +497,10 @@ func (c *msgCache) UserDeleteMsgs(ctx context.Context, conversationID string, se
 		if err != nil {
 			return errs.Wrap(err)
 		}
-		if err := c.rdb.Expire(ctx, delUserListKey, time.Duration(config.Config.MsgCacheTimeout)*time.Second).Err(); err != nil {
+		if err := c.rdb.Expire(ctx, delUserListKey, time.Duration(c.config.MsgCacheTimeout)*time.Second).Err(); err != nil {
 			return errs.Wrap(err)
 		}
-		if err := c.rdb.Expire(ctx, userDelListKey, time.Duration(config.Config.MsgCacheTimeout)*time.Second).Err(); err != nil {
+		if err := c.rdb.Expire(ctx, userDelListKey, time.Duration(c.config.MsgCacheTimeout)*time.Second).Err(); err != nil {
 			return errs.Wrap(err)
 		}
 	}
@@ -604,7 +605,7 @@ func (c *msgCache) DelUserDeleteMsgsList(ctx context.Context, conversationID str
 }

 func (c *msgCache) DeleteMessages(ctx context.Context, conversationID string, seqs []int64) error {
-	if config.Config.Redis.EnablePipeline {
+	if c.config.Redis.EnablePipeline {
 		return c.PipeDeleteMessages(ctx, conversationID, seqs)
 	}

@@ -686,7 +687,7 @@ func (c *msgCache) DelMsgFromCache(ctx context.Context, userID string, seqs []in
 		if err != nil {
 			return errs.Wrap(err)
 		}
-		if err := c.rdb.Set(ctx, key, s, time.Duration(config.Config.MsgCacheTimeout)*time.Second).Err(); err != nil {
+		if err := c.rdb.Set(ctx, key, s, time.Duration(c.config.MsgCacheTimeout)*time.Second).Err(); err != nil {
 			return errs.Wrap(err)
 		}
 	}
@@ -22,12 +22,16 @@ import (
 	"strconv"
 	"time"

+	relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+
+	"github.com/OpenIMSDK/tools/log"
+
 	"github.com/OpenIMSDK/protocol/constant"
+
 	"github.com/OpenIMSDK/protocol/user"
 	"github.com/OpenIMSDK/tools/errs"
-	"github.com/OpenIMSDK/tools/log"
+
 	"github.com/dtm-labs/rockscache"
-	relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
 	"github.com/redis/go-redis/v9"
 )

@@ -62,7 +66,11 @@ type UserCacheRedis struct {
 	rcClient   *rockscache.Client
 }

-func NewUserCacheRedis(rdb redis.UniversalClient, userDB relationtb.UserModelInterface, options rockscache.Options) UserCache {
+func NewUserCacheRedis(
+	rdb redis.UniversalClient,
+	userDB relationtb.UserModelInterface,
+	options rockscache.Options,
+) UserCache {
 	rcClient := rockscache.NewClient(rdb, options)

 	return &UserCacheRedis{
@@ -193,13 +201,13 @@ func (u *UserCacheRedis) SetUserStatus(ctx context.Context, userID string, statu
 				Status:      constant.Online,
 				PlatformIDs: []int32{platformID},
 			}
-			jsonData, err2 := json.Marshal(&onlineStatus)
-			if err2 != nil {
-				return errs.Wrap(err2)
+			jsonData, err := json.Marshal(&onlineStatus)
+			if err != nil {
+				return errs.Wrap(err)
 			}
-			_, err2 = u.rdb.HSet(ctx, key, userID, string(jsonData)).Result()
-			if err2 != nil {
-				return errs.Wrap(err2)
+			_, err = u.rdb.HSet(ctx, key, userID, string(jsonData)).Result()
+			if err != nil {
+				return errs.Wrap(err)
 			}
 			u.rdb.Expire(ctx, key, userOlineStatusExpireTime)

@@ -273,9 +281,9 @@ func (u *UserCacheRedis) refreshStatusOffline(ctx context.Context, userID string
 func (u *UserCacheRedis) refreshStatusOnline(ctx context.Context, userID string, platformID int32, isNil bool, err error, result, key string) error {
 	var onlineStatus user.OnlineStatus
 	if !isNil {
-		err2 := json.Unmarshal([]byte(result), &onlineStatus)
-		if err2 != nil {
-			return errs.Wrap(err, "json.Unmarshal failed")
+		err := json.Unmarshal([]byte(result), &onlineStatus)
+		if err != nil {
+			return errs.Wrap(err)
 		}
 		onlineStatus.PlatformIDs = RemoveRepeatedElementsInList(append(onlineStatus.PlatformIDs, platformID))
 	} else {