func (c *Client) Response(msg *protocol.DataPackage) error { head := msg.Head tail := msg.Tail if (head.Command == protocol.CLIENT_CMD_USER_LOGIN || head.Command == protocol.CLIENT_CMD_USER_REGISTER) && tail.UID != 0 { c.Uid = tail.UID c.Stat = CLIENT_STATE_ONLINE } buf := protocol.GetBuffer() defer protocol.PutBuffer(buf) binary.Write(buf, binary.BigEndian, head) binary.Write(buf, binary.BigEndian, msg.BodyData()) // write to Conn c.Conn.SetDeadline(time.Now().Add(NET_WRITE_DATELINE)) if _, err := c.Conn.Write(buf.Bytes()); err != nil { if e, ok := err.(net.Error); ok && e.Timeout() { syslog.Info("write timeouat:", err, *c) return nil } syslog.Warn("write to conn fail :", err.Error(), msg.Tail) return errors.As(err) } else { syslog.Debug2("write to conn success:", head, string(msg.BodyData()), msg.Tail) } return nil }
func (this *FileMgr) run() { exitNotify := this.waitGroup.ExitNotify() for { select { case <-exitNotify: return case <-this.expiredTimer: if err := this.RemoveExpiredFile(); err != nil { syslog.Warn(err) } case file := <-this.fileCh: if err := addFile(file); err != nil { syslog.Warn(err, *file) } } } }
func (h *Handler) HandleMessage(message *nsq.Message) error { dataPackage := common.GetDataPackage() defer common.PutDataPackage(dataPackage) if err := dataPackage.Unpackage(message.Body); err != nil { syslog.Warn(err) return nil } head := &dataPackage.Head jsonStr := dataPackage.BodyData() tail := &dataPackage.Tail switch head.Command { case common.XXX_CMD_SEND_USER_MSG: default: syslog.Warn("Invalid Cmd :", head.Command, *tail) } // get user state us, err := user.GetUserState(tail.UID) if err != nil { syslog.Info("GetUserState failed!!!", tail) return nil } // not online if us.Online == false { syslog.Debug("client not online!!! uid:", tail.UID) return nil } tail.IP = us.ConnIP tail.Port = us.ConnPort tail.SID = us.Sid tail.UID = us.Uid respBuf := common.GetBuffer() defer common.PutBuffer(respBuf) if err := common.Package(respBuf, head, jsonStr, tail); err != nil { syslog.Info(err) return nil } topic := fmt.Sprintf("conn_%s_%d", util.IPToStr(tail.IP), tail.Port) common.NsqPublish(topic, respBuf.Bytes()) return nil }
func (h *Handler) HandleMessage(message *nsq.Message) error { dataPackage := common.GetDataPackage() defer common.PutDataPackage(dataPackage) if err := dataPackage.Unpackage(message.Body); err != nil { syslog.Warn(err) return nil } head := &dataPackage.Head jsonStr := dataPackage.BodyData() tail := &dataPackage.Tail var err error = nil resp := []byte("") switch head.Command { case common.XXX_CMD_SEND_USER_MSG: resp, err = h.SendMsg(head, jsonStr, tail) case common.XXX_CMD_RECV_USER_MSG: //resp, err = h.ReceivedUserMsg(head, jsonStr, &tail) common.NsqPublish(common.MSG_STORE_TOPIC, message.Body) default: syslog.Info("invalid cmd:", head.Command, *tail) return nil } if err != nil { syslog.Warn("msg_server msg handle failed:", err, head, tail) head.ErrorCode = uint32(errors.Code(err)) resp = []byte("") } head.PkgLen = uint16(common.DATA_PACKAGE_HEAD_SIZE + len(resp)) respBuf := common.GetBuffer() defer common.PutBuffer(respBuf) if err := common.Package(respBuf, head, resp, tail); err != nil { syslog.Info(err) return nil } topic := fmt.Sprintf("conn_%s_%d", util.IPToStr(tail.IP), tail.Port) common.NsqPublish(topic, respBuf.Bytes()) return nil }
func (c *Client) Hello() { //dataPackage := pool.Get(DATA_PACKAGE).(*protocol.DataPackage) dataPackage := protocol.GetDataPackage() dataPackage.Head.PkgLen = uint16(protocol.DATA_PACKAGE_HEAD_SIZE) dataPackage.Head.Command = protocol.CLIENT_CMD_HEARTBEAT buf := protocol.GetBuffer() binary.Write(buf, binary.BigEndian, dataPackage.Head) c.Conn.SetDeadline(time.Now().Add(NET_WRITE_DATELINE)) if _, err := c.Conn.Write(buf.Bytes()); err != nil { syslog.Warn(err) } protocol.PutBuffer(buf) protocol.PutDataPackage(dataPackage) }
func (this *ClientGroup) Response() { var dp *protocol.DataPackage = nil var client *Client = nil for this.Exit == false { select { case dp = <-this.RespCh: client = dp.Data.(*Client) if err := client.Response(dp); err != nil { syslog.Warn(err) } atomic.AddInt32(&client.MsgCount, -1) protocol.PutDataPackage(dp) } } }
func (this *Service) Serve() { this.WaitGroup.AddOne() defer this.WaitGroup.Done() exitNotify := this.WaitGroup.ExitNotify() var grpCount int32 = 0 var clientCount int32 = 0 var sid uint32 = 10000 for { select { case <-exitNotify: return default: } this.Listener.SetDeadline(time.Now().Add(NET_READ_DATELINE)) conn, err := this.Listener.AcceptTCP() if err != nil { if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() { continue } syslog.Warn("Unknow Net Error:", err) break } syslog.Debug(conn.RemoteAddr(), "connected, seesionId:", sid) // 建立客户端 client := GetClient() client.Service = this client.Conn = conn client.Sid = sid client.Stat = CLIENT_STATE_INIT client.RespCh = nil client.MsgCount = 0 client.LastTime = time.Now().Unix() this.RWMutex.Lock() this.ClientMap[sid] = client this.RWMutex.Unlock() this.ClientCh <- client clientCount = atomic.AddInt32(&this.ClientCount, 1) grpCount = atomic.LoadInt32(&this.ClientGroupCount) if clientCount >= ((grpCount - 10) * CLIENT_NUM_PER_GROUP) { NewClientGroup(this) } // 处理客户端请求 sid++ // increase sid } }
func (h *DBHandler) HandleMessage(message *nsq.Message) error { var resp []byte var err error defer func() { if err != nil { syslog.Warn(err) } }() dataPackage := protocol.GetDataPackage() defer protocol.PutDataPackage(dataPackage) if err := dataPackage.Unpackage(message.Body); err != nil { return nil } head := &dataPackage.Head jsonStr := dataPackage.BodyData() tail := &dataPackage.Tail syslog.Debug(*head, string(jsonStr), *tail) switch head.Command { case protocol.CLIENT_CMD_USER_REGISTER: resp = h.Register(head, jsonStr, tail) case protocol.CLIENT_CMD_USER_LOGIN: resp = h.Login(head, jsonStr, tail) default: syslog.Debug("invalid cmd:", head.Command, *tail) return nil } respBuf := protocol.GetBuffer() defer protocol.PutBuffer(respBuf) head.PkgLen = uint16(protocol.DATA_PACKAGE_HEAD_SIZE + len(resp)) binary.Write(respBuf, binary.BigEndian, head) binary.Write(respBuf, binary.BigEndian, resp) binary.Write(respBuf, binary.BigEndian, tail) topic := fmt.Sprintf("conn_%s_%d", util.IPToStr(tail.IP), tail.Port) common.NsqPublish(topic, respBuf.Bytes()) syslog.Debug2("db_server --> conn_server publish:", topic, head, string(resp), tail) return nil }
func (this *Service) HandleMessage(message *nsq.Message) error { dp := protocol.GetDataPackage() if err := dp.Unpackage(message.Body); err != nil { syslog.Warn(err, string(message.Body)) protocol.PutDataPackage(dp) return nil } this.RWMutex.RLock() client, ok := this.ClientMap[dp.Tail.SID] this.RWMutex.RUnlock() if !ok || client.Stat == CLIENT_STATE_OFFLINE || dp.Tail.SID != client.Sid { protocol.PutDataPackage(dp) return nil } if client.RespCh == nil { protocol.PutDataPackage(dp) return nil } dp.Data = client client.RespCh <- dp atomic.AddInt32(&client.MsgCount, 1) return nil }