* Fix some issues that popped up in Hazel-Examples because of overzealous refactoring.

* Add more data into the early AcceptConnectionCheck to benefit IP-based connection rejection.
* Add a metric for message resends
* Tune message resends a little more

diff --git a/Hazel/Connection.cs b/Hazel/Connection.cs
index 50daf44c461e17635dc5988dd9b424d3231a7111..2e68f738fc5e30aea524b6476b4a6987b6c6ebb9 100644 (file)
--- a/Hazel/Connection.cs
+++ b/Hazel/Connection.cs
@@ -196,7 +196,7 @@ namespace Hazel
             Action<DataReceivedEventArgs> handler = DataReceived;
             if (handler != null)
             {
-                handler(new DataReceivedEventArgs(msg, sendOption));
+                handler(new DataReceivedEventArgs(this, msg, sendOption));
             }
             else
             {

diff --git a/Hazel/ConnectionStatistics.cs b/Hazel/ConnectionStatistics.cs
index 22a09c2c4cfaca096149b7684096e691e12b0900..c183062744dae0fad4c4f9bc893db3ca581fea91 100644 (file)
--- a/Hazel/ConnectionStatistics.cs
+++ b/Hazel/ConnectionStatistics.cs
@@ -386,6 +386,9 @@ namespace Hazel
         /// </summary>
         long totalBytesReceived;
 
+        public int MessagesResent { get { return messagesResent; } }
+        int messagesResent;
+
         /// <summary>
         ///     Logs the sending of an unreliable data packet in the statistics.
         /// </summary>
@@ -555,5 +558,10 @@ namespace Hazel
             Interlocked.Increment(ref helloMessagesReceived);
             Interlocked.Add(ref totalBytesReceived, totalLength);
         }
+
+        internal void LogMessageResent()
+        {
+            Interlocked.Increment(ref messagesResent);
+        }
     }
 }

