func (self *ProtoProc) procCreateTopic(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procCreateTopic") var err error if len(cmd.GetArgs()) != 1 { return CMD_NOT_CORRECT } topicName := cmd.GetArgs()[0] 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 }
func (self *Manager) subscribeChannels() error { log.Info("subscribeChannels") var msgServerClientList []*libnet.Session for _, ms := range self.cfg.MsgServerList { msgServerClient, err := self.connectMsgServer(ms) if err != nil { log.Error(err.Error()) return err } cmd := protocol.NewCmdSimple(protocol.SUBSCRIBE_CHANNEL_CMD) cmd.AddArg(protocol.SYSCTRL_CLIENT_STATUS) cmd.AddArg(self.cfg.UUID) err = msgServerClient.Send(libnet.Json(cmd)) if err != nil { log.Error(err.Error()) return err } cmd = protocol.NewCmdSimple(protocol.SUBSCRIBE_CHANNEL_CMD) cmd.AddArg(protocol.SYSCTRL_TOPIC_STATUS) cmd.AddArg(self.cfg.UUID) err = msgServerClient.Send(libnet.Json(cmd)) if err != nil { log.Error(err.Error()) return err } cmd = protocol.NewCmdSimple(protocol.SUBSCRIBE_CHANNEL_CMD) cmd.AddArg(protocol.STORE_CLIENT_INFO) cmd.AddArg(self.cfg.UUID) err = msgServerClient.Send(libnet.Json(cmd)) if err != nil { log.Error(err.Error()) return err } cmd = protocol.NewCmdSimple(protocol.SUBSCRIBE_CHANNEL_CMD) cmd.AddArg(protocol.STORE_TOPIC_INFO) cmd.AddArg(self.cfg.UUID) err = msgServerClient.Send(libnet.Json(cmd)) if err != nil { log.Error(err.Error()) return err } msgServerClientList = append(msgServerClientList, msgServerClient) } for _, msc := range msgServerClientList { go self.handleMsgServerClient(msc) } return nil }
func (self *ProtoProc) procClientID(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procClientID") var err error ID := cmd.GetArgs()[0] // for cache data sessionCacheData := redis_store.NewSessionCacheData(cmd.GetArgs()[0], session.Conn().RemoteAddr().String(), self.msgServer.cfg.LocalIP, strconv.FormatUint(session.Id(), 10)) log.Info(sessionCacheData) 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[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 { log.Error(err.Error()) return err } return nil }
/* Router -> MsgServer ROUTE_SEND_P2P_MSG_CMD arg0: Sent2ID //接收方用户ID arg1: Msg //消息内容 arg2: FromID //发送方用户ID arg3: uuid //MsgServer分配的消息uuid 发送给消息接受者的消息 MsgServer -> device/client REQ_SEND_P2P_MSG_CMD arg0: Msg //消息内容 arg1: FromID //发送方用户ID arg2: uuid //MsgServer分配的消息uuid,可选,如果提供了则须IND_ACK_P2P_STATUS_CMD(ClientID, uuid) */ func (self *ProtoProc) procRouteMessageP2P(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procRouteMessageP2P") var err error send2ID := cmd.GetArgs()[0] send2Msg := cmd.GetArgs()[1] fromID := cmd.GetArgs()[2] uuid := cmd.GetArgs()[3] if self.msgServer.sessions[send2ID] != nil { resp := protocol.NewCmdSimple(protocol.IND_SEND_P2P_MSG_CMD) resp.AddArg(send2Msg) resp.AddArg(fromID) // add uuid resp.AddArg(uuid) err = self.msgServer.sessions[send2ID].Send(libnet.Json(resp)) if err != nil { log.Fatalln(err.Error()) } else { self.procP2PAckStatus(fromID, uuid, protocol.P2P_ACK_SENT) } } return nil }
/* 通过Router转发消息(对终端开发者不可见) Router -> MsgServer ROUTE_SEND_TOPIC_MSG_CMD arg0: Msg //消息内容 arg1: TopicName //群组名 arg2: ClientID //发送方用户ID arg3: ClientType //发送方终端类型,是client还是device */ func (self *ProtoProc) procRouteTopicMsg(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procRouteTopicMsg") var err error //send2Msg := cmd.GetArgs()[0] topicName := cmd.GetArgs()[1] //fromID := cmd.GetArgs()[2] //fromType := cmd.GetArgs()[3] // check whether the topic exist topicCacheData, err := self.msgServer.topicCache.Get(topicName) if topicCacheData == nil { log.Warningf("TOPIC %s not exist: %s", topicName, err.Error()) return common.TOPIC_NOT_EXIST } cmd.ChangeCmdName(protocol.IND_SEND_TOPIC_MSG_CMD) // exactly in this server, just broadcasting log.Warningf("topic %s has %d member(s) in this server", topicName, topicCacheData.AliveMemberNumMap[self.msgServer.cfg.LocalIP]) for _, mID := range topicCacheData.MemberList { if self.msgServer.sessions[mID.ID] != nil { self.msgServer.sessions[mID.ID].Send(libnet.Json(cmd)) if err != nil { log.Fatalln(err.Error()) } } } return nil }
func (self *ProtoProc) procSendMsgP2P(cmd protocol.Cmd, session *libnet.Session) error { glog.Info("procSendMsgP2P") var err error send2ID := cmd.GetArgs()[0] send2Msg := cmd.GetArgs()[1] glog.Info(send2Msg) self.Monitor.readMutex.Lock() defer self.Monitor.readMutex.Unlock() store_session, err := common.GetSessionFromCID(self.Monitor.sessionStore, send2ID) if err != nil { glog.Warningf("no ID : %s", send2ID) return err } glog.Info(store_session.MsgServerAddr) cmd.ChangeCmdName(protocol.ROUTE_MESSAGE_P2P_CMD) err = self.Monitor.msgServerClientMap[store_session.MsgServerAddr].Send(libnet.Json(cmd)) if err != nil { glog.Error("error:", err) return err } return nil }
func (self *ProtoProc) procSendMessageTopic(cmd protocol.Cmd, session *libnet.Session) error { glog.Info("procSendMessageTopic") var err error topicName := cmd.GetArgs()[0] send2Msg := cmd.GetArgs()[1] glog.Info(send2Msg) glog.Info(topicName) if self.msgServer.topics[topicName] == nil { glog.Warning(topicName + " is not exist") } else { resp := protocol.NewCmdSimple(protocol.RESP_MESSAGE_TOPIC_CMD) resp.AddArg(topicName) resp.AddArg(send2Msg) resp.AddArg(session.State.(*base.SessionState).ClientID) _, err = self.msgServer.topics[topicName].Channel.Broadcast(libnet.Json(resp)) if err != nil { glog.Error(err.Error()) return err } } return err }
func (self *ProtoProc) procRouteMessageP2P(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procRouteMessageP2P") var err error send2ID := cmd.GetArgs()[0] send2Msg := cmd.GetArgs()[1] fromID := cmd.GetArgs()[2] uuid := cmd.GetArgs()[3] _, err = common.GetSessionFromCID(self.msgServer.sessionCache, send2ID) if err != nil { log.Warningf("no ID : %s", send2ID) return err } resp := protocol.NewCmdSimple(protocol.RESP_MESSAGE_P2P_CMD) resp.AddArg(send2Msg) resp.AddArg(fromID) // add uuid resp.AddArg(uuid) if self.msgServer.sessions[send2ID] != nil { self.msgServer.sessions[send2ID].Send(libnet.Json(resp)) if err != nil { log.Fatalln(err.Error()) } } return nil }
func (self *Monitor) subscribeChannels() error { log.Info("monitor start to subscribeChannels") for _, ms := range self.cfg.MsgServerList { msgServerClient, err := self.connectMsgServer(ms) if err != nil { log.Error(err.Error()) return err } cmd := protocol.NewCmdSimple(protocol.SUBSCRIBE_CHANNEL_CMD) cmd.AddArg(protocol.SYSCTRL_MONITOR) cmd.AddArg(self.cfg.UUID) err = msgServerClient.Send(libnet.Json(cmd)) if err != nil { log.Error(err.Error()) return err } self.msgServerClientMap[ms] = msgServerClient } for _, msc := range self.msgServerClientMap { go self.handleMsgServerClient(msc) } 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) procOfflineMsg(session *libnet.Session, ID string) error { var err error exist, err := self.msgServer.offlineMsgStore.IsKeyExist(ID) if exist.(int64) == 0 { return err } else { omrd, err := common.GetOfflineMsgFromOwnerName(self.msgServer.offlineMsgStore, ID) if err != nil { glog.Error(err.Error()) return err } for _, v := range omrd.MsgList { resp := protocol.NewCmdSimple(protocol.RESP_MESSAGE_P2P_CMD) resp.AddArg(v.Msg) resp.AddArg(v.FromID) if self.msgServer.sessions[ID] != nil { self.msgServer.sessions[ID].Send(libnet.Json(resp)) if err != nil { glog.Error(err.Error()) return err } } } omrd.ClearMsg() self.msgServer.offlineMsgStore.Set(omrd) } return err }
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 }
/* 发送给消息接受者的消息 MsgServer -> device/client REQ_SEND_P2P_MSG_CMD arg0: Msg //消息内容 arg1: FromID //发送方用户ID arg2: uuid //MsgServer分配的消息uuid,可选,如果提供了则须IND_ACK_P2P_STATUS_CMD(ClientID, uuid) */ func (self *ProtoProc) procOfflineMsg(session *libnet.Session, ID string) error { var err error exist, err := self.msgServer.offlineMsgCache.IsKeyExist(ID) if exist.(int64) == 0 { return err } else { omrd, err := common.GetOfflineMsgFromOwnerName(self.msgServer.offlineMsgCache, ID) if err != nil { log.Error(err.Error()) return err } for _, v := range omrd.MsgList { if v.Msg == protocol.IND_ACK_P2P_STATUS_CMD { resp := protocol.NewCmdSimple(protocol.IND_ACK_P2P_STATUS_CMD) resp.AddArg(v.Uuid) resp.AddArg(v.FromID) // v.FromID is status if self.msgServer.sessions[ID] != nil { self.msgServer.sessions[ID].Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) return err } } } else { resp := protocol.NewCmdSimple(protocol.IND_SEND_P2P_MSG_CMD) resp.AddArg(v.Msg) resp.AddArg(v.FromID) resp.AddArg(v.Uuid) if self.msgServer.sessions[ID] != nil { self.msgServer.sessions[ID].Send(libnet.Json(resp)) if err != nil { log.Error(err.Error()) return err } else { self.procP2PAckStatus(v.FromID, v.Uuid, protocol.P2P_ACK_SENT) } } } } omrd.ClearMsg() self.msgServer.offlineMsgCache.Set(omrd) } return err }
/* 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 *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 cmd_logout(self *Client, args []string) error { if self.bLogin == true { cmd := protocol.NewCmdSimple(protocol.REQ_LOGOUT_CMD) err := self.session.Send(libnet.Json(cmd)) self.bLogin = false return err } return nil }
/* 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 }
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 := common.GetSessionFromCID(self.Router.sessionCache, send2ID) if err != nil { log.Warningf("no ID in cache : %s", send2ID) storeSession, err := self.Router.mongoStore.GetSessionFromCid(mongo_store.DATA_BASE_NAME, mongo_store.TOPIC_INFO_COLLECTION, send2ID) if err != nil { return err } log.Info(storeSession.MsgServerAddr) cmd.ChangeCmdName(protocol.ROUTE_MESSAGE_P2P_CMD) err = self.Router.msgServerClientMap[storeSession.MsgServerAddr].Send(libnet.Json(cmd)) if err != nil { log.Error("error:", err) return err } } else { log.Info(cacheSession.MsgServerAddr) cmd.ChangeCmdName(protocol.ROUTE_MESSAGE_P2P_CMD) err = self.Router.msgServerClientMap[cacheSession.MsgServerAddr].Send(libnet.Json(cmd)) if err != nil { log.Error("error:", err) return err } } 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 cmd_quit(self *Client, args []string) error { if self.bLogin == false { fmt.Println("NOT login yet. Please login first.") return nil } if len(args) != 2 { return common.SYNTAX_ERROR } cmd := protocol.NewCmdSimple(protocol.REQ_QUIT_TOPIC_CMD) cmd.AddArg(args[1]) err := self.session.Send(libnet.Json(cmd)) return err }
func cmd_topic(self *Client, args []string) error { // get topic list if self.bLogin == false { fmt.Println("NOT login yet. Please login first.") return nil } cmd := protocol.NewCmdSimple(protocol.REQ_GET_TOPIC_LIST_CMD) err := self.session.Send(libnet.Json(cmd)) if err != nil { log.Error(err.Error()) } return err }
// [msg, fromID, uuid] func incoming_p2p_msg(self *Client, c *protocol.CmdSimple) error { fmt.Println(c.GetArgs()[1] + " says : " + c.GetArgs()[0]) if len(c.GetArgs()) >= 3 { cmd := protocol.NewCmdSimple(protocol.IND_ACK_P2P_STATUS_CMD) cmd.AddArg(c.GetArgs()[2]) cmd.AddArg(protocol.P2P_ACK_READ) cmd.AddArg(c.GetArgs()[1]) err := self.session.Send(libnet.Json(cmd)) if err != nil { log.Error(err.Error()) } } 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 *HeartBeat) Beat() { timer := time.NewTicker(self.timeout * time.Second) //ttl := time.After(self.expire * time.Second) for { select { case <-timer.C: go func() { cmd := protocol.NewCmdSimple(protocol.SEND_PING_CMD) err := self.session.Send(libnet.Json(cmd)) if err != nil { log.Error(err.Error()) } }() //case <-ttl: //break } } }
func cmd_join(self *Client, args []string) error { if self.bLogin == false { fmt.Println("NOT login yet. Please login first.") return nil } if len(args) != 3 { return common.SYNTAX_ERROR } cmd := protocol.NewCmdSimple(protocol.REQ_JOIN_TOPIC_CMD) cmd.AddArg(args[1]) cmd.AddArg(args[2]) err := self.session.Send(libnet.Json(cmd)) if err != nil { fmt.Errorf(err.Error()) } return err }
// return (ClientID, MsgServerAddr) func login_gateway(self *Client) error { fmt.Println("req GatewayServer...") gatewayClient, err := libnet.Dial("tcp", self.cfg.GatewayServer) if err != nil { panic(err) } cmd := protocol.NewCmdSimple(protocol.REQ_LOGIN_CMD) cmd.AddArg(self.clientID) cmd.AddArg(self.clientType) cmd.AddArg(self.clientPwd) err = gatewayClient.Send(libnet.Json(cmd)) if err != nil { log.Error(err.Error()) } var c protocol.CmdSimple err = gatewayClient.ProcessOnce(func(msg *libnet.InBuffer) error { log.Info(string(msg.Data)) err = json.Unmarshal(msg.Data, &c) if err != nil { log.Error("error:", err) } return nil }) if err != nil { log.Error(err.Error()) } gatewayClient.Close() fmt.Println("req GatewayServer end...") if c.GetArgs()[0] != protocol.RSP_SUCCESS { log.Errorf("login gateway error: %s", c.GetArgs()[0]) return errors.New(c.GetArgs()[0]) } self.uuid = c.GetArgs()[1] self.msAddr = c.GetArgs()[2] return nil }
func (self *MonitorBeat) Beat(c *libnet.Channel, data *protocol.CmdMonitor) { timer := time.NewTicker(self.timeout * time.Second) //ttl := time.After(self.expire * time.Second) //for { select { case <-timer.C: go func() { _, err := c.Broadcast(libnet.Json(data)) if err != nil { glog.Error(err.Error()) //return err } }() //case <-ttl: //break } //} //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) 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 }