Golang buffpool.BuffPool类代码示例

func (this *DispatcherOutComponent) checkConnActivity(Time time.Time, client *model.Client, buffPool *buffpool.BuffPool, number uint16, userUuid string, devID uint32, token uint8) bool {
	//5分钟
	if time.Now().Sub(Time) > define.KEEP_ALIVE_PEORID {
		if client.Conn != nil {
			(*client.Conn).Close()
		}
		if token > 0 {
			err := buffPool.RemoveClient(number, userUuid, devID, token)
			if err != nil {
				err = errors.New("DispatcherComponent.checkConnActivity() Error:can not remove invalid client's connection, " + err.Error())
				fmt.Println(err.Error())
				return false
			}
			clientArr := buffPool.QueryForDeviceId(number, userUuid, devID)
			if clientArr == nil || len(clientArr) == 0 {
				//offline broadcast
				unregister := GetUnregisterComponent()
				if unregister != nil {
					err2 := unregister.offlineBroadcast(buffPool, userUuid, devID)
					if err2 != nil {
						err2 = errors.New("cDispatcherComponent.checkConnActivity() Error: " + err2.Error())
						fmt.Println(err2.Error())
					}
				} else {
					fmt.Println("DispatcherComponent.checkConnActivity() Error: one client disconnected, but offline broadcast send failed, ")
				}
			}

		}
		return false
	}
	return true
}

func (this *RegisterComponent) handleService(buffPool *buffpool.BuffPool, message *protocol.Message, conn *net.Conn) {
	if buffPool == nil || message == nil || conn == nil {
		err := errors.New("RegisterComponent handleService Error: the argument is nil")
		return err
	}
	err := buffPool.AddService(message.Number, message.UserUuid, conn)
	if err != nil {
		err = fmt.Errorf("RegisterCompoennt handleService Error: %v", err)
		return err
	}
	responseMessage, err := protocol.NewMessage(protocol.VERSION, protocol.MT_REGISTER, protocol.PT_PUSHSERVER, 0, message.Number, 0, P_UID,
		message.UserUuid, 0, nil)
	if err != nil {
		err = fmt.Errorf("RegisterComponent handleService Error:%v", err)
		return err
	}
	GetDispatcherOutComponent().NPushBack(responseMessage, false)

	if GetRunWithSnode().Flag {
		onlineInfo := structure.ClientOnlineInfo{
			PushID:   this.PushID,
			ParentID: this.PushID,
		}
		data, err := onlineInfo.Encode()
		if err != nil {
			err = fmt.Errorf("RegisterCompoennt handleService Error:%v", err)
			return err
		}
		snode_component.GetNodeComponent().Forward(stree_define.ONLINE, msg.UserId, 0, data) //added for QueryUser
	}

	go this.listenService(conn, buffPool, message.Number, message.UserUuid)
	return nil
}

func (this *DispatcherOutComponent) handleMTRegister(msg *protocol.Message, buffPool *buffpool.BuffPool, respComp *ResponseComponent) error {
	if msg.PushType == protocol.PT_PUSHSERVER {
		conn := buffPool.QueryService(msg.Number, msg.DestUuid)
		if conn == nil {
			clientConn := buffPool.GetClient(msg.Number, msg.DestUuid, msg.DeviceId, msg.Token)
			if clientConn == nil || clientConn.Conn == nil {
				err := errors.New("DispatcherOutComponent.handleMTRegister() Error: can not find the dest conn")
				fmt.Println(err.Error())
				return err
			}
			conn = clientConn.Conn
		}
		if conn == nil {
			err := errors.New("DispatcherOutComponent.handleMTRegister() Error: can not find the dest conn")
			fmt.Println(err.Error())
			return err
		}
		err := this.sendMessage(msg, conn)
		if err != nil {
			err = errors.New("DispatcherComponnet.handleMTRegister() Error: can not send message out, " + err.Error())
			fmt.Println(err.Error())
			return err
		}
	}
	return nil
}

