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 }