Merge pull request asynkron#257 from tomliversidge/253_cancel_receive_timeout

add CancelReceiveTimeout method on IContext and fix bug in SetReceive…

Author: cpx86

src/Proto.Actor/IContext.cs

@@ -92,11 +92,13 @@ public interface IContext : ISenderContext
         /// <summary>
         ///     Sets the receive timeout. If no message is received for the given duration, a ReceiveTimeout message will be sent
         ///     to the actor. If a message is received within the given duration, the timer is reset, unless the message implements
-        ///     INotInfluenceReceiveTimeout. Setting a duration of less than 1ms will disable the timer.
+        ///     INotInfluenceReceiveTimeout.
         /// </summary>
         /// <param name="duration">The receive timeout duration</param>
         void SetReceiveTimeout(TimeSpan duration);
 
+        void CancelReceiveTimeout();
+
         Task ReceiveAsync(object message);
         void Tell(PID target, object message);
         void Request(PID target, object message);

src/Proto.Actor/LocalContext.cs

@@ -144,32 +144,37 @@ public void Unwatch(PID pid)
 
         public void SetReceiveTimeout(TimeSpan duration)
         {
-            if (duration == ReceiveTimeout)
+            if (duration <= TimeSpan.Zero)
             {
-                return;
+                throw new ArgumentOutOfRangeException(nameof(duration), duration, "Duration must be greater than zero");
             }
-            if (duration > TimeSpan.Zero)
+            
+            if (duration == ReceiveTimeout)
             {
-                StopReceiveTimeout();
+                return;
             }
-            if (duration < TimeSpan.FromMilliseconds(1))
+            
+            StopReceiveTimeout();
+            ReceiveTimeout = duration;
+            
+            if (_receiveTimeoutTimer == null)
             {
-                duration = TimeSpan.FromMilliseconds(1);
+                _receiveTimeoutTimer = new Timer(ReceiveTimeoutCallback, null, ReceiveTimeout, ReceiveTimeout);
             }
-            ReceiveTimeout = duration;
-            if (ReceiveTimeout > TimeSpan.Zero)
+            else
             {
-                if (_receiveTimeoutTimer == null)
-                {
-                    _receiveTimeoutTimer = new Timer(ReceiveTimeoutCallback, null, ReceiveTimeout, ReceiveTimeout);
-                }
-                else
-                {
-                    ResetReceiveTimeout();
-                }
+                ResetReceiveTimeout();
             }
         }
 
+        public void CancelReceiveTimeout()
+        {
+            if (_receiveTimeoutTimer == null) return;
+            StopReceiveTimeout();
+            _receiveTimeoutTimer = null;
+            ReceiveTimeout = TimeSpan.Zero;
+        }
+
         public Task ReceiveAsync(object message)
         {
             return ProcessMessageAsync(message);
@@ -448,12 +453,7 @@ private async Task HandleStopAsync()
 
         private async Task TryRestartOrTerminateAsync()
         {
-            if (_receiveTimeoutTimer != null)
-            {
-                StopReceiveTimeout();
-                _receiveTimeoutTimer = null;
-                ReceiveTimeout = TimeSpan.Zero;
-            }
+            CancelReceiveTimeout();
 
             if (_children?.Count > 0)
             {

tests/Proto.Actor.Tests/ReceiveTimeoutTests.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Threading;
+using Xunit;
+
+namespace Proto.Tests
+{
+    public class ReceiveTimeoutTests
+    {
+        [Fact]
+        public void receive_timeout_received_within_expected_time()
+        {
+            var timeoutReceived = false;
+            var props = Actor.FromFunc((context) =>
+            {
+                switch (context.Message)
+                {
+                        case Started _:
+                            context.SetReceiveTimeout(TimeSpan.FromMilliseconds(150));
+                            break;
+                        case ReceiveTimeout _:
+                            timeoutReceived = true;
+                            break;
+                }
+                return Actor.Done;
+            });
+            Actor.Spawn(props);
+            
+            Thread.Sleep(500);
+            Assert.True(timeoutReceived);
+        }
+        
+        [Fact]
+        public void receive_timeout_not_received_within_expected_time()
+        {
+            var timeoutReceived = false;
+            var props = Actor.FromFunc((context) =>
+            {
+                switch (context.Message)
+                {
+                    case Started _:
+                        context.SetReceiveTimeout(TimeSpan.FromMilliseconds(1500));
+                        break;
+                    case ReceiveTimeout _:
+                        timeoutReceived = true;
+                        break;
+                }
+                return Actor.Done;
+            });
+            Actor.Spawn(props);
+            
+            Thread.Sleep(500);
+            Assert.False(timeoutReceived);
+        }
+        
+        [Fact]
+        public void can_cancel_receive_timeout()
+        {
+            var timeoutReceived = false;
+            var props = Actor.FromFunc((context) =>
+            {
+                switch (context.Message)
+                {
+                    case Started _:
+                        context.SetReceiveTimeout(TimeSpan.FromMilliseconds(150));
+                        context.CancelReceiveTimeout();
+                        break;
+                    case ReceiveTimeout _:
+                        timeoutReceived = true;
+                        break;
+                }
+                return Actor.Done;
+            });
+            Actor.Spawn(props);
+            
+            Thread.Sleep(500);
+            Assert.False(timeoutReceived);
+        }
+        
+        [Fact]
+        public void can_still_set_receive_timeout_after_cancelling()
+        {
+            var timeoutReceived = false;
+            var props = Actor.FromFunc((context) =>
+            {
+                switch (context.Message)
+                {
+                    case Started _:
+                        context.SetReceiveTimeout(TimeSpan.FromMilliseconds(150));
+                        context.CancelReceiveTimeout();
+                        context.SetReceiveTimeout(TimeSpan.FromMilliseconds(150));
+                        break;
+                    case ReceiveTimeout _:
+                        timeoutReceived = true;
+                        break;
+                }
+                return Actor.Done;
+            });
+            Actor.Spawn(props);
+            
+            Thread.Sleep(500);
+            Assert.True(timeoutReceived);
+        }
+    }
+}