func (self *MongoStore) Set(data interface{}) error { log.Info("MongoStore Update") var err error self.rwMutex.Lock() defer self.rwMutex.Unlock() switch data.(type) { case *SessionStoreData: op := self.session.DB(DATA_BASE_NAME).C(CLIENT_INFO_COLLECTION) cid := data.(*SessionStoreData).ClientID log.Info("cid : ", cid) _, err = op.Upsert(bson.M{"ClientID": cid}, data.(*SessionStoreData)) if err != nil { log.Error(err.Error()) return err } case *TopicStoreData: op := self.session.DB(DATA_BASE_NAME).C(TOPIC_INFO_COLLECTION) topicName := data.(*TopicStoreData).TopicName log.Info("topicName : ", topicName) _, err = op.Upsert(bson.M{"TopicName": topicName}, data.(*TopicStoreData)) if err != nil { log.Error(err.Error()) return err } } return err }
func (self *MsgServer) scanDeadSession() { log.Info("scanDeadSession") timer := time.NewTicker(self.cfg.ScanDeadSessionTimeout * time.Second) ttl := time.After(self.cfg.Expire * time.Second) for { select { case <-timer.C: log.Info("scanDeadSession timeout") go func() { for id, s := range self.sessions { self.scanSessionMutex.Lock() //defer self.scanSessionMutex.Unlock() if (s.State).(*base.SessionState).Alive == false { log.Info("delete" + id) self.procOffline(id) } else { s.State.(*base.SessionState).Alive = false } self.scanSessionMutex.Unlock() } }() case <-ttl: break } } }
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 := 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) common.StoreData(self.gateway.sessionCache, 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) procStoreSession(data interface{}, session *libnet.Session) error { log.Info("procStoreSession") var err error log.Info(data) err = self.Manager.mongoStore.Set(data.(*mongo_store.SessionStoreData)) if err != nil { return err log.Error("error:", err) } return nil }
func (self *ProtoProc) procCacheTopic(cmd protocol.Cmd, session *libnet.Session) error { log.Info("procCacheTopic") var err error log.Info(cmd.GetAnyData()) err = self.Manager.topicCache.Set(cmd.GetAnyData().(*redis_store.TopicCacheData)) if err != nil { return err log.Error("error:", err) } log.Info("set sesion id success") return nil }
func (self *ProtoProc) procSubscribeChannel(cmd protocol.Cmd, session *libnet.Session) { log.Info("procSubscribeChannel") channelName := cmd.GetArgs()[0] cUUID := cmd.GetArgs()[1] log.Info(channelName) if self.msgServer.channels[channelName] != nil { self.msgServer.channels[channelName].Channel.Join(session, nil) self.msgServer.channels[channelName].ClientIDlist = append(self.msgServer.channels[channelName].ClientIDlist, cUUID) } else { log.Warning(channelName + " is not exist") } log.Info(self.msgServer.channels) }
func GetOfflineMsgFromOwnerName(storeOp interface{}, ownerName string) (*redis_store.OfflineMsgCacheData, error) { switch storeOp.(type) { case *redis_store.OfflineMsgCache: o, err := storeOp.(*redis_store.OfflineMsgCache).Get(ownerName) if err != nil { log.Warningf("no ownerName : %s", ownerName) return nil, err } if o != nil { log.Info(o) } return o, nil } return nil, NOTFOUNT // o ,err := offlineMsgCache.Get(ownerName) // if err != nil { // log.Warningf("no ownerName : %s", ownerName) // return nil, err // } // if o != nil { // log.Info(o) // } // return o, nil }
func main() { version() fmt.Printf("built on %s\n", BuildTime()) flag.Parse() cfg := NewRouterConfig(*InputConfFile) err := cfg.LoadConfig() if err != nil { log.Error(err.Error()) return } server, err := libnet.Listen(cfg.TransportProtocols, cfg.Listen) if err != nil { log.Error(err.Error()) return } log.Info("server start: ", server.Listener().Addr().String()) rs := redis_store.NewRedisStore(&redis_store.RedisStoreOptions{ Network: "tcp", Address: cfg.Redis.Addr + cfg.Redis.Port, ConnectTimeout: time.Duration(cfg.Redis.ConnectTimeout) * time.Millisecond, ReadTimeout: time.Duration(cfg.Redis.ReadTimeout) * time.Millisecond, WriteTimeout: time.Duration(cfg.Redis.WriteTimeout) * time.Millisecond, Database: 1, KeyPrefix: base.COMM_PREFIX, }) r := NewRouter(cfg, rs) //TODO not use go go r.subscribeChannels() server.Serve(func(session *libnet.Session) { }) }
/* 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 }
/* 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.REQ_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.REQ_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 *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 }
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 }) }
func main() { version() fmt.Printf("built on %s\n", BuildTime()) flag.Parse() cfg := NewMonitorConfig(*InputConfFile) err := cfg.LoadConfig() if err != nil { log.Error(err.Error()) return } server, err := libnet.Listen(cfg.TransportProtocols, cfg.Listen) if err != nil { log.Error(err.Error()) return } log.Info("server start: ", server.Listener().Addr().String()) m := NewMonitor(cfg) //TODO not use go m.subscribeChannels() go server.Serve(func(session *libnet.Session) { }) beego.Router("api/v1/monitor", &controllers.MonitorController{}) //beego.SetStaticPath("/views", "/mh/mygo/src/FishChatServer/monitor/views") beego.SetStaticPath("/views", "views") beego.Run() }
func (self *MsgServer) sendMonitorData() error { log.Info("sendMonitorData") resp := protocol.NewCmdMonitor() // resp.SessionNum = (uint64)(len(self.sessions)) // log.Info(resp) mb := NewMonitorBeat("monitor", self.cfg.MonitorBeatTime, 40, 10) if self.channels[protocol.SYSCTRL_MONITOR] != nil { for { resp.SessionNum = (uint64)(len(self.sessions)) //log.Info(resp) mb.Beat(self.channels[protocol.SYSCTRL_MONITOR].Channel, resp) } // _, err := self.channels[protocol.SYSCTRL_MONITOR].Channel.Broadcast(libnet.Json(resp)) // if err != nil { // glog.Error(err.Error()) // return err // } } return nil }
func (self *MsgServer) createChannels() { log.Info("createChannels") for _, c := range base.ChannleList { channel := libnet.NewChannel(self.server.Protocol()) self.channels[c] = base.NewChannelState(c, channel) } }
/* 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) 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 }
func GetSessionFromCID(storeOp interface{}, ID string) (interface{}, error) { switch storeOp.(type) { case *redis_store.SessionCache: // return (*redis_store.SessionCacheData) SessionCacheData, err := storeOp.(*redis_store.SessionCache).Get(ID) if err != nil { log.Warningf("no ID : %s", ID) return nil, err } if SessionCacheData != nil { log.Info(SessionCacheData) } return SessionCacheData, nil case *mongo_store.MongoStore: // return (*mongo_store.sessionStoreData) sessionStoreData, err := storeOp.(*mongo_store.MongoStore).GetSessionFromCid(ID) if err != nil { log.Warningf("no ID : %s", ID) return nil, err } if sessionStoreData != nil { log.Info(sessionStoreData) } return sessionStoreData, nil } return nil, NOTFOUNT // session ,err := sessionCache.Get(ID) // if err != nil { // log.Warningf("no ID : %s", ID) // return nil, err // } // if session != nil { // log.Info(session) // } // return session, nil }
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 (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 GetTopicFromTopicName(storeOp interface{}, topicName string) (interface{}, error) { switch storeOp.(type) { case *redis_store.TopicCache: // return (*redis_store.TopicCacheData) TopicCacheData, err := storeOp.(*redis_store.TopicCache).Get(topicName) if err != nil { log.Warningf("no topicName : %s", topicName) return nil, err } if TopicCacheData != nil { log.Info(TopicCacheData) } return TopicCacheData, nil case *mongo_store.MongoStore: // return (*mongo_store.TopicStoreData) TopicStoreData, err := storeOp.(*mongo_store.MongoStore).GetTopicFromCid(topicName) if err != nil { log.Warningf("no topicName : %s", topicName) return nil, err } if TopicStoreData != nil { log.Info(TopicStoreData) } return TopicStoreData, nil } return nil, NOTFOUNT // topic ,err := topicCache.Get(topicName) // if err != nil { // log.Warningf("no topicName : %s", topicName) // return nil, err // } // if topic != nil { // log.Info(topic) // } // return topic, nil }
func StoreData(storeOp interface{}, data interface{}) error { switch data.(type) { case *redis_store.SessionCacheData: err := storeOp.(*redis_store.SessionCache).Set(data.(*redis_store.SessionCacheData)) //err := (*redis_store.SessionCache)(storeOp).Set(data) if err != nil { return err log.Error("error:", err) } log.Info("cache sesion success") return nil case *redis_store.TopicCacheData: err := storeOp.(*redis_store.TopicCache).Set(data.(*redis_store.TopicCacheData)) if err != nil { return err log.Error("error:", err) } log.Info("cache topic success") return nil case *mongo_store.SessionStoreData: err := storeOp.(*mongo_store.MongoStore).Set(data) if err != nil { return err log.Error("error:", err) } log.Info("store session success") return nil case *mongo_store.TopicStoreData: err := storeOp.(*mongo_store.MongoStore).Set(data) if err != nil { return err log.Error("error:", err) } log.Info("store topic success") return nil } return nil }
func (self *MongoStore) DeleteTopic(cid string) error { log.Info("MongoStore DeleteTopic") self.rwMutex.Lock() defer self.rwMutex.Unlock() op := self.session.DB(DATA_BASE_NAME).C(TOPIC_INFO_COLLECTION) return op.Remove(bson.M{"TopicName": cid}) }
func (self *MongoStore) DeleteSession(cid string) error { log.Info("MongoStore DeleteSession") self.rwMutex.Lock() defer self.rwMutex.Unlock() op := self.session.DB(DATA_BASE_NAME).C(CLIENT_INFO_COLLECTION) return op.Remove(bson.M{"ClientID": cid}) }
func (self *MsgServer) procJoinTopic(member *mongo_store.Member, topicName string) error { log.Info("procJoinTopic") var err error // check whether the topic exist topicCacheData, err := self.topicCache.Get(topicName) if topicCacheData == nil { log.Warningf("TOPIC %s not exist", topicName) return common.TOPIC_NOT_EXIST } if topicCacheData.MemberExist(member.ID) { log.Warningf("ClientID %s exists in topic %s", member.ID, topicName) return common.MEMBER_EXIST } sessionCacheData, err := self.sessionCache.Get(member.ID) if sessionCacheData == nil { log.Warningf("Client %s not online", member.ID) return common.NOT_ONLINE } // Watch can only be added in ONE topic //fmt.Println("len of topic list of %s: %d", member.ID, len(sessionCacheData.TopicList)) if member.Type == protocol.DEV_TYPE_WATCH && len(sessionCacheData.TopicList) >= 1 { log.Warningf("Watch %s is in topic %s", member.ID, sessionCacheData.TopicList[0]) return common.DENY_ACCESS } // session cache and store sessionCacheData.AddTopic(topicName) err = self.sessionCache.Set(sessionCacheData) if err != nil { log.Error(err.Error()) return err } err = self.mongoStore.Set(sessionCacheData.SessionStoreData) if err != nil { log.Error(err.Error()) return err } // topic cache and store topicCacheData.AddMember(member) err = self.topicCache.Set(topicCacheData) if err != nil { log.Error(err.Error()) return err } err = self.mongoStore.Set(topicCacheData.TopicStoreData) if err != nil { log.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 */ 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 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 { member := mongo_store.NewMember(mID, mName, sessionCacheData.ClientType) err = self.msgServer.procJoinTopic(member, topicName) } } } 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 -> 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 main() { version() fmt.Printf("built on %s\n", BuildTime()) flag.Parse() cfg := NewMsgServerConfig(*InputConfFile) err := cfg.LoadConfig() if err != nil { log.Error(err.Error()) return } rs := redis_store.NewRedisStore(&redis_store.RedisStoreOptions{ Network: "tcp", Address: cfg.Redis.Addr + cfg.Redis.Port, ConnectTimeout: time.Duration(cfg.Redis.ConnectTimeout) * time.Millisecond, ReadTimeout: time.Duration(cfg.Redis.ReadTimeout) * time.Millisecond, WriteTimeout: time.Duration(cfg.Redis.WriteTimeout) * time.Millisecond, Database: 1, KeyPrefix: base.COMM_PREFIX, }) ms := NewMsgServer(cfg, rs) ms.server, err = libnet.Listen(cfg.TransportProtocols, cfg.Listen) if err != nil { panic(err) } log.Info("msg_server running at ", ms.server.Listener().Addr().String()) ms.createChannels() go ms.scanDeadSession() go ms.sendMonitorData() ms.server.Serve(func(session *libnet.Session) { log.Info("a new client ", session.Conn().RemoteAddr().String(), " | come in") go handleSession(ms, session) }) }
/* 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 }