# HG changeset patch
# User cin
# Date 2015-05-06 14:11:27
# Node ID eb793fbbe4ea5d051ef9b4fa446cb957826eda9c
# Parent  e6d4b41f0101bb778d4e6eabb0b0d3af6bd90337

fixed promises cancellation

diff --git a/Implab.Test/AsyncTests.cs b/Implab.Test/AsyncTests.cs
--- a/Implab.Test/AsyncTests.cs
+++ b/Implab.Test/AsyncTests.cs
@@ -746,33 +746,31 @@ namespace Implab.Test {
         public void ChainedCancel2Test() {
             // при отмене цепочки обещаний, вложенные операции также должны отменяться
             var pSurvive = new Promise<bool>();
-            var hemStarted = new ManualResetEvent(false);
+            var hemStarted = new Signal();
             var p = PromiseHelper
                 .Sleep(1, "Hi, HAL!")
-                .Chain(x => {
+                .Chain(() => {
                     hemStarted.Set();
                     // запускаем две асинхронные операции
                     var result = PromiseHelper
-                        .Sleep(100000000, "HEM ENABLED!!!")
-                        .Then(s => {
-                            pSurvive.Resolve(false);
-                            return s;
-                        });
+                        .Sleep(2000, "HEM ENABLED!!!")
+                        .Then(() => pSurvive.Resolve(false));
 
                     result
                         .On(() => pSurvive.Resolve(true), PromiseEventType.Cancelled);
-                    
+
                     return result;
                 });
 
-            hemStarted.WaitOne();
+            hemStarted.Wait();
             p.Cancel();
 
             try {
                 p.Join();
+                Assert.Fail();
             } catch (OperationCanceledException) {
-                Assert.IsTrue(pSurvive.Join());
             }
+            Assert.IsTrue(pSurvive.Join());
         }
 
         [TestMethod]
diff --git a/Implab.Test/CancelationTests.cs b/Implab.Test/CancelationTests.cs
--- a/Implab.Test/CancelationTests.cs
+++ b/Implab.Test/CancelationTests.cs
@@ -48,7 +48,7 @@ namespace Implab.Test {
             bool run = false;
             var task = new ActionTask(() => {
                 run = true;
-            }, null, null);
+            }, null, null, true);
 
             // request cancelation
             task.Cancel();
@@ -65,7 +65,7 @@ namespace Implab.Test {
             var task = new ActionTask(() => {
                 started.Set();
                 finish.Wait();
-            }, null, null);
+            }, null, null, true);
 
             AsyncPool.RunThread(() => {
                 task.Resolve();
@@ -85,14 +85,18 @@ namespace Implab.Test {
 
         [TestMethod]
         public void CancelTaskChainFromBottom() {
+            var started = new Signal();
             var check1 = new Signal();
             var requested = false;
             var p1 = AsyncPool.RunThread(token => {
                 token.CancellationRequested(reason => requested = true);
+                started.Set();
                 check1.Wait();
                 token.CancelOperationIfRequested();
             });
 
+            started.Wait();
+
             var p2 = p1.Then(() => {
             });
 
diff --git a/Implab.Test/PromiseHelper.cs b/Implab.Test/PromiseHelper.cs
--- a/Implab.Test/PromiseHelper.cs
+++ b/Implab.Test/PromiseHelper.cs
@@ -4,7 +4,8 @@ using System.Threading;
 namespace Implab.Test {
     static class PromiseHelper {
         public static IPromise<T> Sleep<T>(int timeout, T retVal) {
-            return AsyncPool.Invoke(() => {
+            return AsyncPool.Invoke((ct) => {
+                ct.CancellationRequested(ct.CancelOperation);
                 Thread.Sleep(timeout);
                 return retVal;
             });
diff --git a/Implab/ActionChainTask.cs b/Implab/ActionChainTask.cs
--- a/Implab/ActionChainTask.cs
+++ b/Implab/ActionChainTask.cs
@@ -4,14 +4,16 @@ namespace Implab {
     public class ActionChainTask : ActionChainTaskBase, IDeferred {
         readonly Func<IPromise> m_task;
 
-        public ActionChainTask(Func<IPromise> task, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel) : base(error,cancel) {
+        public ActionChainTask(Func<IPromise> task, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
             m_task = task;
         }
 
         public void Resolve() {
             if (m_task != null && LockCancelation()) {
                 try {
-                    Observe(m_task());
+                    var p = m_task();
+                    p.On(SetResult, HandleErrorInternal, SetCancelled);
+                    CancellationRequested(p.Cancel);
                 } catch(Exception err) {
                     HandleErrorInternal(err);
                 }
diff --git a/Implab/ActionChainTaskBase.cs b/Implab/ActionChainTaskBase.cs
--- a/Implab/ActionChainTaskBase.cs
+++ b/Implab/ActionChainTaskBase.cs
@@ -8,9 +8,11 @@ namespace Implab {
 
         int m_cancelationLock;
 
-        protected ActionChainTaskBase( Func<Exception, IPromise> error, Func<Exception, IPromise> cancel) {
+        protected ActionChainTaskBase(Func<Exception, IPromise> error, Func<Exception, IPromise> cancel, bool autoCancellable) {
             m_error = error;
             m_cancel = cancel;
+            if (autoCancellable)
+                CancellationRequested(CancelOperation);
         }
 
         public void Reject(Exception error) {
@@ -21,21 +23,26 @@ namespace Implab {
 
 
         public override void CancelOperation(Exception reason) {
-            if (m_cancel != null && LockCancelation()) {
-                try {
-                    Observe(m_cancel(reason));
-                } catch(Exception err) {
-                    HandleErrorInternal(err);
+            if (LockCancelation()) {
+                if (m_cancel != null) {
+                    try {
+                        m_cancel(reason).On(SetResult, SetError, SetCancelled);
+                    } catch (Exception err) {
+                        HandleErrorInternal(err);
+                    }
+                } else {
+                    SetCancelled(reason);
                 }
             }
-
         }
 
         protected void HandleErrorInternal(Exception error) {
             if (m_error != null) {
                 try {
-                    Observe(m_error(error));
-                } catch(Exception err) {
+                    var p = m_error(error);
+                    p.On(SetResult,SetError,SetCancelled);
+                    CancellationRequested(p.Cancel);
+                } catch (Exception err) {
                     SetError(err);
                 }
             } else {
@@ -43,17 +50,6 @@ namespace Implab {
             }
         }
 
-        protected void Observe(IPromise operation) {
-            if (operation == null)
-                throw new NullReferenceException("The task returned null promise");
-
-            // pass operation results to the current promise
-            operation.On(SetResult, SetError, SetCancelled);
-
-            // pass the cancelation request
-            CancellationRequested(operation.Cancel);
-        }
-
         protected bool LockCancelation() {
             return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
         }
diff --git a/Implab/ActionChainTaskT.cs b/Implab/ActionChainTaskT.cs
--- a/Implab/ActionChainTaskT.cs
+++ b/Implab/ActionChainTaskT.cs
@@ -4,14 +4,16 @@ namespace Implab {
     public class ActionChainTask<T> : ActionChainTaskBase, IDeferred<T> {
         readonly Func<T, IPromise> m_task;
 
-        public ActionChainTask(Func<T, IPromise> task, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel) : base(error,cancel) {
+        public ActionChainTask(Func<T, IPromise> task, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
             m_task = task;
         }
 
         public void Resolve(T value) {
             if (m_task != null && LockCancelation()) {
                 try {
-                    Observe(m_task(value));
+                    var p = m_task(value);
+                    p.On(SetResult, HandleErrorInternal, SetCancelled);
+                    CancellationRequested(p.Cancel);
                 } catch(Exception err) {
                     HandleErrorInternal(err);
                 }
diff --git a/Implab/ActionTask.cs b/Implab/ActionTask.cs
--- a/Implab/ActionTask.cs
+++ b/Implab/ActionTask.cs
@@ -3,7 +3,7 @@
 namespace Implab {
     public class ActionTask : ActionTaskBase, IDeferred {
         readonly Action m_task;
-        public ActionTask(Action task, Action<Exception> error, Action<Exception> cancel) : base(error,cancel) {
+        public ActionTask(Action task, Action<Exception> error, Action<Exception> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
             m_task = task;
         }
 
diff --git a/Implab/ActionTaskBase.cs b/Implab/ActionTaskBase.cs
--- a/Implab/ActionTaskBase.cs
+++ b/Implab/ActionTaskBase.cs
@@ -8,9 +8,11 @@ namespace Implab {
 
         int m_cancelationLock;
 
-        protected ActionTaskBase( Action<Exception> error, Action<Exception> cancel) {
+        protected ActionTaskBase( Action<Exception> error, Action<Exception> cancel, bool autoCancellable) {
             m_error = error;
             m_cancel = cancel;
+            if (autoCancellable)
+                CancellationRequested(CancelOperation);
         }
 
         public void Reject(Exception error) {
diff --git a/Implab/ActionTaskT.cs b/Implab/ActionTaskT.cs
--- a/Implab/ActionTaskT.cs
+++ b/Implab/ActionTaskT.cs
@@ -3,7 +3,7 @@
 namespace Implab {
     public class ActionTask<T> : ActionTaskBase, IDeferred<T> {
         readonly Action<T> m_task;
-        public ActionTask(Action<T> task, Action<Exception> error, Action<Exception> cancel) : base(error,cancel) {
+        public ActionTask(Action<T> task, Action<Exception> error, Action<Exception> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
             m_task = task;
         }
 
diff --git a/Implab/FuncChainTask.cs b/Implab/FuncChainTask.cs
--- a/Implab/FuncChainTask.cs
+++ b/Implab/FuncChainTask.cs
@@ -4,14 +4,17 @@ namespace Implab {
     public class FuncChainTask<TResult> : FuncChainTaskBase<TResult>, IDeferred {
         readonly Func<IPromise<TResult>> m_task;
 
-        public FuncChainTask(Func<IPromise<TResult>> task, Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel) : base(error, cancel){
+        public FuncChainTask(Func<IPromise<TResult>> task, Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel, bool autoCancellable)
+            : base(error, cancel, autoCancellable) {
             m_task = task;
         }
 
         public void Resolve() {
             if (m_task != null && LockCancelation()) {
                 try {
-                    Observe(m_task());
+                    var operation = m_task();
+                    operation.On(SetResult, HandleErrorInternal, SetCancelled);
+                    CancellationRequested(operation.Cancel);
                 } catch (Exception err) {
                     HandleErrorInternal(err);
                 }
diff --git a/Implab/FuncChainTaskBase.cs b/Implab/FuncChainTaskBase.cs
--- a/Implab/FuncChainTaskBase.cs
+++ b/Implab/FuncChainTaskBase.cs
@@ -8,9 +8,11 @@ namespace Implab {
 
         int m_cancelationLock;
 
-        protected FuncChainTaskBase( Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel) {
+        protected FuncChainTaskBase( Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel, bool autoCancellable) {
             m_error = error;
             m_cancel = cancel;
+            if (autoCancellable)
+                CancellationRequested(CancelOperation);
         }
 
         public void Reject(Exception error) {
@@ -19,11 +21,15 @@ namespace Implab {
         }
 
         public override void CancelOperation(Exception reason) {
-            if (m_cancel != null && LockCancelation()) {
-                try {
-                    Observe(m_cancel(reason));
-                } catch(Exception err) {
-                    HandleErrorInternal(err);
+            if (LockCancelation()) {
+                if (m_cancel != null) {
+                    try {
+                        m_cancel(reason).On(SetResult, HandleErrorInternal, SetCancelled);
+                    } catch (Exception err) {
+                        HandleErrorInternal(err);
+                    }
+                } else {
+                    SetCancelled(reason);
                 }
             }
 
@@ -32,7 +38,10 @@ namespace Implab {
         protected void HandleErrorInternal(Exception error) {
             if (m_error != null) {
                 try {
-                    Observe(m_error(error));
+                    var operation = m_error(error);
+
+                    operation.On(SetResult, SetError, SetCancelled);
+                    CancellationRequested(operation.Cancel);
                 } catch(Exception err) {
                     SetError(err);
                 }
@@ -41,17 +50,6 @@ namespace Implab {
             }
         }
 
-        protected void Observe(IPromise<TResult> operation) {
-            if (operation == null)
-                throw new NullReferenceException("The task returned null promise");
-
-            // pass operation results to the current promise
-            operation.On(SetResult, SetError, SetCancelled);
-
-            // pass the cancelation request
-            CancellationRequested(operation.Cancel);
-        }
-
         protected bool LockCancelation() {
             return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
         }
diff --git a/Implab/FuncChainTaskT.cs b/Implab/FuncChainTaskT.cs
--- a/Implab/FuncChainTaskT.cs
+++ b/Implab/FuncChainTaskT.cs
@@ -4,14 +4,16 @@ namespace Implab {
     public class FuncChainTask<TArg,TResult> : FuncChainTaskBase<TResult>, IDeferred<TArg> {
         readonly Func<TArg, IPromise<TResult>> m_task;
 
-        public FuncChainTask(Func<TArg, IPromise<TResult>> task, Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel) : base(error, cancel){
+        public FuncChainTask(Func<TArg, IPromise<TResult>> task, Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel, bool autoCancellable) : base(error, cancel, autoCancellable){
             m_task = task;
         }
 
         public void Resolve(TArg value) {
             if (m_task != null && LockCancelation()) {
                 try {
-                    Observe(m_task(value));
+                    var operation = m_task(value);
+                    operation.On(SetResult, HandleErrorInternal, SetCancelled);
+                    CancellationRequested(operation.Cancel);
                 } catch (Exception err) {
                     HandleErrorInternal(err);
                 }
diff --git a/Implab/FuncTask.cs b/Implab/FuncTask.cs
--- a/Implab/FuncTask.cs
+++ b/Implab/FuncTask.cs
@@ -5,7 +5,7 @@ namespace Implab {
     public class FuncTask<T> : FuncTaskBase<T>, IDeferred {
         readonly Func<T> m_task;
 
-        public FuncTask(Func<T> task, Func<Exception, T> error, Func<Exception, T> cancel) : base(error,cancel) {
+        public FuncTask(Func<T> task, Func<Exception, T> error, Func<Exception, T> cancel, bool autoCancellable) : base(error, cancel, autoCancellable) {
             m_task = task;
         }
 
diff --git a/Implab/FuncTaskBase.cs b/Implab/FuncTaskBase.cs
--- a/Implab/FuncTaskBase.cs
+++ b/Implab/FuncTaskBase.cs
@@ -8,9 +8,11 @@ namespace Implab {
 
         int m_cancelationLock;
 
-        protected FuncTaskBase( Func<Exception, TResult> error, Func<Exception, TResult> cancel) {
+        protected FuncTaskBase( Func<Exception, TResult> error, Func<Exception, TResult> cancel, bool autoCancellable) {
             m_error = error;
             m_cancel = cancel;
+            if (autoCancellable)
+                CancellationRequested(CancelOperation);
         }
 
         public void Reject(Exception error) {
diff --git a/Implab/FuncTaskT.cs b/Implab/FuncTaskT.cs
--- a/Implab/FuncTaskT.cs
+++ b/Implab/FuncTaskT.cs
@@ -4,7 +4,7 @@ namespace Implab {
     public class FuncTask<TArg, TResult> : FuncTaskBase<TResult>, IDeferred<TArg> {
         readonly Func<TArg, TResult> m_task;
 
-        public FuncTask(Func<TArg, TResult> task, Func<Exception, TResult> error,Func<Exception, TResult> cancel) :  base(error,cancel) {
+        public FuncTask(Func<TArg, TResult> task, Func<Exception, TResult> error,Func<Exception, TResult> cancel, bool autoCancellable) :  base(error,cancel, autoCancellable) {
             m_task = task;
         }
 
diff --git a/Implab/Parallels/WorkerPool.cs b/Implab/Parallels/WorkerPool.cs
--- a/Implab/Parallels/WorkerPool.cs
+++ b/Implab/Parallels/WorkerPool.cs
@@ -30,7 +30,49 @@ namespace Implab.Parallels {
             InitPool();
         }
 
-        public Promise<T> Invoke<T>(Func<T> task) {
+        public IPromise<T> Invoke<T>(Func<T> task) {
+            if (task == null)
+                throw new ArgumentNullException("task");
+            if (IsDisposed)
+                throw new ObjectDisposedException(ToString());
+
+            var promise = new FuncTask<T>(task, null, null, true);
+
+            var lop = TraceContext.Instance.CurrentOperation;
+
+            EnqueueTask(delegate {
+                TraceContext.Instance.EnterLogicalOperation(lop, false);
+
+                promise.Resolve();
+
+                TraceContext.Instance.Leave();
+            });
+
+            return promise;
+        }
+
+        public IPromise Invoke(Action task) {
+            if (task == null)
+                throw new ArgumentNullException("task");
+            if (IsDisposed)
+                throw new ObjectDisposedException(ToString());
+
+            var promise = new ActionTask(task, null, null, true);
+
+            var lop = TraceContext.Instance.CurrentOperation;
+
+            EnqueueTask(delegate {
+                TraceContext.Instance.EnterLogicalOperation(lop, false);
+
+                promise.Resolve();
+
+                TraceContext.Instance.Leave();
+            });
+
+            return promise;
+        }
+
+        public IPromise<T> Invoke<T>(Func<ICancellationToken, T> task) {
             if (task == null)
                 throw new ArgumentNullException("task");
             if (IsDisposed)
@@ -43,7 +85,35 @@ namespace Implab.Parallels {
             EnqueueTask(delegate {
                 TraceContext.Instance.EnterLogicalOperation(lop, false);
                 try {
-                    promise.Resolve(task());
+                    if (!promise.CancelOperationIfRequested())
+                        promise.Resolve(task(promise));
+                } catch (Exception e) {
+                    promise.Reject(e);
+                } finally {
+                    TraceContext.Instance.Leave();
+                }
+            });
+
+            return promise;
+        }
+
+        public IPromise Invoke<T>(Action<ICancellationToken> task) {
+            if (task == null)
+                throw new ArgumentNullException("task");
+            if (IsDisposed)
+                throw new ObjectDisposedException(ToString());
+
+            var promise = new Promise();
+
+            var lop = TraceContext.Instance.CurrentOperation;
+
+            EnqueueTask(delegate {
+                TraceContext.Instance.EnterLogicalOperation(lop, false);
+                try {
+                    if (!promise.CancelOperationIfRequested()) {
+                        task(promise);
+                        promise.Resolve();
+                    }
                 } catch (Exception e) {
                     promise.Reject(e);
                 } finally {
diff --git a/Implab/PromiseExtensions.cs b/Implab/PromiseExtensions.cs
--- a/Implab/PromiseExtensions.cs
+++ b/Implab/PromiseExtensions.cs
@@ -178,7 +178,7 @@ namespace Implab {
         public static IPromise Then(this IPromise that, Action success, Action<Exception> error, Action<Exception> cancel) {
             Safe.ArgumentNotNull(that, "that");
 
-            var d = new ActionTask(success, error, cancel);
+            var d = new ActionTask(success, error, cancel, false);
             that.On(d.Resolve, d.Reject, d.CancelOperation);
             if (success != null)
                 d.CancellationRequested(that.Cancel);
@@ -196,7 +196,7 @@ namespace Implab {
         public static IPromise<T> Then<T>(this IPromise that, Func<T> success, Func<Exception, T> error, Func<Exception, T> cancel) {
             Safe.ArgumentNotNull(that, "that");
 
-            var d = new FuncTask<T>(success, error, cancel);
+            var d = new FuncTask<T>(success, error, cancel, false);
             that.On(d.Resolve, d.Reject, d.CancelOperation);
             if (success != null)
                 d.CancellationRequested(that.Cancel);
@@ -213,7 +213,7 @@ namespace Implab {
 
         public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success, Func<Exception, T2> error, Func<Exception, T2> cancel) {
             Safe.ArgumentNotNull(that, "that");
-            var d = new FuncTask<T,T2>(success, error, cancel);
+            var d = new FuncTask<T,T2>(success, error, cancel, false);
             that.On(d.Resolve, d.Reject, d.CancelOperation);
             if (success != null)
                 d.CancellationRequested(that.Cancel);
@@ -232,7 +232,7 @@ namespace Implab {
         public static IPromise Chain(this IPromise that, Func<IPromise> success, Func<Exception,IPromise> error, Func<Exception,IPromise> cancel) {
             Safe.ArgumentNotNull(that, "that");
 
-            var d = new ActionChainTask(success, error, cancel);
+            var d = new ActionChainTask(success, error, cancel, false);
             that.On(d.Resolve, d.Reject, d.CancelOperation);
             if (success != null)
                 d.CancellationRequested(that.Cancel);
@@ -250,7 +250,7 @@ namespace Implab {
         public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success, Func<Exception, IPromise<T>> error, Func<Exception, IPromise<T>> cancel) {
             Safe.ArgumentNotNull(that, "that");
 
-            var d = new FuncChainTask<T>(success, error, cancel);
+            var d = new FuncChainTask<T>(success, error, cancel, false);
             that.On(d.Resolve, d.Reject, d.CancelOperation);
             if (success != null)
                 d.CancellationRequested(that.Cancel);
@@ -267,7 +267,7 @@ namespace Implab {
 
         public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success, Func<Exception, IPromise<T2>> error, Func<Exception, IPromise<T2>> cancel) {
             Safe.ArgumentNotNull(that, "that");
-            var d = new FuncChainTask<T,T2>(success, error, cancel);
+            var d = new FuncChainTask<T,T2>(success, error, cancel, false);
             that.On(d.Resolve, d.Reject, d.CancelOperation);
             if (success != null)
                 d.CancellationRequested(that.Cancel);