ActorTaskScheduler QueueTask for LongRunning akkadotnet#1410

src/core/Akka.Tests/Dispatch/AsyncAwaitSpec.cs

@@ -243,8 +243,99 @@ protected override void PostRestart(Exception reason)
         }
     }
 
+    public class AsyncLongRunningActor : ReceiveActor
+    {
+        Task longRunning;
+        System.Threading.CancellationTokenSource cts;
+
+        public AsyncLongRunningActor()
+        {
+            Receive<string>(m =>
+            { 
+                if(m.Equals("start"))
+                {
+                    RunTask(() =>
+                    {
+                        cts = new System.Threading.CancellationTokenSource();
+                        //long running task as side effect
+                        longRunning = Task.Factory.StartNew(() =>
+                        {
+                            cts.Token.WaitHandle.WaitOne();
+                            return "done";
+                        }, TaskCreationOptions.LongRunning)
+                        .PipeTo(Sender);
+                    });
+                }
+                else if (m.Equals("stop"))
+                {
+                    cts.Cancel();
+                }
+            });
+        }
+    }
+
+    public class AsyncContextSupportForTaskActor : ReceiveActor
+    {
+        public AsyncContextSupportForTaskActor()
+        {
+            Receive<string>(m =>
+            {
+                if (m.Equals("start"))
+                {
+                    AsyncTask().PipeTo(Sender);
+                }
+                else if (m.Equals("run"))
+                {
+                    RunTask(() => AsyncTask().PipeTo(Sender));
+                }
+            });
+        }
+
+        private async Task<String> AsyncTask()
+        {
+            try
+            {
+                var sender1 = Context.Sender;
+                await Task.Delay(1);
+                var sender2 = Context.Sender;
+                if (sender1 != sender2)
+                    return "error";
+            }
+            catch (NotSupportedException)
+            {
+                return "notsupported";
+            }
+            catch(NullReferenceException)
+            {
+                return "notsupported";
+            }
+            return "done";
+        }
+    }
+
     public class ActorAsyncAwaitSpec : AkkaSpec
     {
+        [Fact]
+        public async Task Actors_should_not_be_able_to_use_context_in_async_task()
+        {
+            var actor = Sys.ActorOf(Props.Create<AsyncContextSupportForTaskActor>());
+            actor.Tell("start");
+            ExpectMsg("notsupported", TimeSpan.FromSeconds(5));
+
+            actor.Tell("run");
+            ExpectMsg("done", TimeSpan.FromSeconds(5));
+        }
+
+        [Fact]
+        public async Task Actors_should_be_able_to_start_longrunning_task()
+        {
+            var actor = Sys.ActorOf(Props.Create<AsyncLongRunningActor>());
+            var task = actor.Ask<string>("start", TimeSpan.FromSeconds(5));
+            actor.Tell("stop", ActorRefs.NoSender);
+            var res = await task;
+            Assert.Equal("done", res);
+        }
+
         [Fact]
         public async Task UntypedActors_should_be_able_to_async_await_ask_message_loop()
         {

src/core/Akka/Dispatch/ActorTaskScheduler.cs

@@ -54,6 +54,18 @@ protected override void QueueTask(Task task)
                 return;
             }
 
+            //detached task types
+            if(task.CreationOptions.HasFlag(TaskCreationOptions.LongRunning) 
+                //|| task.CreationOptions.HasFlag(TaskCreationOptions.AttachedToParent)
+                )
+            {
+                var worker = new Task(() => {
+                    TryExecuteTask(task);
+                });
+                worker.Start(TaskScheduler.Default);
+                return;
+            }
+
             //we get here if the task needs to be marshalled back to the mailbox
             //e.g. if previous task was an IO completion
             s = CallContext.LogicalGetData(StateKey) as AmbientState;
@@ -62,7 +74,7 @@ protected override void QueueTask(Task task)
             {
                 SetCurrentState(s.Self,s.Sender,s.Message);
                 TryExecuteTask(task);
-                if (task.IsFaulted)
+                if (task.IsFaulted || task.IsCanceled)
                     Rethrow(task, null);
 
             }), ActorRefs.NoSender);