func (this *SignalHandler) ProcessSignal() { logger.Info("(this *SignalHandler) ProcessSignal()") for { select { case s := <-this.sc: logger.Info("-------->receive UnHandle Signal:", s) this.lock.RLock() defer this.lock.RUnlock() if v, ok := this.mh[s]; ok { for hk, hv := range v { hk.Process(s, hv) } } else { logger.Info("-------->receive UnHandle Signal:", s) } } } }
func (c *Configuration) Init() error { for _, str := range c.SrvInfo.Banner { logger.Info(str) } for i := 0; i < len(c.IoServices); i++ { c.IoServices[i].Init() } return nil }
func LoadPackages(configFile string) { data, err := ioutil.ReadFile(configFile) if err != nil { logger.Errorf("Error while reading config file %s: %s", configFile, err) } switch path.Ext(configFile) { case ".json": // Compact JSON to make it easier to extract JSON per package var buf bytes.Buffer err = json.Compact(&buf, data) if err != nil { logger.Errorf("Error in JSON config file %s: %s", configFile, err) } data = buf.Bytes() // Unmarshal packages /*in given order*/ for _, pkg := range packages { // Extract JSON only for this package key := []byte(`"` + pkg.Name() + `":{`) begin := bytes.Index(data, key) if begin != -1 { begin += len(key) - 1 end := 0 braceCounter := 0 for i := begin; i < len(data); i++ { switch data[i] { case '{': braceCounter++ case '}': braceCounter-- } if braceCounter == 0 { end = i + 1 break } } err = json.Unmarshal(data[begin:end], pkg) if err != nil { logger.Errorf("Error while unmarshalling JSON from config file %s: %s", configFile, err) } } err := pkg.Init() if err != nil { logger.Errorf("Error while initializing package %s: %s", pkg.Name(), err) } else { logger.Info("module [", pkg.Name(), "] load success") } } default: panic("Unsupported config file: " + configFile) } }
func (a *TcpAcceptor) start() (err error) { service := a.sc.Ip + ":" + strconv.Itoa(int(a.sc.Port)) a.listener, err = net.Listen("tcp", service) if err != nil { logger.Error(err) return err } logger.Info(a.sc.Name, " listen at ", a.listener.Addr().String()) go a.acceptRoutine() go a.sessionRoutine() return nil }
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 (this *MulticastPacketFactory) CreateMulticastPacket(data interface{}, sis ...*protocol.MCSessionUnion) proto.Message { pack := &protocol.SSPacketMulticast{Sessions: sis} if byteData, ok := data.([]byte); ok { pack.Data = byteData } else { byteData, err := netlib.MarshalPacket(data) if err == nil { pack.Data = byteData } else { logger.Info("MulticastPacketFactory.CreateMulticastPacket err:", err) } } proto.SetDefaults(pack) return pack }
func ContructTxResultPacket(parent, me *transact.TransNodeParam, tr *transact.TransResult) proto.Message { packet := &protocol.TransactResult{ MyTId: proto.Int64(int64(parent.TId)), ChildTId: proto.Int64(int64(me.TId)), RetCode: proto.Int32(int32(tr.RetCode)), } if tr.RetFiels != nil { b, err := netlib.MarshalPacketNoPackId(tr.RetFiels) if err != nil { logger.Info("ContructTxResultPacket Marshal UserData error:", err) } else { packet.CustomData = b } } proto.SetDefaults(packet) return packet }
func (t *Task) run() (e error) { defer utils.DumpStackIfPanic("Task::run") t.tStart = time.Now() ret := t.c.Call() if t.r != nil { t.r <- ret } if t.n != nil { SendTaskRes(t.s, t) } if t.name != "" { tNow := time.Now() logger.Info("task [", t.name, "] since createTime(", tNow.Sub(t.tCreate), ") since startTime(", tNow.Sub(t.tStart), ")") } return nil }
func (this *Configuration) Init() error { this.Connects.Init() f := this.Connects.GetFilter(filter.AuthenticationFilterName) if f != nil { f.(*filter.AuthenticationFilter).SessionAuthHandler = func(s *netlib.Session, bSuc bool) { if bSuc { packet := &protocol.CSPacketPing{ TimeStamb: proto.Int64(time.Now().Unix()), Message: []byte("=1234567890abcderghijklmnopqrstuvwxyz="), } //for i := 0; i < 1024*32; i++ { // packet.Message = append(packet.Message, byte('x')) //} proto.SetDefaults(packet) s.Send(packet) } else { logger.Info("SessionAuthHandler auth failed") } } } return nil }
func ContructTxStartPacket(parent, me *transact.TransNodeParam, ud interface{}) proto.Message { packet := &protocol.TransactStart{ MyTNP: &protocol.TransactParam{ TransNodeID: proto.Int64(int64(me.TId)), TransType: proto.Int32(int32(me.Tt)), OwnerType: proto.Int32(int32(me.Ot)), TransCommitType: proto.Int32(int32(me.Tct)), OwnerID: proto.Int32(int32(me.Oid)), SkeletonID: proto.Int32(int32(me.SkeletonID)), LevelNo: proto.Int32(int32(me.LevelNo)), AreaID: proto.Int32(int32(me.AreaID)), TimeOut: proto.Int64(int64(me.TimeOut)), }, ParenTNP: &protocol.TransactParam{ TransNodeID: proto.Int64(int64(parent.TId)), TransType: proto.Int32(int32(parent.Tt)), OwnerType: proto.Int32(int32(parent.Ot)), TransCommitType: proto.Int32(int32(parent.Tct)), OwnerID: proto.Int32(int32(parent.Oid)), SkeletonID: proto.Int32(int32(parent.SkeletonID)), LevelNo: proto.Int32(int32(parent.LevelNo)), AreaID: proto.Int32(int32(parent.AreaID)), TimeOut: proto.Int64(int64(parent.TimeOut)), }, } if ud != nil { b, err := netlib.MarshalPacketNoPackId(ud) if err != nil { logger.Info("ContructTxStartPacket Marshal UserData error:", err) } else { packet.CustomData = b } } proto.SetDefaults(packet) return packet }
func (c *WsConnector) dump() { logger.Info("=========wsconnector dump maxDone=", c.maxDone) logger.Info("=========wssession recvBuffer size=", len(c.s.recvBuffer), " sendBuffer size=", len(c.s.sendBuffer)) }
func (a *TcpAcceptor) dump() { logger.Info("=========accept dump maxSessions=", a.maxActive, " maxDone=", a.maxDone) for sid, s := range a.mapSessions { logger.Info("=========session:", sid, " recvBuffer size=", len(s.recvBuffer), " sendBuffer size=", len(s.sendBuffer)) } }
func (ish *KillSignalHandler) Process(s os.Signal, ud interface{}) error { logger.Info("Receive Kill signal, process be close") module.Stop() return nil }
func (ish *InterruptSignalHandler) Process(s os.Signal, ud interface{}) error { logger.Info("Receive Interrupt signal, process start quit.") module.Stop() return nil }
func (s *WsSession) recvRoutine() { defer func() { if err := recover(); err != nil { logger.Trace(s.Id, " ->close: Session.procRecv err: ", err) } s.sc.decoder.FinishDecode(&s.Session) s.shutRead() s.Close() }() s.waitor.Add(1) defer s.waitor.Done() s.conn.SetReadLimit(int64(s.sc.MaxPacket)) var ( pck interface{} packetid int raw []byte ) for { if s.sc.IsInnerLink { var timeZero time.Time s.conn.SetReadDeadline(timeZero) } else { if s.sc.ReadTimeout != 0 { s.conn.SetReadDeadline(time.Now().Add(s.sc.ReadTimeout)) } } op, r, err := s.conn.NextReader() if err != nil { logger.Info("s.conn.NextReader err:", err) panic(err) } switch op { case websocket.BinaryMessage: packetid, pck, err, raw = s.sc.decoder.Decode(&s.Session, r) if err != nil { bUnproc := true bPackErr := false if _, ok := err.(*UnparsePacketTypeErr); ok { bPackErr = true if s.sc.eph != nil && s.sc.eph.OnErrorPacket(&s.Session, packetid, raw) { bUnproc = false } } if bUnproc { logger.Error("s.sc.decoder.Decode err ", err) if s.sc.IsInnerLink == false { panic(err) } else if !bPackErr { panic(err) } } } if pck != nil { if s.FirePacketReceived(packetid, pck) { act := AllocAction() act.s = &s.Session act.p = pck act.packid = packetid act.n = "packet:" + strconv.Itoa(packetid) s.recvBuffer <- act } } s.lastRcvTime = time.Now() } } }
func (sft *SessionFilterTrace) dump() { if time.Now().Sub(sft.dumpTime) >= time.Minute*5 { logger.Info("Session per five minuts: recvCntPerSec=", sft.recvCntPerSec, " sendCntPerSec=", sft.sendCntPerSec) sft.dumpTime = time.Now() } }