Clean up stop flow (#24)

* Update Travis build.

* Clean up stop flow

This is partly in reaction to a problem with the actor not showing as
stopped if the start work failed.

* Try to fix Travis

Author: Jos Hickson

.travis.yml

@@ -10,9 +10,17 @@ branches:
   except:
   - /^[0-9]/
 
-dotnet: 1.1.6
-
+dotnet: 2.1.4
 mono: none
+
+addons:
+  apt:
+    sources:
+    - sourceline: 'deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-trusty-prod trusty main'
+      key_url: 'https://packages.microsoft.com/keys/microsoft.asc'
+    packages:
+    - dotnet-hostfxr-1.0.1
+    - dotnet-sharedframework-microsoft.netcore.app-1.0.9
 
 script:
   - (git fetch --unshallow 2>/dev/null || echo "Already full repo.")

Winton.Extensions.Threading.Actor.Tests.Unit/ActorTests.cs

@@ -992,6 +992,27 @@ public async Task ShouldBeAbleToPauseActorUntilResumeFromAwaitReturningData(Acto
             }
         }
 
+        [Fact]
+        public async Task ShutdownShouldReturnImmediatelyIfStartWorkFails()
+        {
+            var stopWorkCalled = false;
+            var actor =
+                new Actor
+                {
+                    StartWork = new ActorStartWork(() => throw new Exception("Error.")),
+                    StopWork = new ActorStopWork(() => stopWorkCalled = true)
+                };
+
+            actor.Awaiting(async x => await x.Start()).ShouldThrow<Exception>().WithMessage("Error.");
+
+            var stopperThreadId = Thread.CurrentThread.ManagedThreadId;
+
+            await actor.Stop();
+
+            Thread.CurrentThread.ManagedThreadId.Should().Be(stopperThreadId);
+            stopWorkCalled.Should().BeFalse();
+        }
+
         [Flags]
         private enum ActorCreateOptions
         {

Winton.Extensions.Threading.Actor.Tests.Unit/Winton.Extensions.Threading.Actor.Tests.Unit.csproj

@@ -10,10 +10,10 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions" Version="4.19.4" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
-    <PackageReference Include="Moq" Version="4.7.137" />
-    <PackageReference Include="xunit" Version="2.2.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
+    <PackageReference Include="Moq" Version="4.8.1" />
+    <PackageReference Include="xunit" Version="2.3.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
   </ItemGroup>
 
   <ItemGroup>

Winton.Extensions.Threading.Actor/Internal/StateMachine/ActiveActorState.cs

@@ -1,5 +1,3 @@
-using System;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Winton.Extensions.Threading.Actor.Internal.StateMachine
@@ -22,44 +20,7 @@ protected override void ScheduleImpl(Task task)
 
         protected override void StopImpl()
         {
-            var finalWork =
-                (Action)(() =>
-                         {
-                             try
-                             {
-                                 Context.StopWork.CancellationToken.ThrowIfCancellationRequested();
-                                 Context.StopWork.SyncWork();
-                             }
-                             finally
-                             {
-                                 Context.TerminateTaskScheduler();
-                             }
-                         });
-
-            var finalTask = Context.ActorTaskFactory.Create(finalWork, CancellationToken.None, Context.StopWork.TaskCreationOptions);
-
-            Task.Run(async () =>
-                     {
-                         try
-                         {
-                             await finalTask;
-                             Context.StopCompletionSource.SetResult(true);
-                         }
-                         catch (Exception exception)
-                         {
-                             if (exception is TaskCanceledException)
-                             {
-                                 Context.StopCompletionSource.SetCanceled();
-                             }
-                             else
-                             {
-                                 Context.StopCompletionSource.SetException(exception);
-                             }
-                         }
-                     });
-
-            Context.StartTask(finalTask);
-            Context.SetState<StoppedActorState>();
+            Context.SetState<StoppingActorState>();
         }
 
         protected override void EnterImpl()

Winton.Extensions.Threading.Actor/Internal/StateMachine/ActorState.cs

@@ -16,7 +16,7 @@ public Task Start()
             {
                 StartImpl();
             }
-            catch (Exception exception)
+            catch (Exception exception) when (!Context.StartCompletionSource.Task.IsCompleted)
             {
                 Context.StartCompletionSource.SetException(exception);
             }
@@ -30,7 +30,7 @@ public Task Stop()
             {
                 StopImpl();
             }
-            catch (Exception exception)
+            catch (Exception exception) when (!Context.StopCompletionSource.Task.IsCompleted)
             {
                 Context.StopCompletionSource.SetException(exception);
             }

Winton.Extensions.Threading.Actor/Internal/StateMachine/InitialActorState.cs

@@ -25,9 +25,7 @@ protected override void StartImpl()
 
         protected override void StopImpl()
         {
-            Context.StartCompletionSource.SetResult(true);
-            Context.StopCompletionSource.SetResult(true);
-            Context.SetState<StoppedActorState>();
+            Context.SetState<StoppingActorState>();
         }
 
         protected override void ScheduleImpl(Task task)

Winton.Extensions.Threading.Actor/Internal/StateMachine/StartingActorState.cs

@@ -54,7 +54,7 @@ protected override void EnterImpl()
                                  Context.StartCompletionSource.SetException(exception);
                              }
 