func (this *RegisterComponent) listenService(conn *net.Conn, buffPool *buffpool.BuffPool, number uint16, userUuid string) error {
	if buffPool == nil {
		err := errors.New("RegisterComponent listenService Error: buffpool is nil")
		return err
	}
	if conn == nil {
		err := errors.New("RegisterComponent listenService Error: the conn is nil")
		if GetRunWithSnode().Flag {
			this.ServiceOffline(userUuid)
		}

		err = buffPool.DeleteService(number, userUuid)
		if err != nil {
			err = fmt.Errorf("RegisterComponent listenService Error:%v", err)
			return err
		}
		return err
	}
	var dispatcher *DispatcherComponent
	for {
		dispatcher = GetDispatcherComponent()
		if dispatcher != nil {
			break
		} else {
			fmt.Println("RegisterComponent listenService Error: can not get DispatcherCompoennt")
		}
	}
	for {
		message, err := this.readMessage(conn)
		if number == protocol.N_ACCOUNT_SYS {

		}
		if err != nil && err != io.EOF && conn != nil {
			fmt.Println("RegisterComponent listenService Error: read message fail")
			continue
		} else if err != nil && (err == io.EOF|conn == nil) {
			err = errors.New("RegisterComponent listenService Error:the connection is invalid")
			err2 := buffPool.DeleteService(number, userUuid)

			if GetRunWithSnode().Flag {
				this.ServiceOffline(userUuid)
			}

			if err2 != nil {
				err2 = fmt.Errorf("RegisterComponent listenService Error: %v", err)
				fmt.Println(err2.Error())
				return err2
			}
			fmt.Println(err.Error())
			return err
		}

		if message == nil {
			continue
		}
		dispatcher.NPushBack(message, true)
	}
	return nil
}

func (this *UnregisterComponent) unregisterClient(buffPool *buffpool.BuffPool, msg *protocol.Message) error {
	if buffPool == nil || msg == nil {
		err := errors.New("UnregisterComponent.unregisterClient() Error: invalid argument")
		fmt.Println(err.Error())
		return err
	}
	clientConn := buffPool.GetClient(msg.Number, msg.UserUuid, msg.DeviceId, msg.Token)
	if clientConn == nil {
		return nil
	}

	//only remove conn from connPool, but do not disconnect this connection
	err := buffPool.RemoveClient(msg.Number, msg.UserUuid, msg.DeviceId, msg.Token)
	(*clientConn.Conn).Close()
	if err != nil {
		err = errors.New("UnregisterComponent.unregisterClient() Error: " + err.Error())
		fmt.Println(err.Error())
		//send failed response to client
		resp, err2 := protocol.NewMessage(protocol.VERSION, protocol.MT_ERROR, protocol.PT_PUSHSERVER, msg.Token, msg.Number, uint16(0),
			P_UID, msg.UserUuid, msg.DeviceId, nil)
		if err2 != nil {
			err2 = errors.New("UnregisterComponent.unregisterClient() Error:" + err2.Error())
			fmt.Println(err2.Error())
			return err2
		}
		err3 := sendResponse(clientConn.Conn, resp)
		if err3 != nil {
			err3 = errors.New("UnregisterComponent.unregisterClient() Error:, " + err3.Error())
			fmt.Println(err3.Error())
			return err3
		}
		return err
	}

	//offline broadcast
	err = this.offlineBroadcast(buffPool, msg.UserUuid, msg.DeviceId)
	if err != nil {
		err = errors.New("UnregisterComponent.unregisterClient() Error: offlineBroadcast send failed, " + err.Error())
		fmt.Println(err.Error())
	}

	resp, err := protocol.NewMessage(protocol.VERSION, protocol.MT_UNREGISTER, protocol.PT_PUSHSERVER, msg.Token, msg.Number, uint16(0),
		P_UID, msg.UserUuid, msg.DeviceId, nil)
	if err != nil {
		err = errors.New("UnregisterComponent.unregisterClient() Error: conn is removed from BuffPool, but can not send response to service" + err.Error())
		fmt.Println(err.Error())
		return err
	}
	err2 := sendResponse(clientConn.Conn, resp)
	if err2 != nil {
		err2 = errors.New("UnregisterComponent.unregisterClient() Error:conn is reomved from BuffPool, but failed when send response to service" + err2.Error())
		return err2
	}
	return nil
}

