func (a *WsAcceptor) start() (err error) {
http.Handle(a.sc.Path, http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
defer utils.DumpStackIfPanic("ws.HandlerFunc")
if req.Method != "GET" {
http.Error(res, "method not allowed", 405)
return
}
ws, err := a.upgrader.Upgrade(res, req, nil)
if _, ok := err.(websocket.HandshakeError); ok {
http.Error(res, "Not a websocket handshake", 400)
return
} else if err != nil {
http.Error(res, fmt.Sprintf("%v", err), 500)
logger.Error(err)
return
}
ws.SetPongHandler(func(string) error {
ws.SetReadDeadline(time.Now().Add(readWait))
return nil
})
s := newWsSession(a.idGen.NextId(), ws, a.sc, a)
s.FireConnectEvent()
s.start()
a.acptChan <- s
}))
go func() {
service := a.sc.Ip + ":" + strconv.Itoa(int(a.sc.Port))
err := http.ListenAndServe(service, nil)
if err != nil {
logger.Error(err)
}
}()
return nil
}
func DumpStackIfPanic(f string) {
if err := recover(); err != nil {
logger.Error(f, " panic,error=", err)
var buf [4096]byte
len := runtime.Stack(buf[:], false)
logger.Error("stack--->", string(buf[:len]))
}
}
func Stop() {
AppModule.Close()
err := core.ExecuteHook(core.HOOK_AFTER_STOP)
if err != nil {
logger.Error("ExecuteHook(HOOK_BEFORE_START) error", err)
}
}
func Start() *utils.Waitor {
err := core.ExecuteHook(core.HOOK_BEFORE_START)
if err != nil {
logger.Error("ExecuteHook(HOOK_BEFORE_START) error", err)
}
return AppModule.Start()
}
func sendTaskReqToExecutor(t *Task, name string) bool {
if t == nil {
return false
}
if t.n != nil && t.s == nil {
logger.Error(name, " You must specify the source object task.")
return false
}
return TaskExecutor.SendCommand(&taskReqCommand{t: t, n: name}, true)
}
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 (e *NetEngine) Init() {
var err error
for i := 0; i < len(Config.IoServices); i++ {
s := e.newIoService(&Config.IoServices[i])
if s != nil {
e.pool[Config.IoServices[i].Id] = s
err = s.start()
if err != nil {
logger.Error(err)
}
}
}
time.AfterFunc(time.Minute*5, func() { e.dump() })
}
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()
}
}
}