Example #1
0
func (tm *TimerMgr) Start() {
	logger.Trace("Timer Start")
	defer logger.Trace("Timer Start [ok]")

	tm.Object = basic.NewObject(core.ObjId_TimerId,
		"timer",
		Config.Options,
		tm)
	tm.UserData = tm

	core.LaunchChild(TimerModule.Object)
}
Example #2
0
func (this *ModuleMgr) init() {
	logger.Trace("Start Initialize Modules")
	defer logger.Trace("Start Initialize Modules [ok]")
	for e := this.modules.Front(); e != nil; e = e.Next() {
		if me, ok := e.Value.(*ModuleEntity); ok && !me.quited {
			logger.Trace(me.module.ModuleName(), " Init...")
			me.module.Init()
			logger.Trace(me.module.ModuleName(), " Init [ok]")
		}
	}
	this.state = ModuleStateRun
}
Example #3
0
func (s *TcpSession) sendRoutine() {

	defer func() {
		if err := recover(); err != nil {
			logger.Trace(s.Id, " ->close: Session.procSend err: ", err)
		}
		s.sc.encoder.FinishEncode(&s.Session)
		s.shutWrite()
		s.shutRead()
		s.Close()
	}()

	s.waitor.Add(1)
	defer s.waitor.Done()

	var (
		err  error
		data []byte
	)

	for !s.quit || len(s.sendBuffer) != 0 {
		select {
		case msg, ok := <-s.sendBuffer:
			if !ok {
				panic("[comm expt]sendBuffer chan closed")
			}

			if msg == nil {
				panic("[comm expt]normal close send")
			}

			if s.sc.IsInnerLink {
				var timeZero time.Time
				s.conn.SetWriteDeadline(timeZero)
			} else {
				if s.sc.WriteTimeout != 0 {
					s.conn.SetWriteDeadline(time.Now().Add(s.sc.WriteTimeout))
				}
			}

			data, err = s.sc.encoder.Encode(&s.Session, msg, s.conn)
			if err != nil {
				logger.Trace("s.sc.encoder.Encode err", err)
				if s.sc.IsInnerLink == false {
					panic(err)
				}
			}
			s.FirePacketSent(data)
			s.lastSndTime = time.Now()
		}
	}
}
Example #4
0
func (e *Executor) Start() {
	logger.Trace("Executor Start")
	defer logger.Trace("Executor Start [ok]")

	e.Object = basic.NewObject(core.ObjId_ExecutorId,
		"executor",
		Config.Options,
		nil)
	e.c.NumberOfReplicas = WorkerVirtualNum
	e.UserData = e
	e.AddWorker(Config.Worker.WorkerCnt)

	core.LaunchChild(TaskExecutor.Object)
}
Example #5
0
func (tcs *TxCommSkeleton) SendTransStart(parent, me *transact.TransNodeParam, ud interface{}) bool {
	logger.Trace("TxCommSkeleton.SendTransStart")
	p := action.ContructTxStartPacket(parent, me, ud)
	if p == nil {
		return false
	}
	s := ServerSessionMgrSington.GetSession(me.AreaID, int(me.Ot), me.Oid)
	if s == nil {
		logger.Trace("TxCommSkeleton.SendTransStart s=nil")
		return false
	}

	s.Send(p)
	return true
}
Example #6
0
func (tcs *TxCommSkeleton) SendTransResult(parent, me *transact.TransNodeParam, tr *transact.TransResult) bool {
	logger.Trace("TxCommSkeleton.SendTransResult")
	p := action.ContructTxResultPacket(parent, me, tr)
	if p == nil {
		return false
	}
	s := ServerSessionMgrSington.GetSession(parent.AreaID, int(parent.Ot), parent.Oid)
	if s == nil {
		logger.Trace("TxCommSkeleton.SendTransResult s=nil")
		return false
	}

	s.Send(p)
	return true
}
Example #7
0
func (tcs *TxCommSkeleton) SendCmdToTransNode(tnp *transact.TransNodeParam, c transact.TransCmd) bool {
	logger.Trace("TxCommSkeleton.SendCmdToTransNode")
	p := action.ConstructTxCmdPacket(tnp, c)
	if p == nil {
		return false
	}
	s := ServerSessionMgrSington.GetSession(tnp.AreaID, int(tnp.Ot), tnp.Oid)
	if s == nil {
		logger.Trace("TxCommSkeleton.SendCmdToTransNode s=nil")
		return false
	}

	s.Send(p)
	return true
}
Example #8
0
func (this *serviceMgr) OnRegiste(s *netlib.Session) {
	if this == nil || s == nil {
		return
	}

	if s.GetAttribute(SessionAttributeServiceFlag) == nil {
		return
	}
	attr := s.GetAttribute(SessionAttributeServerInfo)
	if attr != nil {
		if srvInfo, ok := attr.(*protocol.SSSrvRegiste); ok && srvInfo != nil {
			services := GetCareServicesBySession(srvInfo.GetType())
			for _, v1 := range services {
				if v2, has := this.servicesPool[v1]; has {
					for _, v3 := range v2 {
						func(si *protocol.ServiceInfo, sInfo *protocol.SSSrvRegiste) {
							pack := &protocol.SSServiceInfo{}
							proto.SetDefaults(pack)
							pack.Service = si
							logger.Trace("serviceMgr.OnRegiste Server Type=", sInfo.GetType(), " Id=", sInfo.GetId(), " Name=", sInfo.GetName(), " careful => Service=", si)
							s.Send(pack)
						}(v3, srvInfo)
					}
				}
			}
		}
	}
}
Example #9
0
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
	}))
}
Example #10
0
func RegisteHandler(tt TransType, th TransHandler) {
	if _, exist := transactionHandlerPool[tt]; exist {
		panic(fmt.Sprintf("TransHandlerFactory repeate registe handler, type=%v", tt))
		return
	}
	logger.Trace("transact.RegisteHandler:", tt)
	transactionHandlerPool[tt] = th
}
Example #11
0
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
}
Example #12
0
func (this *TxCtrlCmdHandler) Process(session *netlib.Session, data interface{}) error {
	logger.Trace("TxCtrlCmdHandler.Process")
	if txcmd, ok := data.(*protocol.TransactCtrlCmd); ok {
		if !transact.ProcessTransCmd(transact.TransNodeID(txcmd.GetTId()), transact.TransCmd(txcmd.GetCmd())) {
			return errors.New("TxCtrlCmdHandler error, tid=" + strconv.FormatInt(txcmd.GetTId(), 16) + " cmd=" + strconv.Itoa(int(txcmd.GetCmd())))
		}
	}
	return nil
}
Example #13
0
func (this *TxResultHandler) Process(session *netlib.Session, data interface{}) error {
	logger.Trace("TxResultHandler.Process")
	if tr, ok := data.(*protocol.TransactResult); ok {
		if !transact.ProcessTransResult(transact.TransNodeID(tr.GetMyTId()), transact.TransNodeID(tr.GetChildTId()), int(tr.GetRetCode()), tr.GetCustomData()) {
			return errors.New("TxResultHandler error, tid=" + strconv.FormatInt(tr.GetMyTId(), 16))
		}
	}
	return nil
}
Example #14
0
func (s *TcpSession) shutRead() {
	if s.shutRecv {
		return
	}
	logger.Trace(s.Id, " shutRead")
	s.shutRecv = true
	if tcpconn, ok := s.conn.(*net.TCPConn); ok {
		tcpconn.CloseRead()
	}
}
Example #15
0
func (this *PacketTransitHandler) Process(s *netlib.Session, data interface{}) error {
	logger.Trace("PacketTransitHandler.Process")
	if pr, ok := data.(*protocol.SSPacketTransit); ok {
		targetS := srvlib.ServerSessionMgrSington.GetSession(int(pr.GetSArea()), int(pr.GetSType()), int(pr.GetSId()))
		if targetS != nil {
			targetS.Send(pr.GetData())
		}
	}
	return nil
}
Example #16
0
func (s *WsSession) shutRead() {
	if s.shutRecv {
		return
	}
	logger.Trace(s.Id, " shutRead")
	s.shutRecv = true
	if s.conn != nil {
		s.conn.Close()
		s.conn = nil
	}
}
Example #17
0
func (this *ModuleMgr) Start() *utils.Waitor {
	logger.Trace("Startup PreloadModules")
	for e := this.preloadModule.Front(); e != nil; e = e.Next() {
		if me, ok := e.Value.(*PreloadModuleEntity); ok {
			me.module.Start()
		}
	}
	logger.Trace("Startup PreloadModules [ok]")

	this.Object = basic.NewObject(core.ObjId_CoreId,
		"core",
		Config.Options,
		this)
	this.UserData = this
	core.LaunchChild(this.Object)

	this.state = ModuleStateInit
	//给模块预留调度的空间,防止主线程直接跑过去
	select {
	case <-time.After(time.Second):
	}
	return this.Object.Waitor
}
Example #18
0
func (mssrl *MyServerSessionRegisteListener) OnRegiste(*netlib.Session) {
	logger.Trace("MyServerSessionRegisteListener.OnRegiste")
	tnp := &transact.TransNodeParam{
		Tt:     protocol.TxTrace,
		Ot:     transact.TransOwnerType(2),
		Oid:    202,
		AreaID: 1,
	}

	tNode := transact.DTCModule.StartTrans(tnp, nil, transact.DefaultTransactTimeout)
	if tNode != nil {
		tNode.Go(core.CoreObject())
	}
}
Example #19
0
func (this *traceTransHandler) OnExcute(tNode *transact.TransNode, ud interface{}) transact.TransExeResult {
	logger.Trace("traceTransHandler.OnExcute ")
	tnp := &transact.TransNodeParam{
		Tt:     protocol.TxTrace,
		Ot:     transact.TransOwnerType(2),
		Oid:    201,
		AreaID: 1,
		Tct:    transact.TransactCommitPolicy_TwoPhase,
	}
	p := new(int)
	*p = -2
	userData := protocol.StructA{X: 10, Y: -1, Z: 65535, P: p, Desc: "welcome!"}
	tNode.StartChildTrans(tnp, userData, transact.DefaultTransactTimeout)
	return transact.TransExeResult_Success
}
Example #20
0
func (s *TcpSession) shutWrite() {
	if s.shutSend {
		return
	}
	logger.Trace(s.Id, " shutWrite")
	rest := len(s.sendBuffer)
	for rest > 0 {
		<-s.sendBuffer
		rest--
	}

	s.shutSend = true
	if tcpconn, ok := s.conn.(*net.TCPConn); ok {
		tcpconn.CloseWrite()
	}
}
Example #21
0
func (s *WsSession) shutWrite() {
	if s.shutSend {
		return
	}
	logger.Trace(s.Id, " shutWrite")
	rest := len(s.sendBuffer)
	for rest > 0 {
		<-s.sendBuffer
		rest--
	}

	s.shutSend = true
	if s.conn != nil {
		s.conn.Close()
		s.conn = nil
	}
}
Example #22
0
func (this *PacketRedirectHandler) Process(s *netlib.Session, data interface{}) error {
	logger.Trace("PacketRedirectHandler.Process")
	if pr, ok := data.(*protocol.SSPacketRedirect); ok {
		packid, pack, err := netlib.UnmarshalPacket(pr.GetData())
		if err != nil {
			return err
		}
		h := srvlib.GetHandler(packid)
		if h != nil {
			return h.Process(s, pack, pr.GetClientSid(), pr.GetSrvRoutes())
		} else {
			nh := netlib.GetHandler(packid)
			if nh != nil {
				return nh.Process(s, pack)
			}
		}
	}
	return nil
}
Example #23
0
func (this *ModuleMgr) checkShutdown() bool {
	select {
	case param := <-this.waitShutAct:
		logger.Trace(param, " shutdowned")
		if name, ok := param.(string); ok {
			me := this.getModuleEntityByName(name)
			if me != nil && !me.quited {
				me.quited = true
				this.waitShutCnt--
			}
		}
	default:
	}
	if this.waitShutCnt == 0 {
		this.state = ModuleStateFini
		return true
	}
	this.update()
	return false
}
Example #24
0
func init() {
	netlib.RegisteSessionHandlerCreator(SessionHandlerClientBalanceName, func() netlib.SessionHandler {
		return SessionHandlerClientBalanceMgr
	})

	netlib.RegisterFactory(int(protocol.MmoPacketID_PACKET_GB_CUR_LOAD), netlib.PacketFactoryWrapper(func() interface{} {
		return &protocol.ServerLoad{}
	}))

	netlib.RegisterHandler(int(protocol.MmoPacketID_PACKET_GB_CUR_LOAD), netlib.HandlerWrapper(func(s *netlib.Session, pack interface{}) error {
		logger.Trace("receive gate load info==", pack)
		if sr, ok := pack.(*protocol.ServerLoad); ok {
			srvid := sr.GetSrvId()
			if v, has := SessionHandlerClientBalanceMgr.gates[srvid]; has {
				v.load = int(sr.GetCurLoad())
			}
		}
		return nil
	}))
}
Example #25
0
func (this *TxStartHandler) Process(session *netlib.Session, data interface{}) error {
	logger.Trace("TxStartHandler.Process")
	if ts, ok := data.(*protocol.TransactStart); ok {
		netptnp := ts.GetParenTNP()
		if netptnp == nil {
			return nil
		}
		netmtnp := ts.GetMyTNP()
		if netmtnp == nil {
			return nil
		}

		ptnp := &transact.TransNodeParam{
			TId:        transact.TransNodeID(netptnp.GetTransNodeID()),
			Tt:         transact.TransType(netptnp.GetTransType()),
			Ot:         transact.TransOwnerType(netptnp.GetOwnerType()),
			Tct:        transact.TransactCommitPolicy(netptnp.GetTransCommitType()),
			Oid:        int(netptnp.GetOwnerID()),
			SkeletonID: int(netptnp.GetSkeletonID()),
			LevelNo:    int(netptnp.GetLevelNo()),
			AreaID:     int(netptnp.GetAreaID()),
			TimeOut:    time.Duration(netptnp.GetTimeOut()),
		}
		mtnp := &transact.TransNodeParam{
			TId:        transact.TransNodeID(netmtnp.GetTransNodeID()),
			Tt:         transact.TransType(netmtnp.GetTransType()),
			Ot:         transact.TransOwnerType(netmtnp.GetOwnerType()),
			Tct:        transact.TransactCommitPolicy(netmtnp.GetTransCommitType()),
			Oid:        int(netmtnp.GetOwnerID()),
			SkeletonID: int(netmtnp.GetSkeletonID()),
			LevelNo:    int(netmtnp.GetLevelNo()),
			AreaID:     int(netmtnp.GetAreaID()),
			TimeOut:    time.Duration(netmtnp.GetTimeOut()),
		}

		if !transact.ProcessTransStart(ptnp, mtnp, ts.GetCustomData(), mtnp.TimeOut) {
			return errors.New("TxStartHandler error, tid=" + strconv.FormatInt(netmtnp.GetTransNodeID(), 16))
		}
	}
	return nil
}
Example #26
0
func (sfcb *SessionHandlerClientBalance) OnSessionOpened(s *netlib.Session) {
	logger.Trace("SessionHandlerClientBalance.OnSessionOpened")
	services := srvlib.ServiceMgr.GetServices(srvlib.ClientServiceType)
	if services != nil {
		/*清理掉线的gate*/
		for k, _ := range sfcb.gates {
			if _, has := services[k]; !has {
				delete(sfcb.gates, k)
			}
		}
		/*补充新上线的gate*/
		for k, v := range services {
			if _, has := sfcb.gates[k]; !has {
				sfcb.gates[k] = &gateService{ServiceInfo: v, active: true}
			}
		}
	}

	/*查找最小负载的gate*/
	var mls *libproto.ServiceInfo
	var min = 100000
	for _, v := range sfcb.gates {
		if v.active && v.load < min {
			mls = v.ServiceInfo
		}
	}
	pack := &protocol.SCGateInfo{}
	if mls != nil {
		pack.SrvType = proto.Int32(mls.GetSrvType())
		pack.SrvId = proto.Int32(mls.GetSrvId())
		pack.AuthKey = proto.String(mls.GetAuthKey())
		pack.Ip = proto.String(mls.GetIp())
		pack.Port = proto.Int32(mls.GetPort())
	}
	proto.SetDefaults(pack)
	s.Send(pack)
	time.AfterFunc(time.Second*5, func() { s.Close() })
}
Example #27
0
func (mssrl *MyServerSessionRegisteListener) OnUnregiste(*netlib.Session) {
	logger.Trace("MyServerSessionRegisteListener.OnUnregiste")
}
Example #28
0
func (this *traceTransHandler) OnChildTransRep(tNode *transact.TransNode, hChild transact.TransNodeID, retCode int, ud interface{}) transact.TransExeResult {
	logger.Trace("traceTransHandler.OnChildTransRep ")
	return transact.TransExeResult_Success
}
Example #29
0
func (this *traceTransHandler) OnRollBack(tNode *transact.TransNode) transact.TransExeResult {
	logger.Trace("traceTransHandler.OnRollBack ")
	return transact.TransExeResult_Success
}
Example #30
0
func (this *traceTransHandler) OnCommit(tNode *transact.TransNode) transact.TransExeResult {
	logger.Trace("traceTransHandler.OnCommit ")
	return transact.TransExeResult_Success
}