-                             Context.SetState<StoppedActorState>();
+                             Context.SetState<StoppingActorState>();
                          }
                      });
         }

Winton.Extensions.Threading.Actor/Internal/StateMachine/StoppedActorState.cs

@@ -1,4 +1,3 @@
-using System.Linq;
 using System.Threading.Tasks;
 
 namespace Winton.Extensions.Threading.Actor.Internal.StateMachine
@@ -25,13 +24,6 @@ protected override void StopImpl()
 
         protected override void EnterImpl()
         {
-            foreach (var task in Context.InitialWorkQueue.Concat(Context.InitialWorkToBeCancelledQueue))
-            {
-                task.Cancel();
-            }
-
-            Context.InitialWorkQueue.Clear();
-            Context.InitialWorkToBeCancelledQueue.Clear();
         }
     }
 }

Winton.Extensions.Threading.Actor/Internal/StateMachine/StoppingActorState.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Winton.Extensions.Threading.Actor.Internal.StateMachine
+{
+    internal sealed class StoppingActorState : ActorState
+    {
+        public StoppingActorState(ActorContext context)
+            : base(context)
+        {
+        }
+
+        protected override void StartImpl()
+        {
+        }
+
+        protected override void ScheduleImpl(Task task)
+        {
+            task.Cancel();
+        }
+
+        protected override void StopImpl()
+        {
+        }
+
+        protected override void EnterImpl()
+        {
+            var runStopWork = Context.StartCompletionSource.Task.Status == TaskStatus.RanToCompletion;
+
+            Context.StartCompletionSource.TrySetResult(true);
+
+            var finalWork =
+                (Action)(() =>
+                         {
+                             try
+                             {
+                                 Context.StopWork.CancellationToken.ThrowIfCancellationRequested();
+
+                                 if (runStopWork)
+                                 {
+                                     Context.StopWork.SyncWork();
+                                 }
+
+                                 Context.StopCompletionSource.SetResult(true);
+                             }
+                             catch (OperationCanceledException)
+                             {
+                                 Context.StopCompletionSource.SetCanceled();
+                             }
+                             catch (Exception exception)
+                             {
+                                 Context.StopCompletionSource.SetException(exception);
+                             }
+                             finally
+                             {
+                                 Context.TerminateTaskScheduler();
+                                 Context.SetState<StoppedActorState>();
+                             }
+                         });
+
+            Context.StartTask(Context.ActorTaskFactory.Create(finalWork, CancellationToken.None, Context.StopWork.TaskCreationOptions));
+
+            foreach (var task in Context.InitialWorkQueue.Concat(Context.InitialWorkToBeCancelledQueue))
+            {
+                task.Cancel();
+            }
+
+            Context.InitialWorkQueue.Clear();
+            Context.InitialWorkToBeCancelledQueue.Clear();
+        }
+    }
+}