feat: use robot to migrate code

Signed-off-by: kubbot & kubecub <3293172751ysy@gmail.com>

pkg/common/kafka/consumer.go

@@ -1,8 +1,11 @@
 package kafka
 
 import (
-	"github.com/Shopify/sarama"
 	"sync"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+
+	"github.com/Shopify/sarama"
 )
 
 type Consumer struct {
@@ -17,18 +20,21 @@ func NewKafkaConsumer(addr []string, topic string) *Consumer {
 	p := Consumer{}
 	p.Topic = topic
 	p.addr = addr
-
-	consumer, err := sarama.NewConsumer(p.addr, nil)
+	consumerConfig := sarama.NewConfig()
+	if config.Config.Kafka.Username != "" && config.Config.Kafka.Password != "" {
+		consumerConfig.Net.SASL.Enable = true
+		consumerConfig.Net.SASL.User = config.Config.Kafka.Username
+		consumerConfig.Net.SASL.Password = config.Config.Kafka.Password
+	}
+	consumer, err := sarama.NewConsumer(p.addr, consumerConfig)
 	if err != nil {
 		panic(err.Error())
-		return nil
 	}
 	p.Consumer = consumer
 
 	partitionList, err := consumer.Partitions(p.Topic)
 	if err != nil {
 		panic(err.Error())
-		return nil
 	}
 	p.PartitionList = partitionList
 

pkg/common/kafka/consumer_group.go

@@ -8,7 +8,8 @@ package kafka
 
 import (
 	"context"
-	"fmt"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
+
 	"github.com/Shopify/sarama"
 )
 
@@ -29,7 +30,6 @@ func NewMConsumerGroup(consumerConfig *MConsumerGroupConfig, topics, addrs []str
 	config.Version = consumerConfig.KafkaVersion
 	config.Consumer.Offsets.Initial = consumerConfig.OffsetsInitial
 	config.Consumer.Return.Errors = consumerConfig.IsReturnErr
-	fmt.Println("init address is ", addrs, "topics is ", topics)
 	consumerGroup, err := sarama.NewConsumerGroup(addrs, groupID, config)
 	if err != nil {
 		panic(err.Error())
@@ -40,7 +40,14 @@ func NewMConsumerGroup(consumerConfig *MConsumerGroupConfig, topics, addrs []str
 		topics,
 	}
 }
+
+func (mc *MConsumerGroup) GetContextFromMsg(cMsg *sarama.ConsumerMessage) context.Context {
+	return GetContextWithMQHeader(cMsg.Headers)
+
+}
+
 func (mc *MConsumerGroup) RegisterHandleAndConsumer(handler sarama.ConsumerGroupHandler) {
+	log.ZDebug(context.Background(), "register consumer group", "groupID", mc.groupID)
 	ctx := context.Background()
 	for {
 		err := mc.ConsumerGroup.Consume(ctx, mc.topics, handler)

pkg/common/kafka/producer.go

@@ -1,12 +1,23 @@
 package kafka
 
 import (
-	log2 "Open_IM/pkg/common/log"
+	"context"
 	"errors"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	log "github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+
 	"github.com/Shopify/sarama"
-	"github.com/golang/protobuf/proto"
+	"google.golang.org/protobuf/proto"
+
+	prome "github.com/OpenIMSDK/Open-IM-Server/pkg/common/prome"
 )
 
+var errEmptyMsg = errors.New("binary msg is empty")
+
 type Producer struct {
 	topic    string
 	addr     []string
@@ -16,36 +27,72 @@ type Producer struct {
 
 func NewKafkaProducer(addr []string, topic string) *Producer {
 	p := Producer{}
-	p.config = sarama.NewConfig()                             //Instantiate a sarama Config
-	p.config.Producer.Return.Successes = true                 //Whether to enable the successes channel to be notified after the message is sent successfully
+	p.config = sarama.NewConfig()             //Instantiate a sarama Config
+	p.config.Producer.Return.Successes = true //Whether to enable the successes channel to be notified after the message is sent successfully
+	p.config.Producer.Return.Errors = true
 	p.config.Producer.RequiredAcks = sarama.WaitForAll        //Set producer Message Reply level 0 1 all
 	p.config.Producer.Partitioner = sarama.NewHashPartitioner //Set the hash-key automatic hash partition. When sending a message, you must specify the key value of the message. If there is no key, the partition will be selected randomly
-
+	if config.Config.Kafka.Username != "" && config.Config.Kafka.Password != "" {
+		p.config.Net.SASL.Enable = true
+		p.config.Net.SASL.User = config.Config.Kafka.Username
+		p.config.Net.SASL.Password = config.Config.Kafka.Password
+	}
 	p.addr = addr
 	p.topic = topic
-
 	producer, err := sarama.NewSyncProducer(p.addr, p.config) //Initialize the client
 	if err != nil {
 		panic(err.Error())
-		return nil
 	}
 	p.producer = producer
 	return &p
 }
 
-func (p *Producer) SendMessage(m proto.Message, key string) (int32, int64, error) {
+func GetMQHeaderWithContext(ctx context.Context) ([]sarama.RecordHeader, error) {
+	operationID, opUserID, platform, connID, err := mcontext.GetCtxInfos(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return []sarama.RecordHeader{
+		{Key: []byte(constant.OperationID), Value: []byte(operationID)},
+		{Key: []byte(constant.OpUserID), Value: []byte(opUserID)},
+		{Key: []byte(constant.OpUserPlatform), Value: []byte(platform)},
+		{Key: []byte(constant.ConnID), Value: []byte(connID)}}, err
+}
+
+func GetContextWithMQHeader(header []*sarama.RecordHeader) context.Context {
+	var values []string
+	for _, recordHeader := range header {
+		values = append(values, string(recordHeader.Value))
+	}
+	return mcontext.WithMustInfoCtx(values) // TODO
+}
+
+func (p *Producer) SendMessage(ctx context.Context, key string, msg proto.Message) (int32, int64, error) {
+	log.ZDebug(ctx, "SendMessage", "msg", msg, "topic", p.topic, "key", key)
 	kMsg := &sarama.ProducerMessage{}
 	kMsg.Topic = p.topic
 	kMsg.Key = sarama.StringEncoder(key)
-	bMsg, err := proto.Marshal(m)
+	bMsg, err := proto.Marshal(msg)
 	if err != nil {
-		log2.Error("", "", "proto marshal err = %s", err.Error())
-		return -1, -1, err
+		return 0, 0, utils.Wrap(err, "kafka proto Marshal err")
 	}
 	if len(bMsg) == 0 {
-		return 0, 0, errors.New("msg content is nil")
+		return 0, 0, utils.Wrap(errEmptyMsg, "")
 	}
 	kMsg.Value = sarama.ByteEncoder(bMsg)
-
-	return p.producer.SendMessage(kMsg)
+	if kMsg.Key.Length() == 0 || kMsg.Value.Length() == 0 {
+		return 0, 0, utils.Wrap(errEmptyMsg, "")
+	}
+	kMsg.Metadata = ctx
+	header, err := GetMQHeaderWithContext(ctx)
+	if err != nil {
+		return 0, 0, utils.Wrap(err, "")
+	}
+	kMsg.Headers = header
+	partition, offset, err := p.producer.SendMessage(kMsg)
+	log.ZDebug(ctx, "ByteEncoder SendMessage end", "key ", kMsg.Key, "key length", kMsg.Value.Length())
+	if err == nil {
+		prome.Inc(prome.SendMsgCounter)
+	}
+	return partition, offset, utils.Wrap(err, "")
 }