public override void Deliver(Contact source, byte[] message) { using (MemoryStream mStream = new MemoryStream(message)) { switch ((PacketFlag)mStream.ReadByte()) { case PacketFlag.PutRequest: { lock (localData) { PutRequest r = Serializer.DeserializeWithLengthPrefix<PutRequest>(mStream, PrefixStyle.Base128); if (r.Data == null) { byte[] b; localData.TryRemove(r.Key, out b); } else localData[r.Key] = r.Data; break; } } case PacketFlag.GetRequest: { GetRequest r = Serializer.DeserializeWithLengthPrefix<GetRequest>(mStream, PrefixStyle.Base128); Callback.SendResponse(RoutingTable.LocalContact, source, r.TokenId, GetData(r.Key)); break; } default: break; } } }
public override void Deliver(Contact source, byte[] message) { byte flag = message[0]; Action<Contact, byte[]> processor = processors[flag]; if (processor != null) processor(source, message.Skip(1).ToArray()); }
/// <summary> /// Sends the response back to the remote end /// </summary> /// <param name="local">The local contact</param> /// <param name="target">The target.</param> /// <param name="callbackId">The callback id.</param> /// <param name="responseBytes">The response bytes.</param> public void SendResponse(Contact local, Contact target, long callbackId, byte[] responseBytes) { using (MemoryStream m = new MemoryStream()) { Serializer.SerializeWithLengthPrefix<Response>(m, new Response(callbackId, responseBytes), PrefixStyle.Base128); target.Send(local, ConsumerId, m.ToArray()); } }
protected void Send(Contact destination, Guid consumerId, byte flag, byte[] data, bool reliable = true, bool ordered = true, int channel = 1) { byte[] packet = new byte[data.Length + 1]; packet[0] = flag; Array.ConstrainedCopy(data, 0, packet, 1, data.Length); destination.Send(RoutingTable.LocalContact, consumerId, packet, reliable, ordered, channel); }
public ContactCollection(DistributedRoutingTable drt) { LocalContact = drt.LocalContact; NetworkId = drt.NetworkId; Configuration = drt.Configuration; this.DistributedRoutingTable = drt; for (int i = 0; i < buckets.Length; i++) buckets[i] = new ContactBucket(drt, i); }
public override TimeSpan Ping(Contact source, TimeSpan timeout) { if (!IsDead && random.NextDouble() >= PingFailChance) { Table.DeliverPing(source); return TimeSpan.FromMilliseconds(1); } else return TimeSpan.MaxValue; }
/// <summary> /// Deliver a message encoded into the given byte array /// </summary> /// <param name="source">The source of the message</param> /// <param name="message">The message.</param> public override void Deliver(Contact source, byte[] message) { using (MemoryStream m = new MemoryStream(message)) { Response r = Serializer.DeserializeWithLengthPrefix<Response>(m, PrefixStyle.Base128); WaitToken token; if (tokens.TryRemove(r.CallbackId, out token)) { token.Source = source; token.Response = r.ResponseBytes; } else if (r.CallbackId > nextId) { throw new Exception("Token not found"); } } }
/// <summary> /// Deliver a message encoded into the given byte array /// </summary> /// <param name="source">The source of the message</param> /// <param name="message">The message.</param> public override void Deliver(Contact source, byte[] message) { using (MemoryStream m = new MemoryStream(message)) { Response r = Serializer.Deserialize<Response>(m); WaitToken token; //if (tokens.TryGetValue(r.CallbackId, out token)) if (tokens.TryRemove(r.CallbackId, out token)) { token.Response = r.ResponseBytes; } else { throw new Exception("Token not found"); } } }
/// <summary> /// Moves the specified contact to the top of the most recently used queue /// </summary> /// <param name="source">The source.</param> internal void Update(Contact source) { #if DEBUG if (Configuration.UpdateRoutingTable) { #endif if (source == null) return; if (source.Identifier == LocalIdentifier) return; if (source.NetworkId != NetworkId) throw new ArgumentException("Network Id of contact and ContactCollection must be the same"); buckets[Identifier512.CommonPrefixLength(source.Identifier, LocalIdentifier)].Update(source); #if DEBUG } #endif }
public TimeSpan Ping(Contact source, TimeSpan timeout) { ProxyContact proxySource = (ProxyContact)source; MemoryStream m = new MemoryStream(); Serializer.SerializeWithLengthPrefix<Contact>(m, source, PrefixStyle.Base128); m.WriteByte(0); var waitToken = Game1.UdpFactory.SendPing(proxySource, this, true); Stopwatch timer = new Stopwatch(); timer.Start(); if (waitToken.Wait((int)timeout.TotalMilliseconds)) return timer.Elapsed; return TimeSpan.MaxValue; }
public void Send(Contact source, Guid consumerId, byte[] message, bool reliable, bool ordered, int channel) { MemoryStream m = new MemoryStream(); Serializer.SerializeWithLengthPrefix<Contact>(m, source, PrefixStyle.Base128); m.WriteByte(1); m.Write(consumerId.ToByteArray(), 0, 16); m.Write(BitConverter.GetBytes(message.Length), 0, 4); m.Write(message, 0, message.Length); try { Game1.UdpFactory.Send(m.ToArray(), EndPoint); } catch (SocketException e) { Console.WriteLine(e); } }
/// <summary> /// Deliver a message encoded into the given byte array /// </summary> /// <param name="message">The message.</param> /// <param name="source">The source of the message</param> /// <returns>The response to return</returns> public abstract void Deliver(Contact source, byte[] message);
public override TimeSpan Ping(Contact source, TimeSpan timeout) { return ProxyInstance.Ping(source, timeout); }
public override TimeSpan Ping(Contact source, TimeSpan timeout) { UdpContact uSource = source as UdpContact; using (MemoryStream m = new MemoryStream()) { using(BinaryWriter w =new BinaryWriter(m)) { w.Write((byte)PacketFlag.Ping); WriteContact(w, this); var callback = localTable.GetConsumer<Callback>(Callback.CONSUMER_ID); var token = callback.AllocateToken(); w.Write(IPAddress.HostToNetworkOrder(token.Id)); try { SendUdpMessage(m.ToArray(), Ip, Port); DateTime start = DateTime.Now; if (token.Wait(timeout.Milliseconds)) { return DateTime.Now - start; } return TimeSpan.MaxValue; } finally { callback.FreeToken(token); } } } }
public override void Send(Contact source, Guid consumerId, byte[] message, bool reliable = true, bool ordered = true, int channel = 1) { base.Send(source, consumerId, message, reliable, ordered, channel); using(MemoryStream m = new MemoryStream()) { using(BinaryWriter w = new BinaryWriter(m)) { w.Write((byte)PacketFlag.Data); WriteContact(w, this); byte[] guidBytes = consumerId.ToByteArray(); w.Write(IPAddress.HostToNetworkOrder(guidBytes.Length)); w.Write(guidBytes); w.Write(IPAddress.HostToNetworkOrder(message.Length)); w.Write(message); SendUdpMessage(m.ToArray(), Ip, Port); } } }
private bool ConnectToNodeAsParent(Contact node, int timeout) { bool isAlreadyChild = children.ContainsKey(node); bool isAlreadyParent; lock (parents) isAlreadyParent = parents.Contains(node); if (isAlreadyParent || isAlreadyChild) return false; Callback.WaitToken token = callback.AllocateToken(); try { using (MemoryStream m = new MemoryStream()) { Serializer.SerializeWithLengthPrefix<ParentageRequest>(m, new ParentageRequest() { CallbackId = token.Id, }, PrefixStyle.Base128); base.Send(node, ConsumerId, (byte)PacketFlag.ParentRequest, m.ToArray()); } if (!token.Wait(timeout)) return false; if (token.Response[0] == 0) return false; //add candidate to set of parents, as this request has been successful lock (parents) { parents.Add(node); } return true; } finally { callback.FreeToken(token); } }
/// <summary> /// Pings this instance. /// </summary> /// <returns>The response time, or Timespan.MaxValue if it timed out</returns> public abstract TimeSpan Ping(Contact source, TimeSpan timeout);
private void ParentRequestProcessor(Contact c, byte[] data) { using (MemoryStream m = new MemoryStream(data)) { var request = Serializer.DeserializeWithLengthPrefix<ParentageRequest>(m, PrefixStyle.Base128); if ((ChildrenCount < 2 || children.ContainsKey(c)) && (ParentCount > 0 || Root)) { callback.SendResponse(RoutingTable.LocalContact, c, request.CallbackId, new byte[] { 1 }); children[c] = DateTime.Now; } else { callback.SendResponse(RoutingTable.LocalContact, c, request.CallbackId, new byte[] { 0 }); } } }
private void VideoFrameDataProcessor(Contact c, byte[] data) { new LoggerMessages.GeneralMessage("Received a frame " + DateTime.Now.Second + " " + DateTime.Now.Millisecond).Send(); VideoFrame frame = Serializer.DeserializeWithLengthPrefix<VideoFrame>(new MemoryStream(data), PrefixStyle.Base128); VideoFrames.Enqueue(frame); ThreadPool.QueueUserWorkItem(_ => base.Send(c, ConsumerId, (byte)PacketFlag.Pong, new byte[] { 1 })); if (ChildrenCount > 0) { ThreadPool.QueueUserWorkItem(_ => SendVideoData(data)); new LoggerMessages.GeneralMessage("Sending a message to a child " + DateTime.Now.Second + " " + DateTime.Now.Millisecond).Send(); } }
public override void Send(Contact source, Guid consumerId, byte[] message, bool reliable = true, bool ordered = true, int channel = 1) { ProxyInstance.Send(source, consumerId, message, reliable, ordered, channel); }
public override TimeSpan Ping(Contact source, TimeSpan timeout) { table.DeliverPing(source); return TimeSpan.FromMilliseconds(1); }
/// <summary> /// Sends a message to the consumer with the given Id /// </summary> /// <param name="consumerId">The consumer id.</param> /// <param name="message">The message.</param> /// <returns>The response fromthe remote consumer, or null if there was no response</returns> public virtual void Send(Contact source, Guid consumerId, byte[] message, bool reliable = true, bool ordered = true, int channel = 1) { Interlocked.Add(ref sentBytes, message.Length); }
public void PingResponse(Contact source, Callback.WaitToken token) { callback.FreeToken(token); table.DeliverPing(source); }
private void PongRequestProcessor(Contact c, byte[] data) { DateTime d; if (children.TryGetValue(c, out d)) children.TryUpdate(c, DateTime.Now, d); }
/// <summary> /// Sends the response back to the remote end /// </summary> /// <param name="local">The local contact</param> /// <param name="target">The target.</param> /// <param name="callbackId">The callback id.</param> /// <param name="responseBytes">The response bytes.</param> public void SendResponse(Contact local, Contact target, long callbackId, byte[] responseBytes) { using (MemoryStream m = new MemoryStream()) { Serializer.Serialize<Response>(m, new Response(callbackId, responseBytes)); target.Send(local, ConsumerId, m.ToArray()); } }
/// <summary> /// Sends a message to the consumer with the given Id /// </summary> /// <param name="consumerId">The consumer id.</param> /// <param name="message">The message.</param> /// <returns>The response fromthe remote consumer, or null if there was no response</returns> public abstract void Send(Contact source, Guid consumerId, byte[] message, bool reliable = true, bool ordered = true, int channel = 1);
public override void Send(Contact source, Guid consumerId, byte[] message, bool reliable = true, bool ordered = true, int channel = 1) { table.Deliver(source, consumerId, message); }
public override void Send(Contact source, Guid consumerId, byte[] message, bool reliable = true, bool ordered = true, int channel = 1) { if (!IsDead && random.NextDouble() >= SendFailChance) Table.Deliver(source, consumerId, message); }