func (this *UnregisterComponent) offlineBroadcast(buffPool *buffpool.BuffPool, userUuid string, devID uint32) error {

	if GetRunWithSnode().Flag {
		snode_component.GetNodeComponent().Logout(userID, devID)
		snode_component.GetNodeComponent().DecUsersNumber()
		snode_component.GetNodeComponent().DecConnNumber()
	}

	if buffPool == nil {
		err := errors.New("UnRegisterComponent offlineBroadcast Error: invalid argument")
		return err
	}

	var dispatcherOut *DispatcherOutComponent
	for {
		dispatcherOut = GetDispatcherOutComponent()
		if dispatcherOut != nil {
			break
		} else {
			fmt.Println("UnregisterComponent.offlineBroadcast() Error:can not get a dispatcher, will try again")
		}
	}

	brMsg := protocol.BRMsg{
		UserUuid: userUuid,
		DeviceId: devID,
	}

	brData, err := brMsg.Encode()
	if err != nil {
		err := errors.New("UnregisterComponent.offlienBroadcast() Error: " + err.Error())
		return err
	}

	servNoUuidArr := buffPool.GetAllServices()
	for num, uuidArr := range servNoUuidArr {
		for _, uuid := range uuidArr {
			offlineMsg, err := protocol.NewMessage(protocol.VERSION, protocol.MT_BROADCAST_OFFLINE, protocol.PT_PUSHSERVER, 0, num, uint16(len(brData)),
				P_UID, uuid, 0, brData)
			if err != nil {
				err = errors.New("UnregisterComponent offlineBroadcast() Error: " + err.Error())
				return err
			}
			dispatcherOut.NPushBack(offlineMsg, false) //not need forward
		}
	}

	return nil
}

func (this *RegisterComponent) onlineBroadcast(buffPool *buffpool.BuffPool, dispatcherOut *DispatcherOutComponent, userUuid string, deviceID uint32) error {

	if GetRunWithSnode().Flag {
		onlineInfo := structure.ClientOnlineInfo{
			PushID:   this.PushID,
			ParentID: this.PushID,
		}
		data, err := onlineInfo.Encode()
		if err != nil {
			err = errors.New("RegisterComponent onlineBroadcast() Error: " + err.Error())
			return err
		}
		snode_component.GetNodeComponent().Forward(define.ONLINE, userUuid, deviceID, data)
		snode_component.GetNodeComponent().AddUsersNumber()
		snode_component.GetNodeComponent().AddConnNumber()
	}

	if buffPool == nil || dispatcherOut == nil {
		err := errors.New("RegisterComponent onlineBroadcast() Error: invalid argument")
		return err
	}

	brMsg := protocol.BRMsg{
		userUuid,
		deviceID,
	}
	brData, err := brMsg.Encode()
	if err != nil {
		err := errors.New("RegisterCompoent onlineBroadcast() Error: " + err.Error())
		return err
	}

	servNoUuidArr := buffPool.GetAllServices()
	for num, uuidArr := range servNoUuidArr {
		for _, uuid := range uuidArr {
			onlineMsg, err := protocol.NewMessage(protocol.VERSION, protocol.MT_BROADCAST_ONLINE, protocol.PT_PUSHSERVER, 0, num, uint16(len(brData)),
				P_UID, uuid, 0, brData)
			if err != nil {
				err = errors.New("RegisterComponent onlineBroadcast() Error: " + err.Error())
				return err
			}
			dispatcherOut.NPushBack(onlineMsg, false) //not need forward
		}
	}
	return nil
}

func (this *RegisterComponent) checkAccountServer(buffPool *buffpool.BuffPool, message *protocol.Message, conn *net.Conn) bool {
	if buffPool == nil || message == nil || conn == nil {
		fmt.Println("RegisterComponent checkAccountServer() Error: invalid argument")
		return false
	}
	connService := buffPool.GetService(protocol.N_ACCOUNT_SYS)
	if connService == nil {
		fmt.Println("RegisterComponent checkAccountServer() Error: can not get the account_sys server")
		response, _ := protocol.NewMessage(protocol.VERSION, protoocl.MT_ERROR, protocol.PT_PUSHSERVER, message.Token, message.Number, 0, P_UID,
			message.UserUuid, 0, nil)
		err := sendResponse(conn, response)
		if err != nil {
			err = fmt.Errorf("RegisterComponent checkAccountServer() Error:%v", err)
			fmt.Println(err.Error())
		}
		return false
	}
	return true
}

