// Copyright © 2023 OpenIM. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package msgtransfer import ( "context" "fmt" "time" "github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis" "github.com/openimsdk/open-im-server/v3/pkg/common/storage/database/mgo" "github.com/openimsdk/open-im-server/v3/pkg/dbbuild" "github.com/openimsdk/open-im-server/v3/pkg/mqbuild" "github.com/openimsdk/tools/discovery" "github.com/openimsdk/tools/mq" "github.com/openimsdk/tools/utils/runtimeenv" "google.golang.org/grpc" conf "github.com/openimsdk/open-im-server/v3/pkg/common/config" "github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller" "github.com/openimsdk/tools/log" ) const ( mongoPersistenceRetryInitial = time.Second mongoPersistenceRetryMax = 30 * time.Second ) type MsgTransfer struct { historyConsumer mq.Consumer historyMongoConsumer mq.Consumer // This consumer aggregated messages, subscribed to the topic:toRedis, // the message is stored in redis, Incr Redis, and then the message is sent to toPush topic for push, // and the message is sent to toMongo topic for persistence historyHandler *OnlineHistoryRedisConsumerHandler //This consumer handle message to mongo historyMongoHandler *OnlineHistoryMongoConsumerHandler ctx context.Context //cancel context.CancelFunc } type Config struct { MsgTransfer conf.MsgTransfer RedisConfig conf.Redis MongodbConfig conf.Mongo KafkaConfig conf.Kafka Share conf.Share WebhooksConfig conf.Webhooks Discovery conf.Discovery Index conf.Index } func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server grpc.ServiceRegistrar) error { log.CInfo(ctx, "MSG-TRANSFER server is initializing", "runTimeEnv", runtimeenv.RuntimeEnvironment(), "prometheusPorts", config.MsgTransfer.Prometheus.Ports, "index", config.Index) dbb := dbbuild.NewBuilder(&config.MongodbConfig, &config.RedisConfig) mgocli, err := dbb.Mongo(ctx) if err != nil { return err } rdb, err := dbb.Redis(ctx) if err != nil { return err } builder, err := mqbuild.NewBuilder(config.Share.Queue, &config.KafkaConfig, rdb) if err != nil { return err } mongoProducer, err := builder.GetTopicProducer(ctx, mqbuild.TopicToMongo) if err != nil { return err } pushProducer, err := builder.GetTopicProducer(ctx, mqbuild.TopicToPush) if err != nil { return err } msgDocModel, err := mgo.NewMsgMongo(mgocli.GetDB()) if err != nil { return err } msgModel := redis.NewMsgCache(rdb, msgDocModel) seqConversation, err := mgo.NewSeqConversationMongo(mgocli.GetDB()) if err != nil { return err } seqConversationCache := redis.NewSeqConversationCacheRedis(rdb, seqConversation) seqUser, err := mgo.NewSeqUserMongo(mgocli.GetDB()) if err != nil { return err } seqUserCache := redis.NewSeqUserCacheRedis(rdb, seqUser) msgTransferDatabase, err := controller.NewMsgTransferDatabase(msgDocModel, msgModel, seqUserCache, seqConversationCache, mongoProducer, pushProducer) if err != nil { return err } historyConsumer, err := builder.GetTopicConsumer(ctx, mqbuild.TopicToRedis) if err != nil { return err } historyMongoConsumer, err := builder.GetTopicConsumer(ctx, mqbuild.TopicToMongo) if err != nil { return err } historyHandler, err := NewOnlineHistoryRedisConsumerHandler(ctx, client, config, msgTransferDatabase) if err != nil { return err } historyMongoHandler := NewOnlineHistoryMongoConsumerHandler(msgTransferDatabase, config) msgTransfer := &MsgTransfer{ historyConsumer: historyConsumer, historyMongoConsumer: historyMongoConsumer, historyHandler: historyHandler, historyMongoHandler: historyMongoHandler, } return msgTransfer.Start(ctx) } func (m *MsgTransfer) Start(ctx context.Context) error { var cancel context.CancelCauseFunc m.ctx, cancel = context.WithCancelCause(ctx) go func() { for { if err := m.historyConsumer.Subscribe(m.ctx, m.historyHandler.HandlerRedisMessage); err != nil { cancel(fmt.Errorf("history consumer %w", err)) log.ZError(m.ctx, "historyConsumer err", err) return } } }() go func() { fn := func(msg mq.Message) error { return consumeMongoMessage(m.ctx, msg, m.historyMongoHandler.HandleChatWs2Mongo, mongoPersistenceRetryInitial, mongoPersistenceRetryMax) } for { if err := m.historyMongoConsumer.Subscribe(m.ctx, fn); err != nil { cancel(fmt.Errorf("history mongo consumer %w", err)) log.ZError(m.ctx, "historyMongoConsumer err", err) return } } }() go m.historyHandler.HandleUserHasReadSeqMessages(m.ctx) err := m.historyHandler.redisMessageBatches.Start() if err != nil { return err } <-m.ctx.Done() return context.Cause(m.ctx) } // consumeMongoMessage leaves a Kafka message unacknowledged until its MongoDB // persistence succeeds. Since the subscription loop is serial, later messages // cannot call Mark and advance the partition offset past a failed message. func consumeMongoMessage(ctx context.Context, msg mq.Message, handle func(mq.Message) error, initial, max time.Duration) error { delay := initial for { if err := handle(msg); err == nil { msg.Mark() return nil } else { log.ZError(ctx, "persist to MongoDB failed; retrying without acknowledging Kafka message", err, "key", msg.Key(), "retryAfter", delay) } timer := time.NewTimer(delay) select { case <-ctx.Done(): if !timer.Stop() { <-timer.C } return context.Cause(ctx) case <-timer.C: } if delay < max { delay *= 2 if delay > max { delay = max } } } }