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) 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.REQ_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
}