func (this *UnregisterComponent) unregisterService(buffPool *buffpool.BuffPool, msg *protocol.Message) error {
	if buffPool == nil || msg == nil {
		err := errors.New("UnregisterComponent unregisterService() Error: invalid argument")
		return err
	}
	conn := buffPool.QueryService(msg.Number, msg.UserUuid)
	if conn == nil {
		return nil
	}
	//only remove conn from connPool, but do not disconnect this connection
	err := buffPool.DeleteService(msg.Number, msg.UserUuid)
	if err != nil {
		err = errors.New("UnregisterComponent unregisterService() Error: " + err.Error())
		//send failed response to client
		resp, err2 := protocol.NewMessage(protocol.VERSION, protocol.MT_ERROR, protocol.PT_PUSHSERVER, msg.Token, msg.Number, uint16(0),
			P_UID, msg.UserUuid, msg.DeviceId, nil)
		if err2 != nil {
			err2 = errors.New("UnregisterComponent.unregisterService() Error: " + err2.Error())
			return err2
		}
		err3 := sendResponse(conn, resp)
		if err3 != nil {
			err3 = errors.New("UnregisterComponent.unregisterService() Error: " + err3.Error())
			return err3
		}
		return err
	}

	resp, err := protocol.NewMessage(protocol.VERSION, protocol.MT_UNREGISTER, protocol.PT_PUSHSERVER, msg.Token, msg.Number, uint16(0),
		P_UID, msg.UserUuid, msg.DeviceId, nil)
	if err != nil {
		err = errors.New("UnregisterComponent unregisterService() Error:conn is removed from BuffPool, but can not send response to service" + err.Error())
		return err
	}
	err2 := sendResponse(conn, resp)
	if err2 != nil {
		err2 = errors.New("UnregisterComponent unregisterService() Error: conn is reomved from BuffPool, but failed when send response to service" + err2.Error())
		return err2
	}
	return nil
}

func (this *DispatcherOutComponent) sendToService(msg *protocol.Message, buffPool *buffpool.BuffPool) (*net.Conn, error) {
	if msg == nil || buffPool == nil {
		err := errors.New("DispatcherOutComponent.sendToService() Error: invalid argument")
		fmt.Println(err.Error())
		return nil, err
	}
	var conn *net.Conn
	if msg.DestUuid == P_UID {
		conn = buffPool.GetService(msg.Number)
	} else {
		conn = buffPool.QueryService(msg.Number, msg.DestUuid)
		if conn == nil {
			conn = buffPool.GetService(msg.Number)
		}
	}

	if conn == nil {
		err := errors.New("DispatcherOutComponent.sendToService() Error:  can not get a server connection from buffpool")
		fmt.Println(err.Error())
		return nil, err
	}

	err := this.sendMessage(msg, conn)
	if err != nil {
		err = errors.New("DispatcherOutComponent.sendToService() Error:  can not send message to server's connection")
		fmt.Println(err.Error())
		return conn, err
	}
	return conn, nil
}

func (this *DispatcherOutComponent) sendToService2(msg *protocol.Message, forward bool, buffPool *buffpool.BuffPool) (*net.Conn, error) {
	if msg == nil || buffPool == nil {
		err := errors.New("DispatcherOutComponent.sendToService() Error: invalid argument")
		fmt.Println(err.Error())
		return nil, err
	}
	var conn *net.Conn
	if msg.DestUuid == P_UID {
		conn = buffPool.GetService(msg.Number)
	} else {
		conn = buffPool.QueryService(msg.Number, msg.DestUuid)
		if conn == nil && forward && GetRunWithSnode().Flag {
			buf, err := msg.Encode()
			if err != nil {
				fmt.Println(err)
				return nil, err
			}
			snode_component.GetNodeComponent().Forward(stree_define.FORWARD, msg.DestUuid, msg.DeviceId, buf)
			return nil, nil
		}
	}

	if conn == nil {
		err := errors.New("DispatcherOutComponent.sendToService() Error:  can not find dest server")
		fmt.Println(err.Error())
		return nil, err
	}

	err := this.sendMessage(msg, conn)
	if err != nil {
		err = errors.New("DispatcherOutComponent.sendToService() Error: can not send message to server's connection")
		fmt.Println(err.Error())
		return conn, err
	}
	if msg.MsgType == protocol.MT_PUBLISH {
		fmt.Println("\n", time.Now().String(), "MT_PUBLISH: sendToService2 Directly OK", "\n")
	}
	return conn, nil
}