diff --git a/Hazel/DataReceivedEventArgs.cs b/Hazel/DataReceivedEventArgs.cs
index a063852bc25fe94ebc897e453b76f2a23eac84bc..35609fcc04b95a751ac85e49cb4cff1157df1f88 100644 (file)
--- a/Hazel/DataReceivedEventArgs.cs
+++ b/Hazel/DataReceivedEventArgs.cs
@@ -7,6 +7,8 @@ namespace Hazel
 {
     public struct DataReceivedEventArgs
     {
+        public readonly Connection Sender;
+
         /// <summary>
         ///     The bytes received from the client.
         /// </summary>
@@ -17,8 +19,9 @@ namespace Hazel
         /// </summary>
         public readonly SendOption SendOption;
         
-        public DataReceivedEventArgs(MessageReader msg, SendOption sendOption)
+        public DataReceivedEventArgs(Connection sender, MessageReader msg, SendOption sendOption)
         {
+            this.Sender = sender;
             this.Message = msg;
             this.SendOption = sendOption;
         }

diff --git a/Hazel/ObjectPool.cs b/Hazel/ObjectPool.cs
index 725353eb2d854b1b1301f438bc060d99aaa18022..163301db6927556227c9b397780e453db5a4b2a2 100644 (file)
--- a/Hazel/ObjectPool.cs
+++ b/Hazel/ObjectPool.cs
@@ -16,6 +16,7 @@ namespace Hazel
 
         public int NumberInUse { get { return this.inuse.Count; } }
         public int NumberNotInUse { get { return this.pool.Count; } }
+        public int Size { get { return this.NumberInUse + this.NumberNotInUse; } }
 
         // Available objects
         private readonly ConcurrentBag<T> pool = new ConcurrentBag<T>();

diff --git a/Hazel/Properties/AssemblyInfo.cs b/Hazel/Properties/AssemblyInfo.cs
index bcdc4adabb4c6271da7017b2e2549d90f63015ef..0e0091581abaec087a2410440e7ee1bc501153f4 100644 (file)
--- a/Hazel/Properties/AssemblyInfo.cs
+++ b/Hazel/Properties/AssemblyInfo.cs
@@ -10,7 +10,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("Hazel")]
-[assembly: AssemblyCopyright("Copyright ©  2016")]
+[assembly: AssemblyCopyright("Copyright ©  2019")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 

diff --git a/Hazel/Udp/UdpClientConnection.cs b/Hazel/Udp/UdpClientConnection.cs
index c02cd31bc6b0f7d37eec3777bee6229a7ca5a702..503025da33502a27d7cef61e92d98ffad57dab2f 100644 (file)
--- a/Hazel/Udp/UdpClientConnection.cs
+++ b/Hazel/Udp/UdpClientConnection.cs
@@ -19,6 +19,11 @@ namespace Hazel.Udp
 
         private Timer reliablePacketTimer;
 
+#if DEBUG
+        public event Action<byte[], int> DataSentRaw;
+        public event Action<byte[], int> DataReceivedRaw;
+#endif
+
         /// <summary>
         ///     Creates a new UdpClientConnection.
         /// </summary>
@@ -62,22 +67,23 @@ namespace Hazel.Udp
         /// <inheritdoc />
         protected override void WriteBytesToConnection(byte[] bytes, int length)
         {
+#if DEBUG
             if (TestLagMs > 0)
             {
                 ThreadPool.QueueUserWorkItem(a => { Thread.Sleep(this.TestLagMs); WriteBytesToConnectionReal(bytes, length); });
             }
             else
+#endif
             {
                 WriteBytesToConnectionReal(bytes, length);
             }
         }
 
-        public event Action<byte[], int> DataSentRaw;
-        public event Action<byte[], int> DataReceivedRaw;
-
         private void WriteBytesToConnectionReal(byte[] bytes, int length)
         {
+#if DEBUG
             DataSentRaw?.Invoke(bytes, length);
+#endif
 
             try
             {
@@ -183,6 +189,13 @@ namespace Hazel.Udp
         /// </summary>
         void StartListeningForData()
         {
+#if DEBUG
+            if (this.TestLagMs > 0)
+            {
+                Thread.Sleep(this.TestLagMs);
+            }
+#endif
+
             var msg = MessageReader.GetSized(ushort.MaxValue);
             try
             {
@@ -241,11 +254,7 @@ namespace Hazel.Udp
                 return;
             }
 
-            if (this.TestLagMs > 0)
-            {
-                Thread.Sleep(this.TestLagMs);
-            }
-
+#if DEBUG
             if (this.TestDropRate > 0)
             {
                 if ((this.testDropCount++ % this.TestDropRate) == 0)
@@ -255,6 +264,7 @@ namespace Hazel.Udp
             }
 
             DataReceivedRaw?.Invoke(msg.Buffer, msg.Length);
+#endif
             HandleReceive(msg, msg.Length);
         }
 

diff --git a/Hazel/Udp/UdpConnection.Reliable.cs b/Hazel/Udp/UdpConnection.Reliable.cs
index a2a245087677a2978dc076b3bfe212048b76dd03..303d6705716bc205136f204505520a6f554054b0 100644 (file)
--- a/Hazel/Udp/UdpConnection.Reliable.cs
+++ b/Hazel/Udp/UdpConnection.Reliable.cs
@@ -171,10 +171,11 @@ namespace Hazel.Udp
                             return 0;
                         }
 
-                        this.NextTimeout += (int)Math.Min(this.NextTimeout * connection.ResendPingMultiplier, 500);
+                        this.NextTimeout += (int)Math.Min(this.NextTimeout * connection.ResendPingMultiplier, 1000);
                         try
                         {
                             connection.WriteBytesToConnection(this.Data, this.Length);
+                            connection.Statistics.LogMessageResent();
                             return 1;
                         }
                         catch (InvalidOperationException)
@@ -238,7 +239,7 @@ namespace Hazel.Udp
                 this,
                 buffer,
                 sendLength,
-                ResendTimeout > 0 ? ResendTimeout : ClampToInt(AveragePingMs * this.ResendPingMultiplier, 300, 1000),
+                ResendTimeout > 0 ? ResendTimeout : (int)Math.Min(AveragePingMs * this.ResendPingMultiplier, 300),
                 ackCallback);
 
             if (!reliableDataPacketsSent.TryAdd(id, packet))

diff --git a/Hazel/Udp/UdpConnectionListener.cs b/Hazel/Udp/UdpConnectionListener.cs
index 5b618854fd5a59847aaa456a1847f50b14f81190..3d67fda84d862276980e76d234bdae185b7a0d35 100644 (file)
--- a/Hazel/Udp/UdpConnectionListener.cs
+++ b/Hazel/Udp/UdpConnectionListener.cs
@@ -16,7 +16,7 @@ namespace Hazel.Udp
 
         public int MinConnectionLength = 0;
 
-        public delegate bool AcceptConnectionCheck(byte[] input, out byte[] response);
+        public delegate bool AcceptConnectionCheck(IPEndPoint endPoint, byte[] input, out byte[] response);
         public AcceptConnectionCheck AcceptConnection;
 
         /// <summary>
@@ -212,7 +212,7 @@ namespace Hazel.Udp
 
                         if (AcceptConnection != null)
                         {
-                            if (!AcceptConnection(message.Buffer, out var response))
+                            if (!AcceptConnection((IPEndPoint)remoteEndPoint, message.Buffer, out var response))
                             {
                                 message.Recycle();
                                 SendData(response, response.Length, remoteEndPoint);