func init() {
netlib.RegisterFactory(int(protocol.MmoPacketID_PACKET_SC_GATEINFO), netlib.PacketFactoryWrapper(func() interface{} {
return &protocol.SCGateInfo{}
}))
netlib.RegisterHandler(int(protocol.MmoPacketID_PACKET_SC_GATEINFO), netlib.HandlerWrapper(func(s *netlib.Session, pack interface{}) error {
logger.Trace("receive gateinfo==", pack)
if sr, ok := pack.(*protocol.SCGateInfo); ok {
sc := &netlib.SessionConfig{
Id: int(sr.GetSrvId()),
Type: int(sr.GetSrvType()),
Ip: sr.GetIp(),
Port: int(sr.GetPort()),
AuthKey: sr.GetAuthKey(),
WriteTimeout: 30,
ReadTimeout: 30,
IdleTimeout: 30,
MaxDone: 20,
MaxPend: 20,
MaxPacket: 1024,
RcvBuff: 1024,
SndBuff: 1024,
IsClient: true,
NoDelay: true,
FilterChain: []string{"session-filter-trace", "session-filter-auth"},
}
sc.Init()
err := netlib.Connect(core.CoreObject(), sc)
if err != nil {
logger.Warn("connect server failed err:", err)
}
}
return nil
}))
}
func (this *PressureTest) Init() {
cfg := Config.Connects
for i := 0; i < Config.Count; i++ {
cfg.Id += i
netlib.Connect(&cfg)
}
}
func (t *openTimer) OnTimer(h timer.TimerHandle, ud interface{}) bool {
if StartCnt >= Config.Count {
} else {
logger.Info("Start ", StartCnt, " Times Connect")
cfg := Config.Connects
cfg.Id = cfg.Id - StartCnt
netlib.Connect(&cfg)
StartCnt = StartCnt + 1
}
return true
}
func init() {
// service registe
netlib.RegisterFactory(int(protocol.SrvlibPacketID_PACKET_SS_SERVICE_REGISTE), netlib.PacketFactoryWrapper(func() interface{} {
return &protocol.SSServiceRegiste{}
}))
netlib.RegisterHandler(int(protocol.SrvlibPacketID_PACKET_SS_SERVICE_REGISTE), netlib.HandlerWrapper(func(s *netlib.Session, pack interface{}) error {
if sr, ok := pack.(*protocol.SSServiceRegiste); ok {
ServiceMgr.RegisteService(s, sr.GetServices())
}
return nil
}))
// service info
netlib.RegisterFactory(int(protocol.SrvlibPacketID_PACKET_SS_SERVICE_INFO), netlib.PacketFactoryWrapper(func() interface{} {
return &protocol.SSServiceInfo{}
}))
netlib.RegisterHandler(int(protocol.SrvlibPacketID_PACKET_SS_SERVICE_INFO), netlib.HandlerWrapper(func(s *netlib.Session, pack interface{}) error {
if sr, ok := pack.(*protocol.SSServiceInfo); ok {
service := sr.GetService()
if service != nil {
sc := &netlib.SessionConfig{
Id: int(service.GetSrvId()),
Type: int(service.GetSrvType()),
AreaId: int(service.GetAreaId()),
Name: service.GetSrvName(),
Ip: service.GetIp(),
Port: int(service.GetPort()),
WriteTimeout: time.Duration(service.GetWriteTimeOut()),
ReadTimeout: time.Duration(service.GetReadTimeOut()),
IdleTimeout: time.Duration(service.GetIdleTimeOut()),
MaxDone: int(service.GetMaxDone()),
MaxPend: int(service.GetMaxPend()),
MaxPacket: int(service.GetMaxPacket()),
RcvBuff: int(service.GetRcvBuff()),
SndBuff: int(service.GetSndBuff()),
IsClient: true,
IsAutoReconn: true,
AuthKey: service.GetAuthKey(),
SoLinger: int(service.GetSoLinger()),
KeepAlive: service.GetKeepAlive(),
NoDelay: service.GetNoDelay(),
IsInnerLink: service.GetIsInnerLink(),
SupportFragment: service.GetSupportFragment(),
AllowMultiConn: service.GetAllowMultiConn(),
EncoderName: service.GetEncoderName(),
DecoderName: service.GetDecoderName(),
FilterChain: service.GetFilterChain(),
HandlerChain: service.GetHandlerChain(),
Protocol: service.GetProtocol(),
Path: service.GetPath(),
}
sc.Init()
err := netlib.Connect(sc)
if err != nil {
logger.Warn("connect server failed err:", err)
}
}
}
return nil
}))
// service shutdown
netlib.RegisterFactory(int(protocol.SrvlibPacketID_PACKET_SS_SERVICE_SHUT), netlib.PacketFactoryWrapper(func() interface{} {
return &protocol.SSServiceShut{}
}))
netlib.RegisterHandler(int(protocol.SrvlibPacketID_PACKET_SS_SERVICE_SHUT), netlib.HandlerWrapper(func(s *netlib.Session, pack interface{}) error {
if sr, ok := pack.(*protocol.SSServiceShut); ok {
service := sr.GetService()
if service != nil {
netlib.ShutConnector(service.GetIp(), int(service.GetPort()))
}
}
return nil
}))
ServerSessionMgrSington.SetListener(ServiceMgr)
}