func (self *ProtoProc) procGetTopicList(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procGetTopicList") var err error resp := protocol.NewCmdSimple(protocol.RSP_GET_TOPIC_LIST_CMD) clientID := session.State.(*base.SessionState).ClientID //clientType := session.State.(*base.SessionState).ClientType sessionCacheData, err := self.msgServer.sessionCache.Get(clientID) if sessionCacheData == nil { log.Warningf("Client %s not online", clientID) err = common.NOT_ONLINE goto ErrOut } ErrOut: if err != nil { resp.AddArg(err.Error()) } else { resp.AddArg(protocol.RSP_SUCCESS) resp.AddArg(strconv.Itoa(len(sessionCacheData.TopicList))) for _, topic := range sessionCacheData.TopicList { resp.AddArg(topic) } } err = session.Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) } return err }
/* client -> MsgServer REQ_QUIT_TOPIC_CMD arg0: TopicName //群组名 MsgServer -> client RSP_QUIT_TOPIC_CMD arg0: SUCCESS/ERROR */ func (self *ProtoProc) procQuitTopic(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procQuitTopic") var err error if len(cmd.GetArgs()) != 1 { err = common.SYNTAX_ERROR } else { topicName := cmd.GetArgs()[0] clientID := session.State.(*base.SessionState).ClientID err = self.msgServer.procQuitTopic(clientID, topicName) } resp := protocol.NewCmdSimple(protocol.RSP_QUIT_TOPIC_CMD) if err != nil { resp.AddArg(err.Error()) } else { resp.AddArg(protocol.RSP_SUCCESS) } err = session.Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) } return err }
func (self *Router) handleMsgServerClient(msc *libnet.Session) { msc.Process(func(msg *libnet.InBuffer) error { log.Info("msg_server", msc.Conn().RemoteAddr().String(), " say: ", string(msg.Data)) var c protocol.CmdInternal pp := NewProtoProc(self) err := json.Unmarshal(msg.Data, &c) if err != nil { log.Error("error:", err) return err } switch c.GetCmdName() { case protocol.REQ_SEND_P2P_MSG_CMD: err := pp.procSendMsgP2P(&c, msc) if err != nil { log.Warning(err.Error()) } case protocol.IND_ACK_P2P_STATUS_CMD: err := pp.procAckP2pStatus(&c, msc) if err != nil { log.Warning(err.Error()) } case protocol.REQ_SEND_TOPIC_MSG_CMD: err := pp.procSendMsgTopic(&c, msc) if err != nil { log.Warning(err.Error()) } } return nil }) }
/* client -> MsgServer REQ_JOIN_TOPIC_CMD arg0: TopicName //群组名 arg1: ClientName //用户在Topic中的Name, 比如老爸/老妈 MsgServer -> client RSP_JOIN_TOPIC_CMD arg0: SUCCESS/FAILED */ func (self *ProtoProc) procJoinTopic(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procJoinTopic") var err error if len(cmd.GetArgs()) != 2 { err = common.SYNTAX_ERROR } else { topicName := cmd.GetArgs()[0] clientName := cmd.GetArgs()[1] clientID := session.State.(*base.SessionState).ClientID clientType := session.State.(*base.SessionState).ClientType member := mongo_store.NewMember(clientID, clientName, clientType) err = self.msgServer.procJoinTopic(member, topicName) } resp := protocol.NewCmdSimple(protocol.RSP_JOIN_TOPIC_CMD) if err != nil { resp.AddArg(err.Error()) } else { resp.AddArg(protocol.RSP_SUCCESS) } err = session.Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) } return err }
func (self *ProtoProc) procClientID(cmd protocol.Cmd, session *libnet.Session) error { glog.Info("procClientID") var err error ID := cmd.GetArgs()[0] sessionStoreData := storage.NewSessionStoreData(cmd.GetArgs()[0], session.Conn().RemoteAddr().String(), self.msgServer.cfg.LocalIP, strconv.FormatUint(session.Id(), 10)) glog.Info(sessionStoreData) args := make([]string, 0) args = append(args, cmd.GetArgs()[0]) CCmd := protocol.NewCmdInternal(protocol.STORE_SESSION_CMD, args, sessionStoreData) glog.Info(CCmd) if self.msgServer.channels[protocol.SYSCTRL_CLIENT_STATUS] != nil { _, err = self.msgServer.channels[protocol.SYSCTRL_CLIENT_STATUS].Channel.Broadcast(libnet.Json(CCmd)) if err != nil { glog.Error(err.Error()) return err } } self.msgServer.sessions[cmd.GetArgs()[0]] = session self.msgServer.sessions[cmd.GetArgs()[0]].State = base.NewSessionState(true, cmd.GetArgs()[0]) err = self.procOfflineMsg(session, ID) if err != nil { glog.Error(err.Error()) return err } return nil }
/* client -> MsgServer REQ_ADD_2_TOPIC_CMD arg0: TopicName //群组名 arg1: NewClientID //用户ID arg2: NewClientName //用户在Topic中的Name, 对于device, 可以是儿子/女儿 MsgServer -> client RSP_ADD_2_TOPIC_CMD arg0: SUCCESS/FAILED arg1: TopicName arg2: ClientID arg3: ClientType */ func (self *ProtoProc) procAdd2Topic(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procAdd2Topic") var err error topicName := cmd.GetArgs()[0] mID := cmd.GetArgs()[1] mName := cmd.GetArgs()[2] ClientID := session.State.(*base.SessionState).ClientID ClientType := session.State.(*base.SessionState).ClientType mType := protocol.DEV_TYPE_CLIENT resp := protocol.NewCmdSimple(protocol.RSP_ADD_2_TOPIC_CMD) if len(cmd.GetArgs()) != 3 { err = common.SYNTAX_ERROR } else // only DEV_TYPE_CLIENT CAN create topic if ClientType != protocol.DEV_TYPE_CLIENT { err = common.DENY_ACCESS } else { // check whether the topic exist topicCacheData, _ := self.msgServer.topicCache.Get(topicName) if topicCacheData == nil { log.Infof("TOPIC %s not exist in CACHE", topicName) err = common.TOPIC_NOT_EXIST } else // only topic creater can do this if topicCacheData.CreaterID != ClientID { log.Warningf("ClientID %s is not creater of topic %s", ClientID, topicName) err = common.DENY_ACCESS } else { // New Member MUST be online sessionCacheData, _ := self.msgServer.sessionCache.Get(mID) if sessionCacheData == nil { log.Warningf("Client %s not online", mID) err = common.NOT_ONLINE } else { mType = sessionCacheData.ClientType member := mongo_store.NewMember(mID, mName, mType) err = self.msgServer.procJoinTopic(member, topicName) } } } if err != nil { resp.AddArg(err.Error()) } else { resp.AddArg(protocol.RSP_SUCCESS) } resp.AddArg(topicName) resp.AddArg(mID) resp.AddArg(mType) err = session.Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) } return err }
func (self *Manager) handleMsgServerClient(msc *libnet.Session) { msc.Process(func(msg *libnet.InBuffer) error { log.Info("msg_server", msc.Conn().RemoteAddr().String(), "say:", string(msg.Data)) self.parseProtocol(msg.Data, msc) return nil }) }
func handleSession(ms *MsgServer, session *libnet.Session) { session.Process(func(msg *libnet.InBuffer) error { err := ms.parseProtocol(msg.Data, session) if err != nil { log.Error(err.Error()) } return nil }) }
func handleSession(gw *Gateway, session *libnet.Session) { session.Process(func(msg *libnet.InBuffer) error { err := gw.parseProtocol(msg.Data, session) if err != nil { log.Error(err.Error()) } return nil }) }
func handleSession(gw *Gateway, session *libnet.Session) { session.Process(func(msg *libnet.InBuffer) error { log.Info("gateway received:===", string(msg.Data), "===") err := gw.parseProtocol(msg.Data, session) if err != nil { log.Error("error:", err) } return err }) }
func handleSession(gw *Gateway, session *libnet.Session) { //glog.Info("handleSession") session.Process(func(msg *libnet.InBuffer) error { glog.Info(string(msg.Data)) err := gw.parseProtocol(msg.Data, session) if err != nil { glog.Error(err.Error()) } return nil }) }
/* client -> MsgServer REQ_KICK_TOPIC_CMD arg0: TopicName //群组名 arg1: NewClientID //待移除的成员用户ID MsgServer -> client RSP_KICK_TOPIC_CMD arg0: SUCCESS/FAILED */ func (self *ProtoProc) procKickTopic(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procKickTopic") var err error var topicCacheData *redis_store.TopicCacheData topicName := cmd.GetArgs()[0] mID := cmd.GetArgs()[1] ClientID := session.State.(*base.SessionState).ClientID ClientType := session.State.(*base.SessionState).ClientType resp := protocol.NewCmdSimple(protocol.RSP_KICK_TOPIC_CMD) if len(cmd.GetArgs()) != 2 { err = common.SYNTAX_ERROR goto ErrOut } // only DEV_TYPE_CLIENT CAN do this if ClientType != protocol.DEV_TYPE_CLIENT { err = common.DENY_ACCESS goto ErrOut } // check whether the topic exist topicCacheData, err = self.msgServer.topicCache.Get(topicName) if topicCacheData == nil { log.Warningf("TOPIC %s not exist", topicName) err = common.TOPIC_NOT_EXIST } else // only topic creater can do this if topicCacheData.CreaterID != ClientID { log.Warningf("ClientID %s is not creater of topic %s", ClientID, topicName) err = common.DENY_ACCESS } else { err = self.msgServer.procQuitTopic(mID, topicName) } ErrOut: if err != nil { resp.AddArg(err.Error()) } else { resp.AddArg(protocol.RSP_SUCCESS) } err = session.Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) } return err }
func (self *Monitor) handleMsgServerClient(msc *libnet.Session) { msc.Process(func(msg *libnet.InBuffer) error { //log.Info("msg_server", msc.Conn().RemoteAddr().String()," say: ", string(msg.Data)) var c protocol.CmdMonitor err := json.Unmarshal(msg.Data, &c) if err != nil { log.Error("error:", err) return err } return nil }) }
func (self *ProtoProc) procLogin(cmd protocol.Cmd, session *libnet.Session) error { //log.Info("procLogin") var err error var uuid string var msgServer string ClientID := cmd.GetArgs()[0] ClientType := cmd.GetArgs()[1] ClientPwd := "" if len(cmd.GetArgs()) == 3 { ClientPwd = cmd.GetArgs()[2] } // get the session cache sessionCacheData, err := self.gateway.sessionCache.Get(ClientID) if sessionCacheData != nil { log.Warningf("ID %s already login", ClientID) msgServer = sessionCacheData.MsgServerAddr uuid = sessionCacheData.ID } else { // choose msg server and allocate UUID msgServer = self.procGetMinLoadMsgServer() uuid = common.NewV4().String() // get the session store to check whether registered sessionStoreData, _ := self.gateway.mongoStore.GetSessionFromCid(ClientID) if sessionStoreData == nil { log.Warningf("ID %s not registered", ClientID) // for store data sessionStoreData = mongo_store.NewSessionStoreData(ClientID, ClientPwd, ClientType) log.Info(sessionStoreData) common.StoreData(self.gateway.mongoStore, sessionStoreData) } // for cache data, MsgServer MUST update local & remote addr. sessionCacheData = redis_store.NewSessionCacheData(sessionStoreData, session.Conn().RemoteAddr().String(), msgServer, uuid) log.Info(sessionCacheData) self.gateway.sessionCache.Set(sessionCacheData) } // resp := protocol.NewCmdSimple(protocol.RSP_LOGIN_CMD) resp.AddArg(protocol.RSP_SUCCESS) resp.AddArg(uuid) resp.AddArg(msgServer) log.Info("Resp | ", resp) if session != nil { err = session.Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) } session.Close() log.Info("client ", session.Conn().RemoteAddr().String(), " | close") } return nil }
func (self *ProtoProc) procGetTopicProfile(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procGetTopicProfile") var err error var topicCacheData *redis_store.TopicCacheData topicName := "<N/A>" resp := protocol.NewCmdSimple(protocol.RSP_GET_TOPIC_PROFILE_CMD) if len(cmd.GetArgs()) != 1 { err = common.SYNTAX_ERROR } else { topicName = cmd.GetArgs()[0] clientID := session.State.(*base.SessionState).ClientID //clientType := session.State.(*base.SessionState).ClientType // check whether the topic exist topicCacheData, err = self.msgServer.topicCache.Get(topicName) if topicCacheData == nil { log.Warningf("TOPIC %s not exist", topicName) err = common.TOPIC_NOT_EXIST } else if topicCacheData.MemberExist(clientID) == false { log.Warningf("%s not the member of topic %d", clientID, topicName) err = common.DENY_ACCESS } } if err != nil { resp.AddArg(err.Error()) resp.AddArg(topicName) } else { resp.AddArg(protocol.RSP_SUCCESS) resp.AddArg(topicName) resp.AddArg(topicCacheData.CreaterID) for _, member := range topicCacheData.MemberList { resp.AddArg(member.ID) resp.AddArg(member.Name) resp.AddArg(member.Type) } } err = session.Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) } return err }
func (self *ProtoProc) procLogout(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procLogout") var err error ClientID := session.State.(*base.SessionState).ClientID resp := protocol.NewCmdSimple(protocol.RSP_LOGOUT_CMD) resp.AddArg(protocol.RSP_SUCCESS) err = session.Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) } self.msgServer.procOffline(ClientID) self.msgServer.sessionCache.Delete(ClientID) return err }
/* MsgServer -> Router REQ_SEND_P2P_MSG_CMD arg0: Sent2ID //接收方用户ID arg1: Msg //消息内容 arg2: FromID //发送方用户ID arg3: uuid //MsgServer分配的消息uuid */ func (self *ProtoProc) procSendMsgP2P(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procSendMsgP2P") var err error send2ID := cmd.GetArgs()[0] send2Msg := cmd.GetArgs()[1] log.Info(send2Msg) self.Router.readMutex.Lock() defer self.Router.readMutex.Unlock() cacheSession, err := self.Router.sessionCache.Get(send2ID) if cacheSession == nil || cacheSession.Alive == false { storeSession, err := self.Router.mongoStore.GetSessionFromCid(send2ID) if err != nil { log.Warningf("ID %s not registered, msg dropped", send2ID) return err } log.Info(storeSession) log.Warningf("ID registered but offline: %s", send2ID) cmd.ChangeCmdName(protocol.ROUTE_SEND_P2P_MSG_CMD) //ms := self.Router.cfg.MsgServerList[0] ms := session.Conn().RemoteAddr().String() err = self.Router.msgServerClientMap[ms].Send(libnet.Json(cmd)) if err != nil { log.Error("error:", err) return err } } else { log.Info(cacheSession.MsgServerAddr) cmd.ChangeCmdName(protocol.ROUTE_SEND_P2P_MSG_CMD) log.Info(cmd) err = self.Router.msgServerClientMap[cacheSession.MsgServerAddr].Send(libnet.Json(cmd)) if err != nil { log.Error("error:", err) return err } } return nil }
/* Router -> MsgServer ROUTE_SEND_TOPIC_MSG_CMD arg0: ClientID //发送方用户ID arg1: ClientType //发送方终端类型,是client还是device arg2: Msg //消息内容 arg3: TopicName //群组名, device无须提供 */ func (self *ProtoProc) procSendMsgTopic(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procSendMsgTopic") var err error ms := session.Conn().RemoteAddr().String() //send2Msg := cmd.GetArgs()[0] topicName := cmd.GetArgs()[1] //fromID := cmd.GetArgs()[2] //fromType := cmd.GetArgs()[3] // check whether the topic exist topicCacheData, err := self.Router.topicCache.Get(topicName) if topicCacheData == nil { log.Warningf("TOPIC %s not exist: %s", topicName, err.Error()) return err } cmd.ChangeCmdName(protocol.ROUTE_SEND_TOPIC_MSG_CMD) log.Info(protocol.ROUTE_SEND_TOPIC_MSG_CMD) log.Info(cmd) for ip, num := range topicCacheData.AliveMemberNumMap { if num > 0 { log.Warningf("topic %s has %d member(s) in ip %s", topicName, num, ip) if ip != ms { // not in this server, routing it err = self.Router.msgServerClientMap[ip].Send(libnet.Json(cmd)) if err != nil { log.Error("error:", err) return err } } } } return nil }
func (self *Router) handleMsgServerClient(msc *libnet.Session) { msc.Process(func(msg *libnet.InBuffer) error { log.Info("msg_server", msc.Conn().RemoteAddr().String(), " say: ", string(msg.Data)) var c protocol.CmdInternal pp := NewProtoProc(self) err := json.Unmarshal(msg.Data, &c) if err != nil { log.Error("error:", err) return err } switch c.GetCmdName() { case protocol.SEND_MESSAGE_P2P_CMD: err := pp.procSendMsgP2P(c, msc) if err != nil { log.Warning(err.Error()) } case protocol.CREATE_TOPIC_CMD: err := pp.procCreateTopic(c, msc) if err != nil { log.Warning(err.Error()) } case protocol.JOIN_TOPIC_CMD: err := pp.procJoinTopic(c, msc) if err != nil { log.Warning(err.Error()) } case protocol.SEND_MESSAGE_TOPIC_CMD: err := pp.procSendMsgTopic(c, msc) if err != nil { log.Warning(err.Error()) } } return nil }) }
func (self *ProtoProc) procReqMsgServer(cmd protocol.Cmd, session *libnet.Session) error { //log.Info("procReqMsgServer") var err error msgServer := common.SelectServer(self.gateway.cfg.MsgServerList, self.gateway.cfg.MsgServerNum) resp := protocol.NewCmdSimple(protocol.SELECT_MSG_SERVER_FOR_CLIENT_CMD) resp.AddArg(msgServer) log.Info("Resp | ", resp) if session != nil { err = session.Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) } session.Close() log.Info("client ", session.Conn().RemoteAddr().String(), " | close") } return nil }
func (self *ProtoProc) procJoinTopic(cmd protocol.Cmd, session *libnet.Session) error { glog.Info("procJoinTopic") var err error if len(cmd.GetArgs()) != 2 { return CMD_NOT_CORRECT } topicName := cmd.GetArgs()[0] clientID := cmd.GetArgs()[1] if self.msgServer.topics[topicName] == nil { glog.Warning("no topic in this server :" + topicName) t, err := self.findTopicMsgAddr(topicName) if err != nil { glog.Warningf("no topicName : %s", topicName) return err } resp := protocol.NewCmdSimple(protocol.LOCATE_TOPIC_MSG_ADDR_CMD) resp.AddArg(t.MsgServerAddr) resp.AddArg(topicName) err = session.Send(libnet.Json(resp)) if err != nil { glog.Error(err.Error()) return err } return err } else { t, err := self.findTopicMsgAddr(topicName) if err != nil { glog.Warningf("no topicName : %s", topicName) return err } resp := protocol.NewCmdSimple(protocol.LOCATE_TOPIC_MSG_ADDR_CMD) resp.AddArg(t.MsgServerAddr) resp.AddArg(topicName) err = session.Send(libnet.Json(resp)) if err != nil { glog.Error(err.Error()) return err } } m := storage.NewMember(clientID) self.msgServer.topics[topicName].ClientIDList = append(self.msgServer.topics[topicName].ClientIDList, clientID) self.msgServer.topics[topicName].AddMember(m) self.msgServer.topics[topicName].Channel.Join(session, nil) args := make([]string, 0) args = append(args, topicName) CCmd := protocol.NewCmdInternal(protocol.STORE_TOPIC_CMD, args, self.msgServer.topics[topicName].TSD) glog.Info(CCmd) if self.msgServer.channels[protocol.SYSCTRL_TOPIC_STATUS] != nil { _, err = self.msgServer.channels[protocol.SYSCTRL_TOPIC_STATUS].Channel.Broadcast(libnet.Json(CCmd)) if err != nil { glog.Error(err.Error()) return err } } return nil }
/* device/client -> MsgServer -> Router REQ_SEND_TOPIC_MSG_CMD arg0: Msg //消息内容 arg1: TopicName //群组名, device无须提供 返回给消息发送者的消息 MsgServer -> device/client RSP_SEND_TOPIC_MSG_CMD arg0: SUCCESS/FAILED 通过Router转发消息(对终端开发者不可见) Router -> MsgServer ROUTE_SEND_TOPIC_MSG_CMD arg0: Msg //消息内容 arg1: TopicName //群组名 arg2: ClientID //发送方用户ID arg3: ClientType //发送方终端类型,是client还是device 发送给消息接受者的消息 MsgServer -> device/client REQ_SEND_TOPIC_MSG_CMD arg0: Msg //消息内容 arg1: TopicName //群组名 arg2: ClientID //发送方用户ID arg3: ClientType //发送方终端类型,是client还是device */ func (self *ProtoProc) procSendTopicMsg(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procSendTopicMsg") var err error var topicName string var topicCacheData *redis_store.TopicCacheData var sessionCacheData *redis_store.SessionCacheData //var sessionStoreData *mongo_store.SessionStoreData msg := cmd.GetArgs()[0] resp := protocol.NewCmdSimple(protocol.RSP_SEND_TOPIC_MSG_CMD) ClientID := session.State.(*base.SessionState).ClientID ClientType := session.State.(*base.SessionState).ClientType if ClientType == protocol.DEV_TYPE_CLIENT { if len(cmd.GetArgs()) != 2 { err = common.SYNTAX_ERROR goto ErrOut } } else if len(cmd.GetArgs()) != 1 { err = common.SYNTAX_ERROR goto ErrOut } // get session cache sessionCacheData, err = self.msgServer.sessionCache.Get(ClientID) if sessionCacheData == nil { log.Errorf("ID %s cache missing", ClientID) err = common.NOT_ONLINE goto ErrOut } else if ClientType == protocol.DEV_TYPE_WATCH { topicName = sessionCacheData.GetTopics()[0] } else { topicName = cmd.GetArgs()[1] } // check whether the topic exist topicCacheData, err = self.msgServer.topicCache.Get(topicName) if topicCacheData == nil { log.Warningf("TOPIC %s not exist", topicName) err = common.TOPIC_NOT_EXIST } else { topic_msg_resp := protocol.NewCmdSimple(cmd.GetCmdName()) topic_msg_resp.AddArg(msg) topic_msg_resp.AddArg(topicName) topic_msg_resp.AddArg(ClientID) topic_msg_resp.AddArg(ClientType) if topicCacheData.AliveMemberNumMap[self.msgServer.cfg.LocalIP] > 1 { // exactly in this server, just broadcasting topic_msg_resp.ChangeCmdName(protocol.IND_SEND_TOPIC_MSG_CMD) log.Warningf("topic %s has %d member(s) in this server", topicName, topicCacheData.AliveMemberNumMap[self.msgServer.cfg.LocalIP]) for _, mID := range topicCacheData.MemberList { if mID.ID != ClientID && self.msgServer.sessions[mID.ID] != nil { self.msgServer.sessions[mID.ID].Send(libnet.Json(topic_msg_resp)) if err != nil { log.Fatalln(err.Error()) } } } } if self.msgServer.channels[protocol.SYSCTRL_SEND] != nil { //topic_msg_resp.ChangeCmdName(protocol.ROUTE_SEND_TOPIC_MSG_CMD) topic_msg_resp.ChangeCmdName(protocol.REQ_SEND_TOPIC_MSG_CMD) for ip, num := range topicCacheData.AliveMemberNumMap { if num > 0 { log.Warningf("topic %s has %d member(s) in ip %s", topicName, num, ip) if ip != self.msgServer.cfg.LocalIP { // not in this server, routing it _, err = self.msgServer.channels[protocol.SYSCTRL_SEND].Channel.Broadcast(libnet.Json(topic_msg_resp)) if err != nil { log.Error(err.Error()) } break } } } } } ErrOut: if err != nil { resp.AddArg(err.Error()) } else { resp.AddArg(protocol.RSP_SUCCESS) } err = session.Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) } return err }
func (self *MsgServer) parseProtocol(cmd []byte, session *libnet.Session) error { var c protocol.CmdSimple // receive msg, that means client alive if session.State != nil { self.scanSessionMutex.Lock() session.State.(*base.SessionState).Alive = true self.scanSessionMutex.Unlock() } err := json.Unmarshal(cmd, &c) if err != nil { log.Error("error:", err) return err } pp := NewProtoProc(self) self.readMutex.Lock() defer self.readMutex.Unlock() log.Infof("[%s]->[%s]", session.Conn().RemoteAddr().String(), self.cfg.LocalIP) log.Info(c) switch c.GetCmdName() { case protocol.SEND_PING_CMD: err = pp.procPing(&c, session) if err != nil { log.Error("error:", err) return err } case protocol.SUBSCRIBE_CHANNEL_CMD: pp.procSubscribeChannel(&c, session) case protocol.REQ_LOGIN_CMD: err = pp.procLogin(&c, session) if err != nil { log.Error("error:", err) return err } case protocol.REQ_LOGOUT_CMD: err = pp.procLogout(&c, session) if err != nil { log.Error("error:", err) return err } case protocol.REQ_SEND_P2P_MSG_CMD: err = pp.procSendMessageP2P(&c, session) if err != nil { log.Error("error:", err) return err } case protocol.ROUTE_SEND_P2P_MSG_CMD: err = pp.procRouteMessageP2P(&c, session) if err != nil { log.Error("error:", err) return err } // p2p ack case protocol.IND_ACK_P2P_STATUS_CMD: err = pp.procP2pAck(&c, session) if err != nil { log.Error("error:", err) return err } // p2p ack case protocol.ROUTE_ACK_P2P_STATUS_CMD: err = pp.procP2pAck(&c, session) if err != nil { log.Error("error:", err) return err } case protocol.REQ_SEND_TOPIC_MSG_CMD: err = pp.procSendTopicMsg(&c, session) if err != nil { log.Error("error:", err) return err } case protocol.ROUTE_SEND_TOPIC_MSG_CMD: err = pp.procRouteTopicMsg(&c, session) if err != nil { log.Error("error:", err) return err } case protocol.REQ_CREATE_TOPIC_CMD: err = pp.procCreateTopic(&c, session) if err != nil { log.Error("error:", err) return err } case protocol.REQ_ADD_2_TOPIC_CMD: err = pp.procAdd2Topic(&c, session) if err != nil { log.Error("error:", err) return err } case protocol.REQ_KICK_TOPIC_CMD: err = pp.procKickTopic(&c, session) if err != nil { log.Error("error:", err) return err } case protocol.REQ_JOIN_TOPIC_CMD: err = pp.procJoinTopic(&c, session) if err != nil { log.Error("error:", err) return err } case protocol.REQ_QUIT_TOPIC_CMD: err = pp.procQuitTopic(&c, session) if err != nil { log.Error("error:", err) return err } case protocol.REQ_GET_TOPIC_LIST_CMD: err = pp.procGetTopicList(&c, session) if err != nil { log.Error("error:", err) return err } case protocol.REQ_GET_TOPIC_PROFILE_CMD: err = pp.procGetTopicProfile(&c, session) if err != nil { log.Error("error:", err) return err } } return err }
func (self *ProtoProc) procLogin(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procLogin") var err error ClientID := cmd.GetArgs()[0] uuid := cmd.GetArgs()[1] resp := protocol.NewCmdSimple(protocol.RSP_LOGIN_CMD) // for cache data sessionCacheData, err := self.msgServer.sessionCache.Get(ClientID) if err != nil { log.Warningf("no ID : %s", ClientID) } else if sessionCacheData.ID != uuid { log.Warningf("ID(%s) & uuid(%s) not matched", ClientID, uuid) err = common.NOT_LOGIN } if err == nil { resp.AddArg(protocol.RSP_SUCCESS) } else { resp.AddArg(protocol.RSP_ERROR) } err2 := session.Send(libnet.Json(resp)) if err2 != nil { log.Error(err2.Error()) return err2 } if err != nil { return err } // update the session cache sessionCacheData.ClientAddr = session.Conn().RemoteAddr().String() sessionCacheData.MsgServerAddr = self.msgServer.cfg.LocalIP sessionCacheData.Alive = true self.msgServer.sessionCache.Set(sessionCacheData) log.Info(sessionCacheData) self.msgServer.procOffline(ClientID) self.msgServer.procOnline(ClientID) /* args := make([]string, 0) args = append(args, cmd.GetArgs()[0]) CCmd := protocol.NewCmdInternal(protocol.CACHE_SESSION_CMD, args, sessionCacheData) log.Info(CCmd) if self.msgServer.channels[protocol.SYSCTRL_CLIENT_STATUS] != nil { _, err = self.msgServer.channels[protocol.SYSCTRL_CLIENT_STATUS].Channel.Broadcast(libnet.Json(CCmd)) if err != nil { log.Error(err.Error()) return err } } // for store data sessionStoreData := mongo_store.SessionStoreData{ID, session.Conn().RemoteAddr().String(), self.msgServer.cfg.LocalIP, true} log.Info(sessionStoreData) args = make([]string, 0) args = append(args, cmd.GetArgs()[0]) CCmd = protocol.NewCmdInternal(protocol.STORE_SESSION_CMD, args, sessionStoreData) log.Info(CCmd) if self.msgServer.channels[protocol.STORE_CLIENT_INFO] != nil { _, err = self.msgServer.channels[protocol.STORE_CLIENT_INFO].Channel.Broadcast(libnet.Json(CCmd)) if err != nil { log.Error(err.Error()) return err } } */ self.msgServer.sessions[ClientID] = session self.msgServer.sessions[ClientID].State = base.NewSessionState(true, ClientID, sessionCacheData.ClientType) err = self.procOfflineMsg(session, ClientID) if err != nil { log.Error(err.Error()) return err } return nil }
func (self *ProtoProc) procSendMessageP2P(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procSendMessageP2P") var err error var sessionCacheData *redis_store.SessionCacheData var sessionStoreData *mongo_store.SessionStoreData var uuid string var send2ID string var send2Msg string fromID := session.State.(*base.SessionState).ClientID resp := protocol.NewCmdSimple(protocol.RSP_SEND_P2P_MSG_CMD) if len(cmd.GetArgs()) != 2 { log.Warningf("syntax error: (id,msg) needed") err = common.SYNTAX_ERROR goto errout } send2ID = cmd.GetArgs()[0] send2Msg = cmd.GetArgs()[1] sessionCacheData, err = self.msgServer.sessionCache.Get(send2ID) if sessionCacheData == nil { sessionStoreData, err = self.msgServer.mongoStore.GetSessionFromCid(send2ID) if sessionStoreData == nil { log.Warningf("send2ID %s not found", send2ID) err = common.NOTFOUNT goto errout } } uuid = common.NewV4().String() log.Info("uuid : ", uuid) self.procP2PAckStatus(fromID, uuid, protocol.P2P_ACK_FALSE) if sessionCacheData == nil || sessionCacheData.Alive == false { //offline log.Info("procSendMessageP2P: " + send2ID + " | is offline") omrd, err := self.msgServer.offlineMsgCache.Get(send2ID) log.Info(omrd) if err != nil { log.Error(err.Error()) } if omrd == nil { omrd = redis_store.NewOfflineMsgCacheData(send2ID) } omrd.AddMsg(redis_store.NewOfflineMsgData(send2Msg, fromID, uuid)) err = self.msgServer.offlineMsgCache.Set(omrd) if err != nil { log.Error(err.Error()) goto errout } } else if sessionCacheData.MsgServerAddr == self.msgServer.cfg.LocalIP { log.Info("procSendMessageP2P: in the same server") req := protocol.NewCmdSimple(protocol.IND_SEND_P2P_MSG_CMD) req.AddArg(send2Msg) req.AddArg(fromID) // add uuid req.AddArg(uuid) if self.msgServer.sessions[send2ID] != nil { self.msgServer.sessions[send2ID].Send(libnet.Json(req)) if err != nil { log.Error(err.Error()) goto errout } self.procP2PAckStatus(fromID, uuid, protocol.P2P_ACK_SENT) } } else { log.Info("procSendMessageP2P: not in the same server") if self.msgServer.channels[protocol.SYSCTRL_SEND] != nil { cmd.AddArg(fromID) //add uuid cmd.AddArg(uuid) _, err = self.msgServer.channels[protocol.SYSCTRL_SEND].Channel.Broadcast(libnet.Json(cmd)) if err != nil { log.Error(err.Error()) goto errout } //self.procP2PAckStatus(fromID, uuid, protocol.P2P_ACK_SENT) } } errout: if err != nil { resp.AddArg(err.Error()) } else { resp.AddArg(protocol.RSP_SUCCESS) resp.AddArg(uuid) } err = session.Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) } return err }
/* REQ_CREATE_TOPIC_CMD arg0: TopicName //群组名 arg1: ClientName //用户在Topic中的Name, 比如老爸/老妈 */ func (self *ProtoProc) procCreateTopic(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procCreateTopic") var err error topicName := cmd.GetArgs()[0] ClientName := cmd.GetArgs()[1] ClientID := session.State.(*base.SessionState).ClientID ClientType := session.State.(*base.SessionState).ClientType resp := protocol.NewCmdSimple(protocol.RSP_CREATE_TOPIC_CMD) if len(cmd.GetArgs()) != 2 { err = common.SYNTAX_ERROR } else // only DEV_TYPE_CLIENT CAN create topic if ClientType != protocol.DEV_TYPE_CLIENT { err = common.DENY_ACCESS } else { // check whether the topic exist topicCacheData, _ := self.msgServer.topicCache.Get(topicName) if topicCacheData != nil { log.Infof("TOPIC %s exist in CACHE", topicName) err = common.TOPIC_EXIST } else { log.Infof("TOPIC %s not exist in CACHE", topicName) topicStoreData, _ := self.msgServer.mongoStore.GetTopicFromCid(topicName) if topicStoreData != nil { log.Infof("TOPIC %s exist in STORE", topicName) err = common.TOPIC_EXIST } else { log.Infof("TOPIC %s not exist in STORE", topicName) // create the topic store log.Infof("Create topic %s in STORE", topicName) topicStoreData = mongo_store.NewTopicStoreData(topicName, ClientID) err = self.msgServer.mongoStore.Set(topicStoreData) if err != nil { log.Error(err.Error()) goto ErrOut } log.Infof("topic %s created in STORE", topicName) // create the topic cache log.Infof("Create topic %s in CACHE", topicName) topicCacheData = redis_store.NewTopicCacheData(topicStoreData) err = self.msgServer.topicCache.Set(topicCacheData) if err != nil { log.Error(err.Error()) goto ErrOut } log.Infof("topic %s created in CACHE", topicName) member := mongo_store.NewMember(ClientID, ClientName, ClientType) err = self.msgServer.procJoinTopic(member, topicName) } } } ErrOut: if err != nil { resp.AddArg(err.Error()) resp.AddArg(topicName) } else { resp.AddArg(protocol.RSP_SUCCESS) resp.AddArg(topicName) resp.AddArg(ClientName) } err = session.Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) } return err /* topicCacheData := redis_store.NewTopicCacheData(topicName, session.State.(*base.SessionState).ClientID, self.msgServer.cfg.LocalIP) t := protocol.NewTopic(topicName, self.msgServer.cfg.LocalIP, session.State.(*base.SessionState).ClientID, session) t.ClientIDList = append(t.ClientIDList, session.State.(*base.SessionState).ClientID) t.TSD = topicCacheData self.msgServer.topics[topicName] = t self.msgServer.topics[topicName].Channel = libnet.NewChannel(self.msgServer.server.Protocol()) self.msgServer.topics[topicName].Channel.Join(session, nil) log.Info(topicCacheData) args := make([]string, 0) args = append(args, topicName) CCmd := protocol.NewCmdInternal(protocol.CACHE_TOPIC_CMD, args, topicCacheData) m := redis_store.NewMember(session.State.(*base.SessionState).ClientID) CCmd.AnyData.(*redis_store.TopicCacheData).MemberList = append(CCmd.AnyData.(*redis_store.TopicCacheData).MemberList, m) log.Info(CCmd) if self.msgServer.channels[protocol.SYSCTRL_TOPIC_STATUS] != nil { _, err = self.msgServer.channels[protocol.SYSCTRL_TOPIC_STATUS].Channel.Broadcast(libnet.Json(CCmd)) if err != nil { log.Error(err.Error()) return err } } // store topic topicStoreData := mongo_store.NewTopicStoreData(topicName, session.State.(*base.SessionState).ClientID, self.msgServer.cfg.LocalIP) args = make([]string, 0) args = append(args, topicName) CCmd = protocol.NewCmdInternal(protocol.STORE_TOPIC_CMD, args, topicStoreData) member := mongo_store.NewMember(session.State.(*base.SessionState).ClientID) CCmd.AnyData.(*mongo_store.TopicStoreData).MemberList = append(CCmd.AnyData.(*mongo_store.TopicStoreData).MemberList, member) log.Info(CCmd) if self.msgServer.channels[protocol.STORE_TOPIC_INFO] != nil { _, err = self.msgServer.channels[protocol.STORE_TOPIC_INFO].Channel.Broadcast(libnet.Json(CCmd)) if err != nil { log.Error(err.Error()) return err } } */ return nil }