func (h *Handler) SendMsg(head *common.PackageHead, jsonBody []byte, tail *common.PackageTail) ([]byte, error) {
var req SendUserMsg
if err := json.Unmarshal(jsonBody, &req); err != nil {
return nil, errors.As(err, string(jsonBody))
}
var msg message.UserMsgItem
msg.SendTime = uint32(time.Now().Unix())
msg.MsgId = message.GetUserMsgID()
msg.FromUid = tail.UID
msg.ToUid = req.ToUid
msg.Content = req.Content
msg.Type = req.Type
msg.ExtraData = req.ExtraData
msgBody, err := json.Marshal(msg)
if err != nil {
return nil, errors.As(err, msg)
}
msgBuf := common.GetBuffer()
defer common.PutBuffer(msgBuf)
head.PkgLen = uint16(common.DATA_PACKAGE_HEAD_SIZE + len(jsonBody))
if err := common.Package(msgBuf, head, msgBody, tail); err != nil {
return nil, errors.As(err)
}
common.NsqPublish(common.MSG_CENTER_TOPIC, msgBuf.Bytes())
message.SaveUserMsg(&msg)
respStr := fmt.Sprintf(`{"msgid":%d,"sendtime":%d}`, msg.MsgId, msg.SendTime)
return []byte(respStr), nil
}
func (c *Client) Produce(msg *protocol.DataPackage) error {
head := msg.Head
buf := protocol.GetBuffer()
defer protocol.PutBuffer(buf)
if err := msg.Package(buf); err != nil {
return errors.As(err)
}
if head.Command == protocol.CLIENT_CMD_SEND_USER_MSG || head.Command == protocol.CLIENT_CMD_RECV_USER_MSG {
if err := common.NsqPublish(common.MSG_SERVER_TOPIC, buf.Bytes()); err != nil {
return errors.As(err)
}
syslog.Debug("gateway --> msg_server publish message:", head, msg.Tail)
} else if head.Command == protocol.CLIENT_CMD_USER_LOGIN || head.Command == protocol.CLIENT_CMD_USER_REGISTER {
if err := common.NsqPublish(common.USER_CENTER_TOPIC, buf.Bytes()); err != nil {
return errors.As(err)
}
syslog.Debug("gateway --> user_center publish message:", head, msg.Tail)
}
return nil
}
func (h *Handler) HandleMessage(message *nsq.Message) error {
dataPackage := common.GetDataPackage()
defer common.PutDataPackage(dataPackage)
if err := dataPackage.Unpackage(message.Body); err != nil {
syslog.Warn(err)
return nil
}
head := &dataPackage.Head
jsonStr := dataPackage.BodyData()
tail := &dataPackage.Tail
var err error = nil
resp := []byte("")
switch head.Command {
case common.XXX_CMD_SEND_USER_MSG:
resp, err = h.SendMsg(head, jsonStr, tail)
case common.XXX_CMD_RECV_USER_MSG:
//resp, err = h.ReceivedUserMsg(head, jsonStr, &tail)
common.NsqPublish(common.MSG_STORE_TOPIC, message.Body)
default:
syslog.Info("invalid cmd:", head.Command, *tail)
return nil
}
if err != nil {
syslog.Warn("msg_server msg handle failed:", err, head, tail)
head.ErrorCode = uint32(errors.Code(err))
resp = []byte("")
}
head.PkgLen = uint16(common.DATA_PACKAGE_HEAD_SIZE + len(resp))
respBuf := common.GetBuffer()
defer common.PutBuffer(respBuf)
if err := common.Package(respBuf, head, resp, tail); err != nil {
syslog.Info(err)
return nil
}
topic := fmt.Sprintf("conn_%s_%d", util.IPToStr(tail.IP), tail.Port)
common.NsqPublish(topic, respBuf.Bytes())
return nil
}
func (h *Handler) HandleMessage(message *nsq.Message) error {
dataPackage := common.GetDataPackage()
defer common.PutDataPackage(dataPackage)
if err := dataPackage.Unpackage(message.Body); err != nil {
syslog.Warn(err)
return nil
}
head := &dataPackage.Head
jsonStr := dataPackage.BodyData()
tail := &dataPackage.Tail
switch head.Command {
case common.XXX_CMD_SEND_USER_MSG:
default:
syslog.Warn("Invalid Cmd :", head.Command, *tail)
}
// get user state
us, err := user.GetUserState(tail.UID)
if err != nil {
syslog.Info("GetUserState failed!!!", tail)
return nil
}
// not online
if us.Online == false {
syslog.Debug("client not online!!! uid:", tail.UID)
return nil
}
tail.IP = us.ConnIP
tail.Port = us.ConnPort
tail.SID = us.Sid
tail.UID = us.Uid
respBuf := common.GetBuffer()
defer common.PutBuffer(respBuf)
if err := common.Package(respBuf, head, jsonStr, tail); err != nil {
syslog.Info(err)
return nil
}
topic := fmt.Sprintf("conn_%s_%d", util.IPToStr(tail.IP), tail.Port)
common.NsqPublish(topic, respBuf.Bytes())
return nil
}
func (h *DBHandler) HandleMessage(message *nsq.Message) error {
var resp []byte
var err error
defer func() {
if err != nil {
syslog.Warn(err)
}
}()
dataPackage := protocol.GetDataPackage()
defer protocol.PutDataPackage(dataPackage)
if err := dataPackage.Unpackage(message.Body); err != nil {
return nil
}
head := &dataPackage.Head
jsonStr := dataPackage.BodyData()
tail := &dataPackage.Tail
syslog.Debug(*head, string(jsonStr), *tail)
switch head.Command {
case protocol.CLIENT_CMD_USER_REGISTER:
resp = h.Register(head, jsonStr, tail)
case protocol.CLIENT_CMD_USER_LOGIN:
resp = h.Login(head, jsonStr, tail)
default:
syslog.Debug("invalid cmd:", head.Command, *tail)
return nil
}
respBuf := protocol.GetBuffer()
defer protocol.PutBuffer(respBuf)
head.PkgLen = uint16(protocol.DATA_PACKAGE_HEAD_SIZE + len(resp))
binary.Write(respBuf, binary.BigEndian, head)
binary.Write(respBuf, binary.BigEndian, resp)
binary.Write(respBuf, binary.BigEndian, tail)
topic := fmt.Sprintf("conn_%s_%d", util.IPToStr(tail.IP), tail.Port)
common.NsqPublish(topic, respBuf.Bytes())
syslog.Debug2("db_server --> conn_server publish:", topic, head, string(resp), tail)
return nil
}