public void Handle(Message message) { if (message.GetPropertyObjectID == null) { throw new ArgumentNullException("GetPropertyObjectID is null"); } var entry = this.m_ObjectStorage.Find(message.GetPropertyObjectID).FirstOrDefault(); if (entry == null) { throw new InvalidOperationException("Get property message received but we don't own the object!"); } var obj = entry.Value; var mi = obj.GetType().GetMethod("get_" + message.GetPropertyPropertyName + "__Distributed0", BindingFlagsCombined.All); if (mi == null) { throw new MissingMethodException( obj.GetType().FullName, "get_" + message.GetPropertyPropertyName + "__Distributed0"); } var value = DpmEntrypoint.InvokeDynamic(obj.GetType(), mi, obj, new Type[0], new object[] { }); var client = this.m_ClientLookup.Lookup(message.Sender.IPEndPoint); client.Send(this.m_MessageConstructor.ConstructGetPropertyResultMessage(message.ID, value)); }
public void Send(Stream stream, Message message) { if (!stream.CanWrite) { return; } if (message.ID == null) { throw new InvalidOperationException("Can not serialize a message without an ID!"); } message.SentFromReceivingThread = NetworkThreadContext.IsSentFromReceivingThread(); var writer = new BinaryWriter(stream); using (var memory = new MemoryStream()) { Serializer.Serialize(memory, message); var length = (int)memory.Position; memory.Seek(0, SeekOrigin.Begin); var reader = new BinaryReader(memory); var bytes = reader.ReadBytes(length); var checksum = this.CalculateChecksum(length, bytes); writer.Write(length); writer.Write(checksum); writer.Write(bytes); } }
public void Put(Message message) { lock (this.m_Messages) { this.m_Messages.Add(message); } }
public void Handle(Message message) { var entry = this.m_ObjectStorage.Find(message.SetPropertyObjectID).FirstOrDefault(); if (entry == null) { throw new InvalidOperationException("Set property message received but we don't own the object!"); } var obj = entry.Value; var mi = obj.GetType().GetMethod("set_" + message.SetPropertyPropertyName + "__Distributed0", BindingFlagsCombined.All); if (mi == null) { throw new MissingMethodException(obj.GetType().FullName, "set_" + message.SetPropertyPropertyName + "__Distributed0"); } var value = this.m_ObjectWithTypeSerializer.Deserialize(message.SetPropertyPropertyValue); DpmEntrypoint.InvokeDynamic(obj.GetType(), mi, obj, new Type[0], new[] { value }); this.m_ObjectStorage.UpdateOrPut(new LiveEntry { Key = message.SetPropertyObjectID, Value = obj, Owner = this.m_LocalNode.Self }); var client = this.m_ClientLookup.Lookup(message.Sender.IPEndPoint); client.Send(this.m_MessageConstructor.ConstructSetPropertyConfirmationMessage(message.ID)); }
/// <summary> /// Handle the specified message using the appropriate message handler. This /// is called when a message has been received over the network. /// </summary> /// <param name="message"> /// The message. /// </param> public void Receive(Message message) { if (!this.m_HandlerMappings.ContainsKey(message.Type)) { throw new InvalidOperationException("No handler for message type " + message.Type); } this.m_HandlerMappings[message.Type].Handle(message); }
public void Handle(Message message) { var client = this.m_ClientLookup.Lookup(message.Sender.IPEndPoint); var results = this.m_Lookup.Find(message.FetchKey).ToArray(); var serializedResults = results.Select( x => new SerializedEntry { Key = x.Key, Owner = x.Owner, Value = this.m_ObjectWithTypeSerializer.Serialize(x.Value) }).ToArray(); var confirmationMessage = this.m_MessageConstructor.ConstructFetchResultMessage( message.FetchKey, serializedResults); client.Send(confirmationMessage); }
/// <summary> /// Send a message to the remote host that this client handler is connected to. /// </summary> /// <param name="message"> /// The message. /// </param> public void Send(Message message) { message.Sender = this.m_LocalNode.Self; this.Receive(message); }
/// <summary> /// Send a message to the remote host that this client handler is connected to. /// </summary> /// <param name="message"> /// The message. /// </param> public void Send(Message message) { try { NetworkThreadContext.AssertSendIsValid((IPEndPoint)this.m_Client.Client.RemoteEndPoint); lock (this.m_Client) { this.m_MessageIo.Send(this.m_Client.GetStream(), message); } } catch (ObjectDisposedException) { // The client is no longer available. // TODO: Remove the client from the lookup list. } }
/// <summary> /// Handle the specified message using the appropriate message handler. This /// is called when a message has been received over the network. /// </summary> /// <param name="message"> /// The message. /// </param> public void Receive(Message message) { this.m_HandlerMappings[message.Type].Handle(message); }
public void Handle(Message message) { if (message.InvokeTypeArguments == null) { message.InvokeTypeArguments = new string[0]; } if (message.InvokeArguments == null) { message.InvokeArguments = new ObjectWithType[0]; } var entry = this.m_ObjectStorage.Find(message.InvokeObjectID).FirstOrDefault(); if (entry == null) { throw new InvalidOperationException("Invoke message received but we don't own the object!"); } var obj = entry.Value; var mi = obj.GetType().GetMethod(message.InvokeMethod, BindingFlagsCombined.All); if (mi == null) { throw new MissingMethodException(obj.GetType().FullName, message.InvokeMethod); } var targs = message.InvokeTypeArguments.Select(Type.GetType).ToArray(); var args = message.InvokeArguments.Select(x => this.m_ObjectWithTypeSerializer.Deserialize(x)).ToArray(); var allowed = false; if (this.m_LocalNode.Architecture == Architecture.PeerToPeer) { // In peer-to-peer, all methods are callable. allowed = true; } else if (this.m_LocalNode.Architecture == Architecture.ServerClient) { if (message.Sender == this.m_LocalNode.Self) { // This message is coming from the server. allowed = true; } else { var originalName = mi.Name.Substring(0, mi.Name.Length - "__Distributed0".Length); var originalMethod = obj.GetType().GetMethod(originalName, BindingFlagsCombined.All); // The client is calling this method, ensure they are allowed to call it. allowed = originalMethod.GetCustomAttributes(typeof(ClientCallableAttribute), false).Any(); } } if (!allowed) { // If the sender is not permitted to call this method, we just return (we // don't even bother giving them a response since they're either using an // out-of-date client or attempting to bypass security). throw new InvalidOperationException("Received a call to invoke " + message.InvokeMethod + " on " + obj.GetType()); } var result = DpmEntrypoint.InvokeDynamic( obj.GetType(), mi, obj, targs, args); var client = this.m_ClientLookup.Lookup(message.Sender.IPEndPoint); client.Send(this.m_MessageConstructor.ConstructInvokeResultMessage(message.ID, result)); }