public static async Task <int> SendDataToUserById(RPCType type, ObjectId id, PackedWebSocketMessage message) { //Find the group var group = Program.holder.FindGroup(new RPCGroupQueryUser { type = type, user_id = id }); if (group == null) { return(0); } //Send event to all await group.SendDistributedMessage(message, new List <LibDeltaSystem.WebFramework.WebSockets.Groups.GroupWebSocketService>()); return(group.clients.Count); }
public static async Task <int> SendDataToServerTribeById(RPCType type, ObjectId id, int tribe_id, PackedWebSocketMessage message) { //Find the group var group = Program.holder.FindGroup(new RPCGroupQueryServerTribe { type = type, server_id = id, tribe_id = tribe_id }); if (group == null) { return(0); } //Send event to all await group.SendDistributedMessage(message, new List <LibDeltaSystem.WebFramework.WebSockets.Groups.GroupWebSocketService>()); //Also send this to server admins, as they could also be viewing this tribe int adminCount = await SendDataToServerAdminsById(type, id, message, group.clients); return(group.clients.Count + adminCount); }
public SwitchWorld(RPCType type, string receiver, string user, string world) : base(type, receiver) { this.user = user; this.world = world; }
/// <summary> /// RPC初始化 /// </summary> /// <param name="IP">IP地址</param> /// <param name="Point">端口号</param> /// <param name="type">RPC类型</param> protected RPCCore(string IP, int Point, RPCType type) { Net = new NetSocketCore(IP, Point); this.Type = type; FuncMap = new ConcurrentDictionary <string, Delegate>(); }
/// <summary> /// Execute a remote procedure. /// </summary> /// <param name="netInstanceID">The <see cref="NetworkIdentity.InstanceID"/>.</param> /// <param name="function">The name of the function.</param> /// <param name="parameters">The function parameters.</param> public void Call(NetworkIdentity identity, RPCType type, string function, params object[] parameters) { int connectionID = NetworkController.Instance.IsServer ? identity.OwnerConnection?.ConnectionID ?? -1 : NetworkController.Instance.ConnectionID; if (!NetworkController.Instance.IsServer) { if (type == RPCType.Target) { throw new InvalidOperationException("You cannot send a targetted RPC because you are not the server."); } if (identity.OwnerConnection == null) { throw new InvalidOperationException("The network identity has no owner and cannot execute any RPCs"); } if (identity == null) { throw new InvalidOperationException("The network identity specified does not exist on this client: " + identity.InstanceID); } if (identity.OwnerConnection.ConnectionID != NetworkController.Instance.LocalConnectionID) { throw new InvalidOperationException("You are not the owner of this object and cannot execute RPCs on it."); } } int index = m_Methods?.FindIndex(x => x.m_MethodName == function) ?? -1; if (index == -1) { return; } RPCMethodInfo rpc = m_Methods[index]; if (rpc.m_ArgumentCount != parameters.Length) { throw new InvalidOperationException("Given argument count for " + function + " does not match the argument count specified."); } NetworkWriter writer = GetRPCWriter(NetworkController.Instance.LocalConnectionID, identity.InstanceID, (byte)type, index, rpc.m_ArgumentCount, parameters); byte[] data = writer.ToArray(); switch (type) { case RPCType.All: { if (NetworkController.Instance.IsServer) { NetworkController.Instance.SendToAll(NetworkController.ReliableSequencedChannel, RPCMsg, data); } else { NetworkController.Instance.Send(connectionID, NetworkController.ReliableSequencedChannel, RPCMsg, data); } break; } case RPCType.Others: { if (NetworkController.Instance.IsServer) { NetworkController.Instance.SendToAll(NetworkController.ReliableSequencedChannel, RPCMsg, data); } else { NetworkController.Instance.Send(connectionID, NetworkController.ReliableSequencedChannel, RPCMsg, data); } break; } case RPCType.ServerOnly: { if (NetworkController.Instance.IsServer) { NetworkBehaviour networkBehaviour = identity.GetComponent <NetworkBehaviour>(); networkBehaviour.InvokeRPC(function, parameters); } else { NetworkController.Instance.Send(connectionID, NetworkController.ReliableSequencedChannel, RPCMsg, data); } break; } case RPCType.AllBuffered: { if (NetworkController.Instance.IsServer) { InitBuffer(identity.InstanceID); m_BufferedMessages[identity.InstanceID].Add(new NetworkWriter(writer.ToArray())); NetworkController.Instance.SendToAll(NetworkController.ReliableSequencedChannel, RPCMsg, data); } else { NetworkController.Instance.Send(connectionID, NetworkController.ReliableSequencedChannel, RPCMsg, data); } break; } case RPCType.OthersBuffered: { if (NetworkController.Instance.IsServer) { InitBuffer(identity.InstanceID); m_BufferedMessages[identity.InstanceID].Add(new NetworkWriter(writer.ToArray())); NetworkController.Instance.SendToAll(NetworkController.ReliableSequencedChannel, RPCMsg, data); } else { NetworkController.Instance.Send(connectionID, NetworkController.ReliableSequencedChannel, RPCMsg, data); } break; } case RPCType.Target: { if (parameters.Length > 0) { NetworkConnection connection = (NetworkConnection)parameters[0]; if (connection != null) { connection.Send(NetworkController.ReliableSequencedChannel, RPCMsg, data); } } break; } } }
private void OnRPC(NetworkWriter writer) { ReadRPC(writer, out int connection, out int instanceID, out byte rpcType, out int rpcIndex, out int argumentCount, out object[] arguments); NetworkIdentity identity = NetworkIdentityManager.Instance.Get(instanceID); if (identity == null) { if (!NetworkController.Instance.IsServer) { InitBuffer(instanceID); m_BufferedMessages[instanceID].Add(new NetworkWriter(writer.ToArray())); } return; } if (rpcIndex == -1 || rpcIndex >= m_Methods.Count) { return; } if (NetworkController.Instance.IsServer) { RPCType type = (RPCType)rpcType; if (type != RPCType.ServerOnly) { if (identity.OwnerConnection == null || identity.OwnerConnection.ConnectionID != connection) { return; } if (NetworkController.Instance.GetConnection(connection) == null) { return; } } switch (type) { case RPCType.All: NetworkController.Instance.SendToAll(NetworkController.ReliableSequencedChannel, RPCMsg, writer.ToArray()); return; case RPCType.AllBuffered: NetworkController.Instance.SendToAll(NetworkController.ReliableSequencedChannel, RPCMsg, writer.ToArray()); InitBuffer(instanceID); m_BufferedMessages[instanceID].Add(new NetworkWriter(writer.ToArray())); return; case RPCType.Others: NetworkController.Instance.SendToAllExcluding(writer.ToArray(), NetworkController.ReliableSequencedChannel, RPCMsg, connection); return; case RPCType.OthersBuffered: NetworkController.Instance.SendToAllExcluding(writer.ToArray(), NetworkController.ReliableSequencedChannel, RPCMsg, connection); InitBuffer(instanceID); m_BufferedMessages[instanceID].Add(new NetworkWriter(writer.ToArray())); return; } } RPCMethodInfo method = m_Methods[rpcIndex]; NetworkBehaviour behaviour = (NetworkBehaviour)identity.GetComponent(method.m_TypeName); behaviour.InvokeRPC(method.m_MethodName, arguments); }
internal static async Task <Response> HandleRpc(Protos.Request req, RPCType type, Stopwatch sw) { byte[] data = req.Msg.Data.ToByteArray(); Route route = Route.FromString(req.Msg.Route); string handlerName = $"{route.service}.{route.method}"; PitayaSession s = null; var response = new Response(); RemoteMethod handler; if (type == RPCType.Sys) { s = new Models.PitayaSession(req.Session, req.FrontendID); if (!HandlersDict.ContainsKey(handlerName)) { response = GetErrorResponse("PIT-404", $"remote/handler not found! remote/handler name: {handlerName}"); return(response); } handler = HandlersDict[handlerName]; MetricsReporters.ReportMessageProccessDelay(req.Msg.Route, "local", sw); } else { if (!RemotesDict.ContainsKey(handlerName)) { response = GetErrorResponse("PIT-404", $"remote/handler not found! remote/handler name: {handlerName}"); return(response); } handler = RemotesDict[handlerName]; MetricsReporters.ReportMessageProccessDelay(req.Msg.Route, "remote", sw); } Task ans; if (handler.ArgType != null) { var arg = _serializer.Unmarshal(data, handler.ArgType); if (type == RPCType.Sys) { ans = handler.Method.Invoke(handler.Obj, new[] { s, arg }) as Task; } else { ans = handler.Method.Invoke(handler.Obj, new[] { arg }) as Task; } } else { if (type == RPCType.Sys) { ans = handler.Method.Invoke(handler.Obj, new object[] { s }) as Task; } else { ans = handler.Method.Invoke(handler.Obj, new object[] { }) as Task; } } await ans; byte[] ansBytes; if (handler.ReturnType != typeof(void)) { ansBytes = SerializerUtils.SerializeOrRaw(ans.GetType(). GetProperty("Result") ?.GetValue(ans), _serializer); } else { ansBytes = new byte[] {}; } response.Data = ByteString.CopyFrom(ansBytes); return(response); }
public RPC(RPCType rpcType, string receiver) { this.rpcType = rpcType; this.receiver = receiver; GetType(); }
public RPC(RPCType rpcType) { this.rpcType = rpcType; GetType(); }
public Sync(RPCType type, string receiver, string member) : base(type, receiver) { this.member = member; }