check login

pkg/common/db/RedisModel.go

@@ -182,7 +182,6 @@ func (d *DataBases) GetMessageListBySeq(userID string, seqList []uint32, operati
 	for _, v := range seqList {
 		//MESSAGE_CACHE:169.254.225.224_reliability1653387820_0_1
 		key := messageCache + userID + "_" + strconv.Itoa(int(v))
-
 		result, err := d.RDB.Get(context.Background(), key).Result()
 		if err != nil {
 			errResult = err
@@ -205,7 +204,7 @@ func (d *DataBases) GetMessageListBySeq(userID string, seqList []uint32, operati
 	return seqMsg, failedSeqList, errResult
 }
 
-func (d *DataBases) SetMessageToCache(msgList []*pbChat.MsgDataToMQ, uid string, operationID string) error {
+func (d *DataBases) SetMessageToCache(msgList []*pbChat.MsgDataToMQ, uid string, operationID string) (error, int) {
 	ctx := context.Background()
 	pipe := d.RDB.Pipeline()
 	var failedList []pbChat.MsgDataToMQ
@@ -225,10 +224,10 @@ func (d *DataBases) SetMessageToCache(msgList []*pbChat.MsgDataToMQ, uid string,
 		}
 	}
 	if len(failedList) != 0 {
-		return errors.New(fmt.Sprintf("set msg to cache failed, failed lists: %q,%s", failedList, operationID))
+		return errors.New(fmt.Sprintf("set msg to cache failed, failed lists: %q,%s", failedList, operationID)), len(failedList)
 	}
 	_, err := pipe.Exec(ctx)
-	return err
+	return err, 0
 }
 func (d *DataBases) DeleteMessageFromCache(msgList []*pbChat.MsgDataToMQ, uid string, operationID string) error {
 	ctx := context.Background()

pkg/common/db/batch_insert_chat.go

@@ -4,6 +4,7 @@ import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
+	promePkg "Open_IM/pkg/common/prometheus"
 	pbMsg "Open_IM/pkg/proto/msg"
 	"Open_IM/pkg/utils"
 	"context"
@@ -14,10 +15,6 @@ import (
 	"go.mongodb.org/mongo-driver/mongo"
 )
 
-func (d *DataBases) BatchDeleteChat2DB(userID string, msgList []*pbMsg.MsgDataToMQ, operationID string) {
-
-}
-
 func (d *DataBases) BatchInsertChat2DB(userID string, msgList []*pbMsg.MsgDataToMQ, operationID string, currentMaxSeq uint64) error {
 	newTime := getCurrentTimestampByMill()
 	if len(msgList) > GetSingleGocMsgNum() {
@@ -85,10 +82,13 @@ func (d *DataBases) BatchInsertChat2DB(userID string, msgList []*pbMsg.MsgDataTo
 				sChat.Msg = msgListToMongo
 				log.NewDebug(operationID, "filter ", seqUid, "list ", msgListToMongo)
 				if _, err = c.InsertOne(ctx, &sChat); err != nil {
+					promePkg.PromeInc(promePkg.MsgInsertMongoFailedCounter)
 					log.NewError(operationID, "InsertOne failed", filter, err.Error(), sChat)
 					return utils.Wrap(err, "")
 				}
+				promePkg.PromeInc(promePkg.MsgInsertMongoSuccessCounter)
 			} else {
+				promePkg.PromeInc(promePkg.MsgInsertMongoFailedCounter)
 				log.Error(operationID, "FindOneAndUpdate failed ", err.Error(), filter)
 				return utils.Wrap(err, "")
 			}
@@ -101,9 +101,11 @@ func (d *DataBases) BatchInsertChat2DB(userID string, msgList []*pbMsg.MsgDataTo
 		sChat.Msg = msgListToMongoNext
 		log.NewDebug(operationID, "filter ", seqUidNext, "list ", msgListToMongoNext, "userID: ", userID)
 		if _, err = c.InsertOne(ctx, &sChat); err != nil {
+			promePkg.PromeInc(promePkg.MsgInsertMongoFailedCounter)
 			log.NewError(operationID, "InsertOne failed", filter, err.Error(), sChat)
 			return utils.Wrap(err, "")
 		}
+		promePkg.PromeInc(promePkg.MsgInsertMongoSuccessCounter)
 	}
 	log.Debug(operationID, "batch mgo  cost time ", getCurrentTimestampByMill()-newTime, userID, len(msgList))
 	return nil
@@ -129,8 +131,10 @@ func (d *DataBases) BatchInsertChat2Cache(insertID string, msgList []*pbMsg.MsgD
 		log.Debug(operationID, "constant.SingleChatType  lastMaxSeq before add ", currentMaxSeq, "userID ", insertID, err)
 	}
 	if err != nil && err != go_redis.Nil {
+		promePkg.PromeInc(promePkg.SeqGetFailedCounter)
 		return utils.Wrap(err, ""), 0
 	}
+	promePkg.PromeInc(promePkg.SeqGetSuccessCounter)
 
 	lastMaxSeq := currentMaxSeq
 	for _, m := range msgList {
@@ -142,9 +146,12 @@ func (d *DataBases) BatchInsertChat2Cache(insertID string, msgList []*pbMsg.MsgD
 		log.Debug(operationID, "cache msg node ", m.String(), m.MsgData.ClientMsgID, "userID: ", insertID, "seq: ", currentMaxSeq)
 	}
 	log.Debug(operationID, "SetMessageToCache ", insertID, len(msgList))
-	err = d.SetMessageToCache(msgList, insertID, operationID)
+	err, failedNum := d.SetMessageToCache(msgList, insertID, operationID)
 	if err != nil {
+		promePkg.PromeAdd(promePkg.MsgInsertRedisFailedCounter, failedNum)
 		log.Error(operationID, "setMessageToCache failed, continue ", err.Error(), len(msgList), insertID)
+	} else {
+		promePkg.PromeInc(promePkg.MsgInsertRedisSuccessCounter)
 	}
 	log.Debug(operationID, "batch to redis  cost time ", getCurrentTimestampByMill()-newTime, insertID, len(msgList))
 	if msgList[0].MsgData.SessionType == constant.SuperGroupChatType {
@@ -152,6 +159,11 @@ func (d *DataBases) BatchInsertChat2Cache(insertID string, msgList []*pbMsg.MsgD
 	} else {
 		err = d.SetUserMaxSeq(insertID, currentMaxSeq)
 	}
+	if err != nil {
+		promePkg.PromeInc(promePkg.SeqSetFailedCounter)
+	} else {
+		promePkg.PromeInc(promePkg.SeqSetSuccessCounter)
+	}
 	return utils.Wrap(err, ""), lastMaxSeq
 }
 
@@ -171,106 +183,100 @@ func (d *DataBases) BatchInsertChat2Cache(insertID string, msgList []*pbMsg.MsgD
 //	}
 //	return nil, lastMaxSeq
 //}
-
-func (d *DataBases) BatchInsertChat(userID string, msgList []*pbMsg.MsgDataToMQ, operationID string) error {
-	newTime := getCurrentTimestampByMill()
-	if len(msgList) > GetSingleGocMsgNum() {
-		return errors.New("too large")
-	}
-	isInit := false
-	currentMaxSeq, err := d.GetUserMaxSeq(userID)
-	if err == nil {
-
-	} else if err == go_redis.Nil {
-		isInit = true
-		currentMaxSeq = 0
-	} else {
-		return utils.Wrap(err, "")
-	}
-	var remain uint64
-	//if currentMaxSeq < uint64(GetSingleGocMsgNum()) {
-	//	remain = uint64(GetSingleGocMsgNum()-1) - (currentMaxSeq % uint64(GetSingleGocMsgNum()))
-	//} else {
-	//	remain = uint64(GetSingleGocMsgNum()) - ((currentMaxSeq - (uint64(GetSingleGocMsgNum()) - 1)) % uint64(GetSingleGocMsgNum()))
-	//}
-
-	blk0 := uint64(GetSingleGocMsgNum() - 1)
-	if currentMaxSeq < uint64(GetSingleGocMsgNum()) {
-		remain = blk0 - currentMaxSeq
-	} else {
-		excludeBlk0 := currentMaxSeq - blk0
-		remain = (uint64(GetSingleGocMsgNum()) - (excludeBlk0 % uint64(GetSingleGocMsgNum()))) % uint64(GetSingleGocMsgNum())
-	}
-
-	insertCounter := uint64(0)
-	msgListToMongo := make([]MsgInfo, 0)
-	msgListToMongoNext := make([]MsgInfo, 0)
-	seqUid := ""
-	seqUidNext := ""
-	log.Debug(operationID, "remain ", remain, "insertCounter ", insertCounter, "currentMaxSeq ", currentMaxSeq, userID, len(msgList))
-	//4998 remain ==1
-	//4999
-	for _, m := range msgList {
-		log.Debug(operationID, "msg node ", m.String(), m.MsgData.ClientMsgID)
-		currentMaxSeq++
-		sMsg := MsgInfo{}
-		sMsg.SendTime = m.MsgData.SendTime
-		m.MsgData.Seq = uint32(currentMaxSeq)
-		if sMsg.Msg, err = proto.Marshal(m.MsgData); err != nil {
-			return utils.Wrap(err, "")
-		}
-		if isInit {
-			msgListToMongoNext = append(msgListToMongoNext, sMsg)
-			seqUidNext = getSeqUid(userID, uint32(currentMaxSeq))
-			log.Debug(operationID, "msgListToMongoNext ", seqUidNext, m.MsgData.Seq, m.MsgData.ClientMsgID, insertCounter, remain)
-			continue
-		}
-		if insertCounter < remain {
-			msgListToMongo = append(msgListToMongo, sMsg)
-			insertCounter++
-			seqUid = getSeqUid(userID, uint32(currentMaxSeq))
-			log.Debug(operationID, "msgListToMongo ", seqUid, m.MsgData.Seq, m.MsgData.ClientMsgID, insertCounter, remain)
-		} else {
-			msgListToMongoNext = append(msgListToMongoNext, sMsg)
-			seqUidNext = getSeqUid(userID, uint32(currentMaxSeq))
-			log.Debug(operationID, "msgListToMongoNext ", seqUidNext, m.MsgData.Seq, m.MsgData.ClientMsgID, insertCounter, remain)
-		}
-	}
-	//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
-
-	ctx := context.Background()
-	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
-
-	if seqUid != "" {
-		filter := bson.M{"uid": seqUid}
-		log.NewDebug(operationID, "filter ", seqUid, "list ", msgListToMongo)
-		err := c.FindOneAndUpdate(ctx, filter, bson.M{"$push": bson.M{"msg": bson.M{"$each": msgListToMongo}}}).Err()
-		if err != nil {
-			log.Error(operationID, "FindOneAndUpdate failed ", err.Error(), filter)
-			return utils.Wrap(err, "")
-		}
-	}
-	if seqUidNext != "" {
-		filter := bson.M{"uid": seqUidNext}
-		sChat := UserChat{}
-		sChat.UID = seqUidNext
-		sChat.Msg = msgListToMongoNext
-		log.NewDebug(operationID, "filter ", seqUidNext, "list ", msgListToMongoNext)
-		if _, err = c.InsertOne(ctx, &sChat); err != nil {
-			log.NewError(operationID, "InsertOne failed", filter, err.Error(), sChat)
-			return utils.Wrap(err, "")
-		}
-	}
-	log.NewWarn(operationID, "batch mgo  cost time ", getCurrentTimestampByMill()-newTime, userID, len(msgList))
-	return utils.Wrap(d.SetUserMaxSeq(userID, uint64(currentMaxSeq)), "")
-}
+//
+//func (d *DataBases) BatchInsertChat(userID string, msgList []*pbMsg.MsgDataToMQ, operationID string) error {
+//	newTime := getCurrentTimestampByMill()
+//	if len(msgList) > GetSingleGocMsgNum() {
+//		return errors.New("too large")
+//	}
+//	isInit := false
+//	currentMaxSeq, err := d.GetUserMaxSeq(userID)
+//	if err == nil {
+//
+//	} else if err == go_redis.Nil {
+//		isInit = true
+//		currentMaxSeq = 0
+//	} else {
+//		return utils.Wrap(err, "")
+//	}
+//	var remain uint64
+//	//if currentMaxSeq < uint64(GetSingleGocMsgNum()) {
+//	//	remain = uint64(GetSingleGocMsgNum()-1) - (currentMaxSeq % uint64(GetSingleGocMsgNum()))
+//	//} else {
+//	//	remain = uint64(GetSingleGocMsgNum()) - ((currentMaxSeq - (uint64(GetSingleGocMsgNum()) - 1)) % uint64(GetSingleGocMsgNum()))
+//	//}
+//
+//	blk0 := uint64(GetSingleGocMsgNum() - 1)
+//	if currentMaxSeq < uint64(GetSingleGocMsgNum()) {
+//		remain = blk0 - currentMaxSeq
+//	} else {
+//		excludeBlk0 := currentMaxSeq - blk0
+//		remain = (uint64(GetSingleGocMsgNum()) - (excludeBlk0 % uint64(GetSingleGocMsgNum()))) % uint64(GetSingleGocMsgNum())
+//	}
+//
+//	insertCounter := uint64(0)
+//	msgListToMongo := make([]MsgInfo, 0)
+//	msgListToMongoNext := make([]MsgInfo, 0)
+//	seqUid := ""
+//	seqUidNext := ""
+//	log.Debug(operationID, "remain ", remain, "insertCounter ", insertCounter, "currentMaxSeq ", currentMaxSeq, userID, len(msgList))
+//	//4998 remain ==1
+//	//4999
+//	for _, m := range msgList {
+//		log.Debug(operationID, "msg node ", m.String(), m.MsgData.ClientMsgID)
+//		currentMaxSeq++
+//		sMsg := MsgInfo{}
+//		sMsg.SendTime = m.MsgData.SendTime
+//		m.MsgData.Seq = uint32(currentMaxSeq)
+//		if sMsg.Msg, err = proto.Marshal(m.MsgData); err != nil {
+//			return utils.Wrap(err, "")
+//		}
+//		if isInit {
+//			msgListToMongoNext = append(msgListToMongoNext, sMsg)
+//			seqUidNext = getSeqUid(userID, uint32(currentMaxSeq))
+//			log.Debug(operationID, "msgListToMongoNext ", seqUidNext, m.MsgData.Seq, m.MsgData.ClientMsgID, insertCounter, remain)
+//			continue
+//		}
+//		if insertCounter < remain {
+//			msgListToMongo = append(msgListToMongo, sMsg)
+//			insertCounter++
+//			seqUid = getSeqUid(userID, uint32(currentMaxSeq))
+//			log.Debug(operationID, "msgListToMongo ", seqUid, m.MsgData.Seq, m.MsgData.ClientMsgID, insertCounter, remain)
+//		} else {
+//			msgListToMongoNext = append(msgListToMongoNext, sMsg)
+//			seqUidNext = getSeqUid(userID, uint32(currentMaxSeq))
+//			log.Debug(operationID, "msgListToMongoNext ", seqUidNext, m.MsgData.Seq, m.MsgData.ClientMsgID, insertCounter, remain)
+//		}
+//	}
+//	//	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
+//
+//	ctx := context.Background()
+//	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cChat)
+//
+//	if seqUid != "" {
+//		filter := bson.M{"uid": seqUid}
+//		log.NewDebug(operationID, "filter ", seqUid, "list ", msgListToMongo)
+//		err := c.FindOneAndUpdate(ctx, filter, bson.M{"$push": bson.M{"msg": bson.M{"$each": msgListToMongo}}}).Err()
+//		if err != nil {
+//			log.Error(operationID, "FindOneAndUpdate failed ", err.Error(), filter)
+//			return utils.Wrap(err, "")
+//		}
+//	}
+//	if seqUidNext != "" {
+//		filter := bson.M{"uid": seqUidNext}
+//		sChat := UserChat{}
+//		sChat.UID = seqUidNext
+//		sChat.Msg = msgListToMongoNext
+//		log.NewDebug(operationID, "filter ", seqUidNext, "list ", msgListToMongoNext)
+//		if _, err = c.InsertOne(ctx, &sChat); err != nil {
+//			log.NewError(operationID, "InsertOne failed", filter, err.Error(), sChat)
+//			return utils.Wrap(err, "")
+//		}
+//	}
+//	log.NewWarn(operationID, "batch mgo  cost time ", getCurrentTimestampByMill()-newTime, userID, len(msgList))
+//	return utils.Wrap(d.SetUserMaxSeq(userID, uint64(currentMaxSeq)), "")
+//}
 
 //func (d *DataBases)setMessageToCache(msgList []*pbMsg.MsgDataToMQ, uid string) (err error) {
 //
 //}
-
-func (d *DataBases) GetFromCacheAndInsertDB(msgUserIDPrefix string) {
-	//get value from redis
-
-	//batch insert to db
-}

pkg/common/db/model.go

@@ -58,15 +58,30 @@ func init() {
 		// example: mongodb://$user:$password@mongo1.mongo:27017,mongo2.mongo:27017,mongo3.mongo:27017/$DBDatabase/?replicaSet=rs0&readPreference=secondary&authSource=admin&maxPoolSize=$DBMaxPoolSize
 		uri = config.Config.Mongo.DBUri
 	} else {
+		//mongodb://mongodb1.example.com:27317,mongodb2.example.com:27017/?replicaSet=mySet&authSource=authDB
+		mongodbHosts := ""
+		for i, v := range config.Config.Mongo.DBAddress {
+			if i == len(config.Config.Mongo.DBAddress)-1 {
+				mongodbHosts += v
+			} else {
+				mongodbHosts += v + ","
+			}
+		}
+
 		if config.Config.Mongo.DBPassword != "" && config.Config.Mongo.DBUserName != "" {
-			uri = fmt.Sprintf("mongodb://%s:%s@%s/%s?maxPoolSize=%d&authSource=admin", config.Config.Mongo.DBUserName, config.Config.Mongo.DBPassword, config.Config.Mongo.DBAddress,
+			// clientOpts := options.Client().ApplyURI("mongodb://localhost:27017,localhost:27018/?replicaSet=replset")
+			//mongodb://[username:password@]host1[:port1][,...hostN[:portN]][/[defaultauthdb][?options]]
+			//uri = fmt.Sprintf("mongodb://%s:%s@%s/%s?maxPoolSize=%d&authSource=admin&replicaSet=replset",
+			uri = fmt.Sprintf("mongodb://%s:%s@%s/%s?maxPoolSize=%d&authSource=admin",
+				config.Config.Mongo.DBUserName, config.Config.Mongo.DBPassword, mongodbHosts,
 				config.Config.Mongo.DBDatabase, config.Config.Mongo.DBMaxPoolSize)
 		} else {
 			uri = fmt.Sprintf("mongodb://%s/%s/?maxPoolSize=%d&authSource=admin",
-				config.Config.Mongo.DBAddress, config.Config.Mongo.DBDatabase,
+				mongodbHosts, config.Config.Mongo.DBDatabase,
 				config.Config.Mongo.DBMaxPoolSize)
 		}
 	}
+
 	mongoClient, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
 	if err != nil {
 		fmt.Println(" mongo.Connect  failed, try ", utils.GetSelfFuncName(), err.Error(), uri)
@@ -77,7 +92,7 @@ func init() {
 			panic(err1.Error())
 		}
 	}
-	fmt.Println("0", utils.GetSelfFuncName(), "mongo driver client init success: ", uri)
+	fmt.Println("mongo driver client init success: ", uri)
 	// mongodb create index
 	if err := createMongoIndex(mongoClient, cSendLog, false, "send_id", "-send_time"); err != nil {
 		fmt.Println("send_id", "-send_time", "index create failed", err.Error())
@@ -100,7 +115,7 @@ func init() {
 	if err := createMongoIndex(mongoClient, cTag, true, "tag_id"); err != nil {
 		fmt.Println("tag_id", "index create failed", err.Error())
 	}
-	fmt.Println("create index success")
+	fmt.Println("createMongoIndex success")
 	DB.mongoClient = mongoClient
 
 	// redis pool init

pkg/common/db/mysql.go

@@ -23,6 +23,7 @@ func (w Writer) Printf(format string, args ...interface{}) {
 }
 
 func initMysqlDB() {
+	fmt.Println("init mysqlDB start")
 	//When there is no open IM database, connect to the mysql built-in database to create openIM database
 	dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=true&loc=Local",
 		config.Config.Mysql.DBUserName, config.Config.Mysql.DBPassword, config.Config.Mysql.DBAddress[0], "mysql")
@@ -30,42 +31,43 @@ func initMysqlDB() {
 	var err1 error
 	db, err := gorm.Open(mysql.Open(dsn), nil)
 	if err != nil {
-		fmt.Println("0", "Open failed ", err.Error(), dsn)
+		fmt.Println("Open failed ", err.Error(), dsn)
 	}
 	if err != nil {
 		time.Sleep(time.Duration(30) * time.Second)
 		db, err1 = gorm.Open(mysql.Open(dsn), nil)
 		if err1 != nil {
-			fmt.Println("0", "Open failed ", err1.Error(), dsn)
+			fmt.Println("Open failed ", err1.Error(), dsn)
 			panic(err1.Error())
 		}
 	}
 
 	//Check the database and table during initialization
 	sql := fmt.Sprintf("CREATE DATABASE IF NOT EXISTS %s default charset utf8 COLLATE utf8_general_ci;", config.Config.Mysql.DBDatabaseName)
+	fmt.Println("exec sql: ", sql, " begin")
 	err = db.Exec(sql).Error
 	if err != nil {
-		fmt.Println("0", "Exec failed ", err.Error(), sql)
+		fmt.Println("Exec failed ", err.Error(), sql)
 		panic(err.Error())
 	}
-
+	fmt.Println("exec sql: ", sql, " end")
 	dsn = fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=true&loc=Local",
 		config.Config.Mysql.DBUserName, config.Config.Mysql.DBPassword, config.Config.Mysql.DBAddress[0], config.Config.Mysql.DBDatabaseName)
 
 	newLogger := logger.New(
 		Writer{},
 		logger.Config{
-			SlowThreshold:             200 * time.Millisecond, // Slow SQL threshold
-			LogLevel:                  logger.Warn,            // Log level
-			IgnoreRecordNotFoundError: true,                   // Ignore ErrRecordNotFound error for logger
-			Colorful:                  true,                   // Disable color
+			SlowThreshold:             time.Duration(config.Config.Mysql.SlowThreshold) * time.Millisecond, // Slow SQL threshold
+			LogLevel:                  logger.LogLevel(config.Config.Mysql.LogLevel),                       // Log level
+			IgnoreRecordNotFoundError: true,                                                                // Ignore ErrRecordNotFound error for logger
+			Colorful:                  true,                                                                // Disable color
 		},
 	)
 	db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
 		Logger: newLogger,
 	})
 	if err != nil {
-		fmt.Println("0", "Open failed ", err.Error(), dsn)
+		fmt.Println("Open failed ", err.Error(), dsn)
 		panic(err.Error())
 	}
 
@@ -78,7 +80,7 @@ func initMysqlDB() {
 	sqlDB.SetMaxOpenConns(config.Config.Mysql.DBMaxOpenConns)
 	sqlDB.SetMaxIdleConns(config.Config.Mysql.DBMaxIdleConns)
 
-	fmt.Println("open db ok ", dsn)
+	fmt.Println("open mysql ok ", dsn)
 	db.AutoMigrate(
 		&Register{},
 		&Friend{},
@@ -88,7 +90,7 @@ func initMysqlDB() {
 		&GroupRequest{},
 		&User{},
 		&Black{}, &ChatLog{}, &Register{}, &Conversation{}, &AppVersion{}, &Department{}, &BlackList{}, &IpLimit{}, &UserIpLimit{}, &Invitation{}, &RegisterAddFriend{},
-		&ClientInitConfig{})
+		&ClientInitConfig{}, &UserIpRecord{})
 	db.Set("gorm:table_options", "CHARSET=utf8")
 	db.Set("gorm:table_options", "collation=utf8_unicode_ci")
 
@@ -179,6 +181,11 @@ func initMysqlDB() {
 		db.Migrator().CreateTable(&ClientInitConfig{})
 	}
 
+	if !db.Migrator().HasTable(&UserIpRecord{}) {
+		fmt.Println("CreateTable Friend")
+		db.Migrator().CreateTable(&UserIpRecord{})
+	}
+
 	DB.MysqlDB.db = db
 	return
 }

pkg/common/db/mysql_model/im_mysql_model/ip_model.go

@@ -2,7 +2,10 @@ package im_mysql_model
 
 import (
 	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/utils"
 	"time"
+
+	"gorm.io/gorm"
 )
 
 func IsLimitRegisterIp(RegisterIp string) (bool, error) {
@@ -23,13 +26,22 @@ func IsLimitLoginIp(LoginIp string) (bool, error) {
 	return count > 0, nil
 }
 
-func IsLimitUserLoginIp(userID string, LoginIp string) (bool, error) {
+func IsLimitUserLoginIp(userID string, loginIp string) (limit bool, err error) {
 	//如果已经存在则放行
 	var count int64
-	if err := db.DB.MysqlDB.DefaultGormDB().Table("user_ip_limits").Where("ip=? and user_id=?", LoginIp, userID).Count(&count).Error; err != nil {
-		return false, err
+	result := db.DB.MysqlDB.DefaultGormDB().Table("user_ip_limits").Where("user_id=?", userID).Count(&count)
+	if err := result.Error; err != nil {
+		return true, err
 	}
-	return count == 0, nil
+	if count < 1 {
+		return false, nil
+	}
+	result = db.DB.MysqlDB.DefaultGormDB().Table("user_ip_limits").Where("user_id=? and ip = ?", userID, loginIp).Count(&count)
+	if err := result.Error; err != nil {
+		return true, err
+	}
+
+	return count > 0, nil
 }
 
 func QueryIPLimits(ip string) (*db.IpLimit, error) {
@@ -83,12 +95,12 @@ func InsertIpRecord(userID, createIp string) error {
 
 func UpdateIpReocord(userID, ip string) (err error) {
 	record := &db.UserIpRecord{UserID: userID, LastLoginIp: ip, LastLoginTime: time.Now()}
-	result := db.DB.MysqlDB.DefaultGormDB().Model(&db.UserIpRecord{}).Where("user_id=?", userID).Updates(record).Updates("login_times = login_times + 1")
+	result := db.DB.MysqlDB.DefaultGormDB().Model(&db.UserIpRecord{}).Where("user_id=?", userID).Updates(record).Update("login_times", gorm.Expr("login_times+?", 1))
 	if result.Error != nil {
-		return result.Error
+		return utils.Wrap(result.Error, "")
 	}
 	if result.RowsAffected == 0 {
 		err = InsertIpRecord(userID, ip)
 	}
-	return err
+	return utils.Wrap(err, "")
 }

pkg/common/db/mysql_model/im_mysql_model/user_model.go

@@ -12,11 +12,9 @@ import (
 )
 
 func init() {
-	//init managers
 	for k, v := range config.Config.Manager.AppManagerUid {
-		user, err := GetUserByUserID(v)
+		_, err := GetUserByUserID(v)
 		if err != nil {
-			fmt.Println("GetUserByUserID failed ", err.Error(), v, user)
 		} else {
 			continue
 		}
@@ -30,9 +28,10 @@ func init() {
 		appMgr.AppMangerLevel = constant.AppAdmin
 		err = UserRegister(appMgr)
 		if err != nil {
-			fmt.Println("AppManager insert error", err.Error(), appMgr, "time: ", appMgr.Birth.Unix())
+			fmt.Println("AppManager insert error ", err.Error(), appMgr)
+		} else {
+			fmt.Println("AppManager insert ", appMgr)
 		}
-
 	}
 }
 

pkg/common/db/redisModel_test.go

@@ -71,7 +71,7 @@ func Test_NewSetMessageToCache(t *testing.T) {
 	data.AtUserIDList = []string{"1212", "23232"}
 	msg.MsgData = &data
 	messageList := []*pbChat.MsgDataToMQ{&msg}
-	err := DB.SetMessageToCache(messageList, uid, "cacheTest")
+	err, _ := DB.SetMessageToCache(messageList, uid, "cacheTest")
 	assert.Nil(t, err)
 
 }

pkg/common/db/rocks_cache/rocks_cache.go

@@ -433,6 +433,13 @@ func DelJoinedSuperGroupIDListFromCache(userID string) error {
 
 func GetGroupMemberListHashFromCache(groupID string) (uint64, error) {
 	generateHash := func() (string, error) {
+		groupInfo, err := GetGroupInfoFromCache(groupID)
+		if err != nil {
+			return "0", utils.Wrap(err, "GetGroupInfoFromCache failed")
+		}
+		if groupInfo.Status == constant.GroupStatusDismissed {
+			return "0", nil
+		}
 		groupMemberIDList, err := GetGroupMemberIDListFromCache(groupID)
 		if err != nil {
 			return "", utils.Wrap(err, "GetGroupMemberIDListFromCache failed")
@@ -447,6 +454,9 @@ func GetGroupMemberListHashFromCache(groupID string) (uint64, error) {
 		return strconv.Itoa(int(bi.Uint64())), nil
 	}
 	hashCode, err := db.DB.Rc.Fetch(groupMemberListHashCache+groupID, time.Second*30*60, generateHash)
+	if err != nil {
+		return 0, utils.Wrap(err, "fetch failed")
+	}
 	hashCodeUint64, err := strconv.Atoi(hashCode)
 	return uint64(hashCodeUint64), err
 }