public Task<RPCData> DispatchCall(int callId, RPCData data) { var tcs = new TaskCompletionSource<RPCData>(); pendingCalls.Add(callId, tcs); data.Peer.Dispatch(data); return tcs.Task; }
internal void SetResult(int callId, RPCData data) { if (!pendingCalls.ContainsKey(callId)) { Log.Error("Received unexpected reply."); return; } pendingCalls[callId].SetResult(data); }
public override void Dispatch(RPCData data) { var bytes = data.Serializer.Buffer.ReadAllBytes(); var packet = new Packet(0); packet.Write(new List<byte>(bytes)); packet.Flags = ConvertFlags(data.Flags); Session.Peer.QueuePacket(packet, 0); }
internal void ProcessEventSubscribe(RPCData data) { var eventId = data.Serializer.ReadI32(); var remoteDelegateId = data.Serializer.ReadI32(); var subscribe = processors[eventId].Subscribe; if (subscribe == null) throw new Exception(); subscribe(data.Peer, remoteDelegateId); }
public void ProcessCall(RPCData.Call call) { var processCall = processors[call.MethodId].Call; if (processCall != null) { processCall(call); } else { SerializerUtil.Skip(call.Data.Serializer, TType.DataObject); var response = new RPCData(call.Data, RPCDataType.Exception); RPCException x = new RPCException(RPCException.ExceptionType.UnknownMethod, "Invalid method id: '" + call.MethodId + "'"); response.Serializer.WriteI32(call.Id); x.Write(response.Serializer); response.Dispatch(); } }
public void ProcessCall(RPCData.Call call) { var processCall = processors[call.MethodId].Call; if (processCall != null) { processCall(call); } else { SerializerUtil.Skip(call.Data.Serializer, TType.DataObject); var response = RPCData.Create(call.Data, RPCDataType.Exception); RPCException x = new RPCException(RPCException.ExceptionType.UnknownMethod, "Invalid method id: '" + call.MethodId + "'"); response.Serializer.WriteI32(call.Id); x.Write(response.Serializer); response.Dispatch(); } }
public unsafe void DispatchChanges() { foreach (var reference in referencesChanged) { var bitFieldsCount = reference.DataObject.BaseDataObjectCount + 1; var bitFields = stackalloc BitField[bitFieldsCount]; reference.DataObject.GetResetChanges(bitFields); foreach (var peer in reference.Subscribers) { var peerData = new RPCData(peer, RPCManager, reference.LocalId, 0, RPCDataType.ReferenceChanges); // TODO: Optimize this. Dont't serialize again for each peer. reference.DataObject.Write(peerData, bitFields, bitFieldsCount); peerData.Dispatch(); } } }
public void Process(RPCData data) { switch (data.Header.CallType) { case RPCDataType.ReferenceChanges: ProcessChanges(data); return; case RPCDataType.ReferenceSubscribe: ProcessSubscribe(data); return; case RPCDataType.ReferenceUnsubscribe: ProcessUnsubscribe(data); return; default: Debug.Assert(false); return; } }
private void ProcessUnsubscribe(RPCData data) { var localId = data.Header.LocalId; Reference reference; if (!localIdToReference.TryGetValue(localId, out reference)) throw new Exception("No reference to subscribe to."); reference.Subscribers.Remove(data.Peer); }
private void ProcessSubscribe(RPCData data) { var localId = data.Header.LocalId; Reference reference; if (!localIdToReference.TryGetValue(localId, out reference)) throw new Exception("No reference to subscribe to."); if (reference.Subscribers == null) reference.Subscribers = new HashSet<RPCPeer>(); reference.Subscribers.Add(data.Peer); //TODO send complete serialization }
private void ProcessChanges(RPCData data) { var subscription = new Subscription(data.Peer, data.Header.RemoteId); Reference reference; if (!subscriptionToReference.TryGetValue(subscription, out reference)) throw new Exception("Reference not found."); reference.DataObject.Read(data); }
internal static DelegateCall Create(RPCData data) { var call = new DelegateCall(); call.Data = data; call.Id = data.Serializer.ReadI32(); return call; }
public abstract void Invoke(RPCData.DelegateCall call);
public abstract void Dispatch(RPCData data);
internal Call(int id, int methodId, RPCPeer peer, RPCManager rpcManager, int localId, int remoteId) { Id = id; MethodId = methodId; Data = new RPCData(peer, rpcManager, localId, remoteId, RPCDataType.Call); Data.Serializer.WriteI32(id); Data.Serializer.WriteI32(methodId); if (remoteId == 0) { GlobalServiceId = rpcManager.ServiceManager.GetGlobalServiceId(localId); GlobalServiceId.Write(Data); } else { GlobalServiceId = default(GlobalServiceId); } }
internal static Call Create(RPCData data) { var call = new Call(); call.Data = data; call.Id = data.Serializer.ReadI32(); call.MethodId = data.Serializer.ReadI32(); if (data.Header.LocalId == 0) call.GlobalServiceId = GlobalServiceId.Read(data); return call; }
public RPCData(RPCData call, RPCDataType type, RPCFlags flags = RPCFlags.None) : this(call.Peer, call.RPCManager ,call.Header.LocalId, call.Header.RemoteId, type, flags) { }
internal static Reply Create(RPCData data) { var reply = new Reply(); reply.Data = data; reply.Id = data.Serializer.ReadI32(); reply.MethodId = data.Serializer.ReadI32(); return reply; }
public Reply(Call call) { Id = call.Id; MethodId = call.MethodId; Data = new RPCData(call.Data, RPCDataType.Reply); Data.Serializer.WriteI32(Id); Data.Serializer.WriteI32(MethodId); }
internal static DelegateReply Create(RPCData data) { var reply = new DelegateReply(); reply.Data = data; reply.Id = data.Serializer.ReadI32(); return reply; }
public DelegateReply(DelegateCall call) { Id = call.Id; Data = new RPCData(call.Data, RPCDataType.DelegateReply); Data.Serializer.WriteI32(Id); }
public static RPCData Create(RPCData call, RPCDataType type, RPCFlags flags = RPCFlags.None) { return(Create(call.Peer, call.Header.LocalId, call.Header.RemoteId, type, flags)); }
public abstract void Dispatch(RPCData data);
internal void ProcessEventUnsubscribe(RPCData data) { throw new System.NotImplementedException(); }
internal void ProcessEventUnsubscribe(RPCData data) { throw new System.NotImplementedException(); }
internal void ProcessReply(RPCData.DelegateReply reply) { callProcessor.SetResult(reply.Id, reply.Data); }
public void Subscribe(IObservableDataObject dataObject, RPCPeer peer, int remoteId) { Reference reference; if (!dataObjectToReference.TryGetValue(dataObject, out reference)) reference = CreateReference(dataObject); reference.Subscription = new Subscription(peer, remoteId); subscriptionToReference.Add(reference.Subscription, reference); var data = new RPCData(peer, RPCManager, reference.LocalId, remoteId, RPCDataType.ReferenceSubscribe); data.Dispatch(); }
public Task<RPCData> DispatchCall(RPCData.DelegateCall call) { return callProcessor.DispatchCall(call.Id, call.Data); }
internal DelegateCall(int id, RPCPeer peer, RPCManager rpcManager, int localId, int remoteId) { Id = id; Data = new RPCData(peer, rpcManager, localId, remoteId, RPCDataType.DelegateCall); Data.Serializer.WriteI32(id); }