func (this *DispatcherOutComponent) sendToClient2(msg *protocol.Message, forward bool, buffPool *buffpool.BuffPool) error {
	if msg == nil || buffPool == nil {
		err := errors.New("DispatcherOutComponent.sendToClient2() Error: invalid argument")
		fmt.Println(err.Error())
		return err
	}

	clientConnArr := make([]*model.Client, 0)
	if msg.Token > 0 {
		clientConn := buffPool.GetClient(msg.Number, msg.DestUuid, msg.DeviceId, msg.Token)
		if clientConn != nil && clientConn.Conn != nil {
			clientConnArr = append(clientConnArr, clientConn)
		}
		if (clientConnArr == nil || len(clientConnArr) <= 0) && forward && GetRunWithSnode().Flag {
			buf, err := msg.Encode()
			if err != nil {
				fmt.Println("DispatcherOutComponent.sendToClient2() Error: " + err.Error())
				fmt.Println("\n", time.Now().String(), "Not find user, not forward due to encode failed.", "\n")
				return err
			}
			snode_component.GetNodeComponent().Forward(stree_define.FORWARD, msg.DestUuid, msg.DeviceId, buf)
			return nil
		}
	} else if msg.Token == 0 && msg.DeviceId > 0 {
		clientConnArr = buffPool.QueryForDeviceId(msg.Number, msg.DestUuid, msg.DeviceId)
		if (clientConnArr == nil || len(clientConnArr) <= 0) && forward && GetRunWithSnode().Flag {
			buf, err := msg.Encode()
			if err != nil {
				fmt.Println("DispatcherOutComponent.sendToClient2() Error:" + err.Error())
				fmt.Println("\n", time.Now().String(), "Not find user, not forward due to encode failed.", "\n")
				return err
			}
			snode_component.GetNodeComponent().Forward(stree_define.FORWARD, msg.DestUuid, msg.DeviceId, buf)
			return nil
		}
	} else if msg.Token == 0 && msg.DeviceId == 0 {
		clientConnArr = buffPool.QueryForUuid(msg.Number, msg.DestUuid)
	}

	err := errors.New("DispatcherOutComponent.sendToClient2() Error: the client's connection not pass authorization yet")
	for _, client := range clientConnArr {
		if client == nil || client.Conn == nil {
			continue
		}
		if !this.checkConnActivity(client.Time, client, buffPool, msg.Number, msg.DestUuid, msg.DeviceId, msg.Token) {
			err := errors.New("DispatcherOutComponent.sendToClient2() Error: client's connection is not alive")
			fmt.Println(err.Error())
			continue
		}
		err2 := this.sendMessage(msg, client.Conn)
		if err2 != nil {
			err2 = errors.New("DispatcherOutComponent.sendToClient2() Error: can not send message to client's connection")
			fmt.Println(err.Error())
			continue
		}
	}
	return nil
}

func (this *RegisterComponent) handleClient(buffPool *buffpool.BuffPool, queryComponent *QueryComponent,
	message *protocol.Message, conn *net.Conn) {
	if buffPool == nil || queryComponent == nil || message == nil || conn == nil || len(msg.Data) != DEVNO_LEN {
		err := errors.New("RegisterComponent handleClient() Error : invaild argument")
		return err
	}
	if !this.checkAccountServer(buffPool, message, conn) {
		err := errors.New("RegisterCompoennt handleClient() Error: the account server is not register")
		return err
	}
	clientConn := model.Client{Conn: conn, Status: false}
	var token uint8
	if message.Token == 0 {
		token = buffPool.AddTmpClient(message.Number, message.UserUuid, string(message.Data), &clientConn)
	} else {
		token = buffPool.AddTmpClient2(message.Number, message.UserUuid, string(message.Data), message.DeviceId,
			message.Token, &clientConn)
	}

	if token == 0 {
		err := errors.New("RegisterCompoennt handleClient() Error: can not add the client to buffpool")
		return err
	}

	queryInfo := protocol.QueryInfo{
		Token:        token,
		Numebr:       message.Number,
		UserUuid:     message.UserUuid,
		DeviceNumber: string(message.Data),
	}

	err := queryComponent.AcceptInfo(queryInfo)
	if err != nil {
		err = fmt.Errorf("RegisterCompoennt handleClient() Error: %v", err)
		return er
	}
	return nil
}

