Merge remote-tracking branch 'origin/superGroup' into superGroup

# Conflicts:
#	pkg/proto/sdk_ws/ws.pb.go

pkg/common/constant/constant.go

@@ -230,7 +230,7 @@ var ContentType2PushContent = map[int64]string{
 	AtText:    "[有人@你]",
 	GroupMsg:  "你收到一条群聊消息",
 	Common:    "你收到一条新消息",
-	SignalMsg: "音視頻通話邀請",
+	SignalMsg: "音视频通话邀请",
 }
 
 const (

pkg/common/db/newRedisModel.go

@@ -95,42 +95,50 @@ func (d *DataBases) CleanUpOneUserAllMsgFromRedis(userID string, operationID str
 	return nil
 }
 
-func (d *DataBases) NewCacheSignalInfo(msg *pbCommon.MsgData) error {
+func (d *DataBases) HandleSignalInfo(operationID string, msg *pbCommon.MsgData) error {
 	req := &pbRtc.SignalReq{}
 	if err := proto.Unmarshal(msg.Content, req); err != nil {
 		return err
 	}
 	//log.NewDebug(pushMsg.OperationID, utils.GetSelfFuncName(), "SignalReq: ", req.String())
 	var inviteeUserIDList []string
-	switch invitationInfo := req.Payload.(type) {
+	var isInviteSignal bool
+	switch signalInfo := req.Payload.(type) {
 	case *pbRtc.SignalReq_Invite:
-		inviteeUserIDList = invitationInfo.Invite.Invitation.InviteeUserIDList
+		inviteeUserIDList = signalInfo.Invite.Invitation.InviteeUserIDList
+		isInviteSignal = true
 	case *pbRtc.SignalReq_InviteInGroup:
-		inviteeUserIDList = invitationInfo.InviteInGroup.Invitation.InviteeUserIDList
+		inviteeUserIDList = signalInfo.InviteInGroup.Invitation.InviteeUserIDList
+		isInviteSignal = true
+	case *pbRtc.SignalReq_HungUp, *pbRtc.SignalReq_Cancel, *pbRtc.SignalReq_Reject, *pbRtc.SignalReq_Accept:
+		return errors.New("signalInfo do not need offlinePush")
 	default:
-		log2.NewDebug("", utils.GetSelfFuncName(), "req type not invite", string(msg.Content))
+		log2.NewDebug(operationID, utils.GetSelfFuncName(), "req invalid type", string(msg.Content))
 		return nil
 	}
-	for _, userID := range inviteeUserIDList {
-		timeout, err := strconv.Atoi(config.Config.Rtc.SignalTimeout)
-		if err != nil {
-			return err
+	if isInviteSignal {
+		log2.NewInfo(operationID, utils.GetSelfFuncName(), "invite userID list:", inviteeUserIDList)
+		for _, userID := range inviteeUserIDList {
+			log2.NewInfo(operationID, utils.GetSelfFuncName(), "invite userID:", userID)
+			timeout, err := strconv.Atoi(config.Config.Rtc.SignalTimeout)
+			if err != nil {
+				return err
+			}
+			keyList := SignalListCache + userID
+			err = d.rdb.LPush(context.Background(), keyList, msg.ClientMsgID).Err()
+			if err != nil {
+				return err
+			}
+			err = d.rdb.Expire(context.Background(), keyList, time.Duration(timeout)*time.Second).Err()
+			if err != nil {
+				return err
+			}
+			key := SignalCache + msg.ClientMsgID
+			err = d.rdb.Set(context.Background(), key, msg.Content, time.Duration(timeout)*time.Second).Err()
+			if err != nil {
+				return err
+			}
 		}
-		keyList := SignalListCache + userID
-		err = d.rdb.LPush(context.Background(), keyList, msg.ClientMsgID).Err()
-		if err != nil {
-			return err
-		}
-		err = d.rdb.Expire(context.Background(), keyList, time.Duration(timeout)*time.Second).Err()
-		if err != nil {
-			return err
-		}
-		key := SignalCache + msg.ClientMsgID
-		err = d.rdb.Set(context.Background(), key, msg.Content, time.Duration(timeout)*time.Second).Err()
-		if err != nil {
-			return err
-		}
-		return err
 	}
 	return nil
 }
@@ -149,15 +157,17 @@ func (d *DataBases) GetSignalInfoFromCacheByClientMsgID(clientMsgID string) (inv
 	switch req2 := req.Payload.(type) {
 	case *pbRtc.SignalReq_Invite:
 		invitationInfo.Invitation = req2.Invite.Invitation
+		invitationInfo.OpUserID = req2.Invite.OpUserID
 	case *pbRtc.SignalReq_InviteInGroup:
 		invitationInfo.Invitation = req2.InviteInGroup.Invitation
+		invitationInfo.OpUserID = req2.InviteInGroup.OpUserID
 	}
 	return invitationInfo, err
 }
 
 func (d *DataBases) GetAvailableSignalInvitationInfo(userID string) (invitationInfo *pbRtc.SignalInviteReq, err error) {
 	keyList := SignalListCache + userID
-	result := d.rdb.RPop(context.Background(), keyList)
+	result := d.rdb.LPop(context.Background(), keyList)
 	if err = result.Err(); err != nil {
 		return nil, utils.Wrap(err, "GetAvailableSignalInvitationInfo failed")
 	}
@@ -170,14 +180,14 @@ func (d *DataBases) GetAvailableSignalInvitationInfo(userID string) (invitationI
 	if err != nil {
 		return nil, utils.Wrap(err, "GetSignalInfoFromCacheByClientMsgID")
 	}
-	err = d.delUserSingalList(userID)
+	err = d.DelUserSignalList(userID)
 	if err != nil {
 		return nil, utils.Wrap(err, "GetSignalInfoFromCacheByClientMsgID")
 	}
 	return invitationInfo, nil
 }
 
-func (d *DataBases) delUserSingalList(userID string) error {
+func (d *DataBases) DelUserSignalList(userID string) error {
 	keyList := SignalListCache + userID
 	err := d.rdb.Del(context.Background(), keyList).Err()
 	return err

pkg/common/kafka/producer.go

@@ -2,6 +2,7 @@ package kafka
 
 import (
 	log2 "Open_IM/pkg/common/log"
+	"errors"
 	"github.com/Shopify/sarama"
 	"github.com/golang/protobuf/proto"
 )
@@ -32,18 +33,22 @@ func NewKafkaProducer(addr []string, topic string) *Producer {
 	return &p
 }
 
-func (p *Producer) SendMessage(m proto.Message, key ...string) (int32, int64, error) {
+func (p *Producer) SendMessage(m proto.Message, key string, operationID string) (int32, int64, error) {
+	log2.Info(operationID, "SendMessage", "key ", key, m.String(), p.producer)
 	kMsg := &sarama.ProducerMessage{}
 	kMsg.Topic = p.topic
-	if len(key) == 1 {
-		kMsg.Key = sarama.StringEncoder(key[0])
-	}
+	kMsg.Key = sarama.StringEncoder(key)
 	bMsg, err := proto.Marshal(m)
 	if err != nil {
-		log2.Error("", "", "proto marshal err = %s", err.Error())
+		log2.Error(operationID, "", "proto marshal err = %s", err.Error())
 		return -1, -1, err
 	}
+	if len(bMsg) == 0 {
+		return 0, 0, errors.New("msg content is nil")
+	}
 	kMsg.Value = sarama.ByteEncoder(bMsg)
-
-	return p.producer.SendMessage(kMsg)
+	log2.Info(operationID, "ByteEncoder SendMessage begin", "key ", kMsg, p.producer)
+	a, b, c := p.producer.SendMessage(kMsg)
+	log2.Info(operationID, "ByteEncoder SendMessage end", "key ", kMsg, p.producer)
+	return a, b, c
 }