func (ssm *ServerSessionMgr) RegisteSession(s *netlib.Session) bool {
attr := s.GetAttribute(SessionAttributeServerInfo)
if attr != nil {
if srvInfo, ok := attr.(*protocol.SSSrvRegiste); ok && srvInfo != nil {
logger.Tracef("ServerSessionMgr.RegisteSession %v", srvInfo)
areaId := int(srvInfo.GetAreaId())
srvType := int(srvInfo.GetType())
srvId := int(srvInfo.GetId())
if a, exist := ssm.sessions[areaId]; !exist {
ssm.sessions[areaId] = make(map[int]map[int]*netlib.Session)
a = ssm.sessions[areaId]
a[srvType] = make(map[int]*netlib.Session)
} else {
if _, exist := a[srvType]; !exist {
a[srvType] = make(map[int]*netlib.Session)
}
}
ssm.sessions[areaId][srvType][srvId] = s
if ssm.listener != nil {
ssm.listener.OnRegiste(s)
}
}
} else {
logger.Tracef("ServerSessionMgr.RegisteSession SessionAttributeServerInfo=nil")
}
return true
}
func (af *AuthenticationFilter) OnPacketReceived(s *netlib.Session, packetid int, packet interface{}) bool {
if s.GetAttribute(SessionAttributeAuth) == nil {
if auth, ok := packet.(*protocol.SSPacketAuth); ok {
h := md5.New()
rawText := fmt.Sprintf("%v;%v", auth.GetTimestamp(), s.GetSessionConfig().AuthKey)
logger.Tracef("AuthenticationFilter rawtext=%v IsInnerLink(%v)", rawText, s.GetSessionConfig().IsInnerLink)
h.Write([]byte(rawText))
expectKey := hex.EncodeToString(h.Sum(nil))
if expectKey != auth.GetAuthKey() {
if af.SessionAuthHandler != nil {
af.SessionAuthHandler(s, false)
}
s.Close()
logger.Tracef("AuthenticationFilter AuthKey error[expect:%v get:%v]", expectKey, auth.GetAuthKey())
return false
}
s.SetAttribute(SessionAttributeAuth, true)
if af.SessionAuthHandler != nil {
af.SessionAuthHandler(s, true)
}
return false
} else {
s.Close()
logger.Warn("AuthenticationFilter packet not expect")
return false
}
}
return true
}
func (this *traceTransHandler) OnExcute(tNode *transact.TransNode, ud interface{}) transact.TransExeResult {
logger.Trace("traceTransHandler.OnExcute ")
userData := &protocol.StructA{}
err := netlib.UnmarshalPacketNoPackId(ud.([]byte), userData)
if err == nil {
logger.Tracef("==========%#v", userData)
}
return transact.TransExeResult_Success
}
func (csm *ClientSessionMgr) UnregisteSession(s *netlib.Session) bool {
attr := s.GetAttribute(SessionAttributeClientSession)
if attr != nil {
if sid, ok := attr.(SessionId); ok {
delete(csm.sessions, sid.Get())
logger.Tracef("client session %v unregiste", sid.Get())
}
}
return true
}
func (csm *ClientSessionMgr) RegisteSession(s *netlib.Session) bool {
attr := s.GetAttribute(SessionAttributeClientSession)
if attr == nil {
sid := NewSessionId(s)
s.SetAttribute(SessionAttributeClientSession, sid)
csm.sessions[sid.Get()] = s
logger.Tracef("client session %v registe", sid.Get())
}
return true
}
func (sfcl *SessionHandlerClientLoad) reportLoad(s *netlib.Session) {
sc := s.GetSessionConfig()
pack := &protocol.ServerLoad{
SrvType: proto.Int32(int32(sc.Type)),
SrvId: proto.Int32(int32(sc.Id)),
CurLoad: proto.Int32(int32(srvlib.ClientSessionMgrSington.Count())),
}
proto.SetDefaults(pack)
srvlib.ServerSessionMgrSington.Broadcast(pack, netlib.Config.SrvInfo.AreaID, srvlib.BalanceServerType)
logger.Tracef("SessionHandlerClientLoad.reportLoad %v", pack)
}
func (ssm *ServerSessionMgr) UnregisteSession(s *netlib.Session) bool {
attr := s.GetAttribute(SessionAttributeServerInfo)
if attr != nil {
if srvInfo, ok := attr.(*protocol.SSSrvRegiste); ok && srvInfo != nil {
logger.Tracef("ServerSessionMgr.UnregisteSession %v", srvInfo)
areaId := int(srvInfo.GetAreaId())
srvType := int(srvInfo.GetType())
srvId := int(srvInfo.GetId())
if a, exist := ssm.sessions[areaId]; exist {
if b, exist := a[srvType]; exist {
delete(b, srvId)
if ssm.listener != nil {
ssm.listener.OnUnregiste(s)
}
}
}
}
}
return true
}