func (this *DispatcherOutComponent) sendToClient(msg *protocol.Message, buffPool *buffpool.BuffPool) error {
	if msg == nil || buffPool == nil {
		err := errors.New("DispatcherOutComponent.sendToClient() Error: invalid argument")
		fmt.Println(err.Error())
		return err
	}
	clientConnArr := make([]*model.Client, 0)

	if msg.Token > 0 {
		clientConn := buffPool.GetClient(msg.Number, msg.DestUuid, msg.DeviceId, msg.Token)
		if clientConn != nil && clientConn.Conn != nil {
			clientConnArr = append(clientConnArr, clientConn)
		}
	} else if msg.Token == 0 && msg.DeviceId > 0 {
		clientConnArr = buffPool.QueryForDeviceId(msg.Number, msg.DestUuid, msg.DeviceId)
	} else if msg.Token == 0 && msg.DeviceId == 0 {
		clientConnArr = buffPool.QueryForUuid(msg.Number, msg.DestUuid)
	}

	if clientConnArr != nil && len(clientConnArr) <= 0 {
		err := errors.New("DispatcherOutComponent.sendToClient() Error: can not find client's connection")
		fmt.Println(err.Error())
		return err
	}

	err := errors.New("DispatcherOutComponent.sendToClient() Error: the client's connection not pass authorization yet")
	for _, client := range clientConnArr {
		if client == nil || client.Conn == nil {
			continue
		}

		if !this.checkConnActivity(client.Time, client, buffPool, msg.Number, msg.DestId, msg.DeviceId, msg.Token) {
			err := errors.New("DispatcherOutComponent.sendToClient() Error: client's connection is not alive")
			fmt.Println(err.Error())
			continue
		}

		err2 := this.sendMessage(msg, client.Conn)
		if err2 != nil {
			err2 = errors.New("DispatcherOutComponent.sendToClient() Error: can not send message to client's connection")
			fmt.Println(err.Error())
			continue
		}
	}

	return err
}

func (this *RegisterComponent) listenClient(conn *net.Conn, buffPool *buffpool.BuffPool, number uint16, userUuid string, deviceID uint32, token uint8) error {
	if buffPool == nil {
		err := errors.New("RegisterComponent listenClient() Error: invalid argument")
		fmt.Println(err.Error())
		return err
	}
	if conn == nil {
		err := errors.New("RegisterComponent listenClient() Error:invalid argument")
		fmt.Println(err.Error())
		fmt.Println("the invalid client connection will be removed")
		err2 := buffPool.RemoveClient(number, userUuid, deviceID, token)
		if err2 != nil {
			err2 = errors.New("RegisterComponent listenClient() Error:remove the invalid client's connection failed" + err2.Error())
			fmt.Println(err2.Error())
			return err2
		}
		fmt.Println("the invalid client connection has been removed")
		return err
	}
	var dispatcher *DispatcherComponent
	for {
		dispatcher = GetDispatcherComponent()
		if dispatcher != nil {
			break
		} else {
			fmt.Println("RegisterComponent listenClient() Error:can not get DispatcherComponent, will try again")
		}
	}

	for {
		msg, err := this.readMessage(conn)
		if err != nil && err != io.EOF && conn != nil {
			err = errors.New("RegisterComponent listenClient() Error " + err.Error())
			fmt.Println(err.Error())
			continue
		} else if err != nil && (err == io.EOF || conn == nil) {
			err = errors.New("RegisterComponent listenClient() Error the connection is invalid, " + err.Error())
			err2 := buffPool.RemoveClient(number, userUuid, deviceID, token)
			if conn != nil {
				(*conn).Close()
			}
			if err2 != nil {
				err2 = errors.New("RegisterComponent listenClient() Error: can not remove invalid client's connection, " + err2.Error())
				fmt.Println(err2.Error())
				return err2
			}
			clientArr := buffPool.QueryForDeviceId(number, userUuid, deviceID)
			if clientArr == nil || len(clientArr) == 0 {
				//offline broadcast
				unregister := GetUnregisterComponent()
				if unregister != nil {
					err3 := unregister.offlineBroadcast(buffPool, userUuid, deviceID)
					if err3 != nil {
						err3 = errors.New("RegisterComponent listenClient() Error:one client disconnected but offlineBroadcast send failed, " + err3.Error())
						fmt.Println(err3.Error())
					}
				} else {
					fmt.Println("RegisterComponent listenClient() Error:one client disconnected but offlineBroadcast send failed")
				}
			}

			return err
		}
		//push to DispatcherQueue
		if msg == nil {
			continue
		}
		dispatcher.NPushBack(msg, true) //need forward
	}
	return nil
}