func genSubKey(userId int64) (res map[int32][]string) { var ( i int ok bool key string keys []string client *rpc.Client err error arg = &rproto.GetArg{UserId: userId} reply = &rproto.GetReply{} ) res = make(map[int32][]string) if client, err = getRouterByUID(userId); err != nil { return } if err = client.Call(routerServiceGet, arg, reply); err != nil { log.Error("client.Call(\"%s\",\"%v\") error(%s)", routerServiceGet, arg, err) return } for i = 0; i < len(reply.Servers); i++ { key = encode(userId, reply.Seqs[i]) if keys, ok = res[reply.Servers[i]]; !ok { keys = []string{} } keys = append(keys, key) res[reply.Servers[i]] = keys } return }
func testSendDeadlock(client *protorpc.Client) { defer func() { recover() }() args := &Args{7, 8} reply := new(Reply) client.Call("Arith.Add", args, reply) }
func broadcastRoomComet(c *protorpc.Client, roomId int32, msg []byte) { var ( args = &cproto.BoardcastRoomArg{Ver: 0, Operation: define.OP_SEND_SMS_REPLY, Msg: msg, RoomId: roomId} err error ) if err = c.Call(CometServiceBroadcastRoom, args, nil); err != nil { log.Error("c.Call(\"%s\", %v, reply) error(%v)", CometServiceBroadcastRoom, *args, err) } }
func mpushComet(c *protorpc.Client, subkeys []string, body []byte) { var ( args = &cproto.MPushMsgArg{Keys: subkeys, Operation: define.OP_SEND_SMS_REPLY, Msg: body} rep = &cproto.MPushMsgReply{} err error ) if err = c.Call(CometServiceMPushMsg, args, rep); err != nil { log.Error("c.Call(\"%s\", %v, reply) error(%v)", CometServiceMPushMsg, *args, err) } }
func roomsComet(c *protorpc.Client) map[int32]bool { var ( reply = &cproto.RoomsReply{} err error ) if err = c.Call(CometServiceRooms, nil, reply); err != nil { log.Error("c.Call(\"%s\", nil, reply) error(%v)", CometServiceRooms, err) return nil } return reply.Rooms }
func getAllSubkeys(serverId string) (reply *rproto.GetAllReply, err error) { var client *rpc.Client if client, err = getRouterByServer(serverId); err != nil { return } reply = &rproto.GetAllReply{} if err = client.Call(routerServiceGetAll, nil, reply); err != nil { log.Error("client.Call(\"%s\") error(%s)", routerServiceGetAll, err) } return }
func allRoomCount(client *rpc.Client) (counter map[int32]int32, err error) { var ( reply = &rproto.AllRoomCountReply{} ) if err = client.Call(routerServiceAllRoomCount, nil, reply); err != nil { log.Error("c.Call(\"%s\", nil) error(%v)", routerServiceAllRoomCount, err) } else { counter = reply.Counter } return }
func getSubkeys(serverId string, userIds []int64) (reply *rproto.MGetReply, err error) { var client *rpc.Client if client, err = getRouterByServer(serverId); err != nil { return } arg := &rproto.MGetArg{UserIds: userIds} reply = &rproto.MGetReply{} if err = client.Call(routerServiceMGet, arg, reply); err != nil { log.Error("client.Call(\"%s\",\"%v\") error(%s)", routerServiceMGet, arg, err) } return }
func broadcastRoomComet(c *protorpc.Client, roomId int32, msg []byte) { var ( now = time.Now() args = &cproto.BoardcastRoomArg{Ver: 0, Operation: define.OP_SEND_SMS_REPLY, Msg: msg, RoomId: roomId} err error ) if err = c.Call(CometServiceBroadcastRoom, args, nil); err != nil { log.Error("c.Call(\"%s\", %v, reply) error(%v)", CometServiceBroadcastRoom, *args, err) } else { log.Info("broadcast msg to msg:%s room:%d(%f)", msg, roomId, time.Now().Sub(now).Seconds()) } }
func pushToComet(serverId int32, c *protorpc.Client, subkeys []string, body []byte, wg *sync.WaitGroup) { now := time.Now() args := &cproto.MPushMsgArg{Keys: subkeys, Operation: OP_SEND_SMS_REPLY, Msg: body} rep := &cproto.MPushMsgReply{} if err := c.Call(CometServiceMPushMsg, args, rep); err != nil { log.Error("c.Call(\"%s\", %v, reply) error(%v)", CometServiceMPushMsg, *args, err) goto done } log.Info("push msg to serverId:%d index:%d", serverId, rep.Index) log.Debug("push seconds %f", time.Now().Sub(now).Seconds()) done: wg.Done() }
func mpushComet(c *protorpc.Client, subkeys []string, body []byte) { var ( now = time.Now() args = &cproto.MPushMsgArg{Keys: subkeys, Operation: define.OP_SEND_SMS_REPLY, Msg: body} rep = &cproto.MPushMsgReply{} err error ) if err = c.Call(CometServiceMPushMsg, args, rep); err != nil { log.Error("c.Call(\"%s\", %v, reply) error(%v)", CometServiceMPushMsg, *args, err) } else { log.Info("push msg to index:%d(%f)", rep.Index, time.Now().Sub(now).Seconds()) } }
func disconnect(userID int64, seq int32) (has bool, err error) { var client *rpc.Client if client, err = getRouterByUID(userID); err != nil { return } arg := &rproto.DisconnArg{UserId: userID, Seq: seq} reply := &rproto.DisconnReply{} if err = client.Call(routerServiceDisconnect, arg, reply); err != nil { log.Error("c.Call(\"%s\",\"%v\") error(%s)", routerServiceDisconnect, *arg, err) } else { has = reply.Has } return }
func connect(userID int64, server int32) (seq int32, err error) { var client *rpc.Client if client, err = getRouterByUID(userID); err != nil { return } arg := &rproto.ConnArg{UserId: userID, Server: server} reply := &rproto.ConnReply{} if err = client.Call(routerServiceConnect, arg, reply); err != nil { log.Error("c.Call(\"%s\",\"%v\") error(%s)", routerServiceConnect, arg, err) } else { seq = reply.Seq } return }
func disconnect(userID int64, seq, roomId int32) (has bool, err error) { var ( client *rpc.Client arg = &rproto.DelArg{UserId: userID, Seq: seq, RoomId: roomId} reply = &rproto.DelReply{} ) if client, err = getRouterByUID(userID); err != nil { return } if err = client.Call(routerServiceDel, arg, reply); err != nil { log.Error("c.Call(\"%s\",\"%v\") error(%v)", routerServiceDel, *arg, err) } else { has = reply.Has } return }
func rpcPing(addr string, c *protorpc.Client, retry time.Duration) { var err error for { if err = c.Call(logicServicePing, nil, nil); err != nil { log.Error("c.Call(\"%s\", nil, nil) error(%v), retry after:%ds", logicServicePing, err, retry/time.Second) rpcTmp, err := protorpc.Dial("tcp", addr) if err != nil { log.Error("protorpc.Dial(\"tcp\", %s) error(%v)", addr, err) time.Sleep(retry) continue } c = rpcTmp time.Sleep(retry) continue } log.Debug("rpc ping:%s ok", addr) time.Sleep(retry) continue } }
func testHTTPRPC(t *testing.T, path string) { var client *protorpc.Client var err error if path == "" { client, err = protorpc.DialHTTP("tcp", httpServerAddr) } else { client, err = protorpc.DialHTTPPath("tcp", httpServerAddr, path) } if err != nil { t.Fatal("dialing", err) } defer client.Close() // Synchronous calls args := &Args{7, 8} reply := new(Reply) err = client.Call("Arith.Add", args, reply) if err != nil { t.Errorf("Add: expected no error but got string %q", err.Error()) } if reply.C != args.A+args.B { t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B) } }