implab/ImplabNet Commit - r185:822aab37b107

runnable component, work in progress

cin -

r185:822aab37b107 ref20160224

parent child

Context file:

r185:822aab37b107

Collapse all files

Implab.Test/RunnableComponentTests.cs created 644 +194 0

@@ -0,0 +1,194
	1	using System;
	2	using System.Reflection;
	3	using System.Threading;
	4	using Implab.Parallels;
	5	using Implab.Components;
	6
	7	#if MONO
	8
	9	using NUnit.Framework;
	10	using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
	11	using TestMethodAttribute = NUnit.Framework.TestAttribute;
	12
	13	#else
	14
	15	using Microsoft.VisualStudio.TestTools.UnitTesting;
	16
	17	#endif
	18
	19	namespace Implab.Test {
	20	[TestClass]
	21	public class RunnableComponentTests {
	22
	23	static void ShouldThrow(Action action) {
	24	try {
	25	action();
	26	Assert.Fail();
	27	} catch(AssertionException) {
	28	throw;
	29	} catch {
	30	}
	31	}
	32
	33	class Runnable : RunnableComponent {
	34	public Runnable(bool initialized) : base(initialized) {
	35	}
	36
	37	public Action MockInit {
	38	get;
	39	set;
	40	}
	41
	42	public Func<IPromise> MockStart {
	43	get;
	44	set;
	45	}
	46
	47	public Func<IPromise> MockStop {
	48	get;
	49	set;
	50	}
	51
	52	protected override IPromise OnStart() {
	53	return MockStart != null ? MockStart() : base.OnStart();
	54	}
	55
	56	protected override IPromise OnStop() {
	57	return MockStop != null ? MockStop() : base.OnStart();
	58	}
	59
	60	protected override void OnInitialize() {
	61	if (MockInit != null)
	62	MockInit();
	63	}
	64	}
	65
	66	[TestMethod]
	67	public void NormalFlowTest() {
	68	var comp = new Runnable(false);
	69
	70	Assert.AreEqual(ExecutionState.Created, comp.State);
	71
	72	comp.Init();
	73
	74	Assert.AreEqual(ExecutionState.Ready, comp.State);
	75
	76	comp.Start().Join(1000);
	77
	78	Assert.AreEqual(ExecutionState.Running, comp.State);
	79
	80	comp.Stop().Join(1000);
	81
	82	Assert.AreEqual(ExecutionState.Disposed, comp.State);
	83
	84	}
	85
	86	[TestMethod]
	87	public void InitFailTest() {
	88	var comp = new Runnable(false) {
	89	MockInit = () => {
	90	throw new Exception("BAD");
	91	}
	92	};
	93
	94	ShouldThrow(() => comp.Start());
	95	ShouldThrow(() => comp.Stop());
	96	Assert.AreEqual(ExecutionState.Created, comp.State);
	97
	98	ShouldThrow(comp.Init);
	99
	100	Assert.AreEqual(ExecutionState.Failed, comp.State);
	101
	102	ShouldThrow(() => comp.Start());
	103	ShouldThrow(() => comp.Stop());
	104	Assert.AreEqual(ExecutionState.Failed, comp.State);
	105
	106	comp.Dispose();
	107	Assert.AreEqual(ExecutionState.Disposed, comp.State);
	108	}
	109
	110	[TestMethod]
	111	public void DisposedTest() {
	112
	113	var comp = new Runnable(false);
	114	comp.Dispose();
	115
	116	ShouldThrow(() => comp.Start());
	117	ShouldThrow(() => comp.Stop());
	118	ShouldThrow(comp.Init);
	119
	120	Assert.AreEqual(ExecutionState.Disposed, comp.State);
	121	}
	122
	123	[TestMethod]
	124	public void StartCancelTest() {
	125	var comp = new Runnable(true) {
	126	MockStart = () => PromiseHelper.Sleep(100000, 0)
	127	};
	128
	129	var p = comp.Start();
	130	Assert.AreEqual(ExecutionState.Starting, comp.State);
	131	p.Cancel();
	132	ShouldThrow(() => p.Join(1000));
	133	Assert.AreEqual(ExecutionState.Failed, comp.State);
	134	Assert.IsInstanceOfType(typeof(OperationCanceledException), comp.LastError);
	135
	136	comp.Dispose();
	137	}
	138
	139	[TestMethod]
	140	public void StartStopTest() {
	141	var stop = new Signal();
	142	var comp = new Runnable(true) {
	143	MockStart = () => PromiseHelper.Sleep(100000, 0),
	144	MockStop = () => AsyncPool.RunThread(stop.Wait)
	145	};
	146
	147	var p1 = comp.Start();
	148	var p2 = comp.Stop();
	149	// should enter stopping state
	150
	151	ShouldThrow(p1.Join);
	152	Assert.IsTrue(p1.IsCancelled);
	153	Assert.AreEqual(ExecutionState.Stopping, comp.State);
	154
	155	stop.Set();
	156	p2.Join(1000);
	157	Assert.AreEqual(ExecutionState.Disposed, comp.State);
	158	}
	159
	160	[TestMethod]
	161	public void StartStopFailTest() {
	162	var comp = new Runnable(true) {
	163	MockStart = () => PromiseHelper.Sleep(100000, 0).Then(null,null,x => { throw new Exception("I'm dead"); })
	164	};
	165
	166	comp.Start();
	167	var p = comp.Stop();
	168	// if Start fails to cancel, should fail to stop
	169	ShouldThrow(() => p.Join(1000));
	170	Assert.AreEqual(ExecutionState.Failed, comp.State);
	171	Assert.IsNotNull(comp.LastError);
	172	Assert.AreEqual("I'm dead", comp.LastError.Message);
	173	}
	174
	175	[TestMethod]
	176	public void StopCancelTest() {
	177	var comp = new Runnable(true) {
	178	MockStop = () => PromiseHelper.Sleep(100000, 0)
	179	};
	180
	181	comp.Start();
	182	var p = comp.Stop();
	183	Assert.AreEqual(ExecutionState.Stopping, comp.State);
	184	p.Cancel();
	185	ShouldThrow(() => p.Join(1000));
	186	Assert.AreEqual(ExecutionState.Failed, comp.State);
	187	Assert.IsInstanceOfType(typeof(OperationCanceledException), comp.LastError);
	188
	189	comp.Dispose();
	190	}
	191
	192	}
	193	}
	194

Implab.Test/Implab.Test.mono.csproj +1 0

             <?xml version="1.0" encoding="utf-8"?>
             <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
               <PropertyGroup>
                 <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
                 <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
                 <ProductVersion>8.0.30703</ProductVersion>
                 <SchemaVersion>2.0</SchemaVersion>
                 <ProjectGuid>{2BD05F84-E067-4B87-9477-FDC2676A21C6}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <RootNamespace>Implab.Test</RootNamespace>
                 <AssemblyName>Implab.Test</AssemblyName>
                 <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
                 <ReleaseVersion>0.2</ReleaseVersion>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>DEBUG;MONO</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <DefineConstants>MONO</DefineConstants>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>DEBUG;TRACE;NET_4_5;MONO</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <DefineConstants>NET_4_5;MONO</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <ItemGroup>
                 <Reference Include="System" />
                 <Reference Include="nunit.framework" />
               </ItemGroup>
               <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
               <ItemGroup>
                 <Compile Include="AsyncTests.cs" />
                 <Compile Include="PromiseHelper.cs" />
                 <Compile Include="Properties\AssemblyInfo.cs" />
                 <Compile Include="CancelationTests.cs" />
+                <Compile Include="RunnableComponentTests.cs" />
               </ItemGroup>
               <ItemGroup>
                 <ProjectReference Include="..\Implab\Implab.csproj">
                   <Project>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</Project>
                   <Name>Implab</Name>
                 </ProjectReference>
               </ItemGroup>
             </Project>

Implab/AbstractEvent.cs +9 -8

             using System;
             using Implab.Parallels;
             using System.Threading;
             using System.Reflection;
             namespace Implab {
                 public abstract class AbstractEvent<THandler> : ICancellationToken, ICancellable {
                     const int UNRESOLVED_SATE = 0;
                     const int TRANSITIONAL_STATE = 1;
                     protected const int SUCCEEDED_STATE = 2;
                     protected const int REJECTED_STATE = 3;
                     protected const int CANCELLED_STATE = 4;
                     const int CANCEL_NOT_REQUESTED = 0;
                     const int CANCEL_REQUESTING = 1;
                     const int CANCEL_REQUESTED = 2;
                     const int RESERVED_HANDLERS_COUNT = 4;
                     int m_state;
                     Exception m_error;
                     int m_handlersCount;
                     //readonly THandler[] m_handlers = new THandler[RESERVED_HANDLERS_COUNT];
                     THandler[] m_handlers;
                     MTQueue<THandler> m_extraHandlers;
                     int m_handlerPointer = -1;
                     int m_handlersCommited;
                     int m_cancelRequest;
                     Exception m_cancelationReason;
                     MTQueue<Action<Exception>> m_cancelationHandlers;
                     #region state managment
                     bool BeginTransit() {
                         return UNRESOLVED_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, UNRESOLVED_SATE);
                     }
                     void CompleteTransit(int state) {
                         if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, state, TRANSITIONAL_STATE))
                             throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");
                     }
                     void WaitTransition() {
                         while (m_state == TRANSITIONAL_STATE) {
                             Thread.MemoryBarrier();
                         }
                     }
                     protected bool BeginSetResult() {
                         if (!BeginTransit()) {
                             WaitTransition();
                             if (m_state != CANCELLED_STATE)
                                 throw new InvalidOperationException("The promise is already resolved");
                             return false;
                         }
                         return true;
                     }
                     protected void EndSetResult() {
                         CompleteTransit(SUCCEEDED_STATE);
                         Signal();
                     }
                     /// <summary>
                     /// Выполняет обещание, сообщая об ошибке
                     /// </summary>
                     /// <remarks>
                     /// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков
                     /// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные
                     /// будут проигнорированы.
                     /// </remarks>
                     /// <param name="error">Исключение возникшее при выполнении операции</param>
                     /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
                     protected void SetError(Exception error) {
+                        while (error is PromiseTransientException)
+                            error = error.InnerException;
+                        var isCancel = error is OperationCanceledException;
                         if (BeginTransit()) {
-                            if (error is OperationCanceledException) {
+                            m_error = isCancel ? error.InnerException : error;
-                                m_error = error.InnerException;
+                            CompleteTransit(isCancel ? CANCELLED_STATE : REJECTED_STATE);
-                                CompleteTransit(CANCELLED_STATE);
-                            } else {
-                                m_error = error is PromiseTransientException ? error.InnerException : error;
-                                CompleteTransit(REJECTED_STATE);
                             Signal();
                         } else {
                             WaitTransition();
-                            if (m_state == SUCCEEDED_STATE)
+                            if (!isCancel || m_state == SUCCEEDED_STATE)
                                 throw new InvalidOperationException("The promise is already resolved");
                         }
                     }
                     /// <summary>
                     /// Отменяет операцию, если это возможно.
                     /// </summary>
                     /// <remarks>Для определения была ли операция отменена следует использовать свойство <see cref="IsCancelled"/>.</remarks>
                     protected void SetCancelled(Exception reason) {
                         if (BeginTransit()) {
                             m_error = reason;
                             CompleteTransit(CANCELLED_STATE);
                             Signal();
                         }
                     }
                     protected abstract void SignalHandler(THandler handler, int signal);
                     void Signal() {
                         var hp = m_handlerPointer;
                         var slot = hp +1 ;
                         while (slot < m_handlersCommited) {
                             if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) == hp) {
                                 SignalHandler(m_handlers[slot], m_state);
                             }
                             hp = m_handlerPointer;
                             slot = hp +1 ;
                         }
                         if (m_extraHandlers != null) {
                             THandler handler;
                             while (m_extraHandlers.TryDequeue(out handler))
                                 SignalHandler(handler, m_state);
                         }
                     }
                     #endregion
                     protected abstract Signal GetResolveSignal();
                     #region synchronization traits
                     protected void WaitResult(int timeout) {
                         if (!(IsResolved || GetResolveSignal().Wait(timeout)))
                             throw new TimeoutException();
                         switch (m_state) {
                             case SUCCEEDED_STATE:
                                 return;
                             case CANCELLED_STATE:
                                 throw new OperationCanceledException();
                             case REJECTED_STATE:
                                 throw new TargetInvocationException(m_error);
                             default:
                                 throw new ApplicationException(String.Format("Invalid promise state {0}", m_state));
                         }
                     }
                     #endregion
                     #region handlers managment
                     protected void AddHandler(THandler handler) {
                         if (m_state > 1) {
                             // the promise is in the resolved state, just invoke the handler
                             SignalHandler(handler, m_state);
                         } else {
                             var slot = Interlocked.Increment(ref m_handlersCount) - 1;
                             if (slot < RESERVED_HANDLERS_COUNT) {
                                 if (slot == 0) {
                                     m_handlers = new THandler[RESERVED_HANDLERS_COUNT];
                                 } else {
                                     while (m_handlers == null)
                                         Thread.MemoryBarrier();
                                 }
                                 m_handlers[slot] = handler;
                                 while (slot != Interlocked.CompareExchange(ref m_handlersCommited, slot + 1, slot)) {
                                 }
                                 if (m_state > 1) {
                                     do {
                                         var hp = m_handlerPointer;
                                         slot = hp + 1;
                                         if (slot < m_handlersCommited) {
                                             if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) != hp)
                                                 continue;
                                             SignalHandler(m_handlers[slot], m_state);
                                         }
                                         break;
                                     } while(true);
                                 }
                             } else {
                                 if (slot == RESERVED_HANDLERS_COUNT) {
                                     m_extraHandlers = new MTQueue<THandler>();
                                 } else {
                                     while (m_extraHandlers == null)
                                         Thread.MemoryBarrier();
                                 }
                                 m_extraHandlers.Enqueue(handler);
                                 if (m_state > 1 && m_extraHandlers.TryDequeue(out handler))
                                 // if the promise have been resolved while we was adding the handler to the queue
                                 // we can't guarantee that someone is still processing it
                                 // therefore we need to fetch a handler from the queue and execute it
                                 // note that fetched handler may be not the one that we have added
                                 // even we can fetch no handlers at all :)
                                     SignalHandler(handler, m_state);
                             }
                         }
                     }
                     #endregion
                     #region IPromise implementation
                     public bool IsResolved {
                         get {
                             Thread.MemoryBarrier();
                             return m_state > 1;
                         }
                     }
                     public bool IsCancelled {
                         get {
                             Thread.MemoryBarrier();
                             return m_state == CANCELLED_STATE;
                         }
                     }
                     #endregion
                     public Exception Error {
                         get {
                             return m_error;
                         }
                     }
                     public bool CancelOperationIfRequested() {
                         if (IsCancellationRequested) {
                             CancelOperation(CancellationReason);
                             return true;
                         }
                         return false;
                     }
                     public virtual void CancelOperation(Exception reason) {
                         SetCancelled(reason);
                     }
                     public void CancellationRequested(Action<Exception> handler) {
                         Safe.ArgumentNotNull(handler, "handler");
                         if (IsCancellationRequested)
                             handler(CancellationReason);
                         if (m_cancelationHandlers == null)
                             Interlocked.CompareExchange(ref m_cancelationHandlers, new MTQueue<Action<Exception>>(), null);
                         m_cancelationHandlers.Enqueue(handler);
                         if (IsCancellationRequested && m_cancelationHandlers.TryDequeue(out handler))
                             // TryDeque implies MemoryBarrier()
                             handler(m_cancelationReason);
                     }
                     public bool IsCancellationRequested {
                         get {
                             do {
                                 if (m_cancelRequest == CANCEL_NOT_REQUESTED)
                                     return false;
                                 if (m_cancelRequest == CANCEL_REQUESTED)
                                     return true;
                                 Thread.MemoryBarrier();
                             } while(true);
                         }
                     }
                     public Exception CancellationReason {
                         get {
                             do {
                                 Thread.MemoryBarrier();
                             } while(m_cancelRequest == CANCEL_REQUESTING);
                             return m_cancelationReason;
                         }
                     }
                     #region ICancellable implementation
                     public void Cancel() {
                         Cancel(null);
                     }
                     public void Cancel(Exception reason) {
                         if (CANCEL_NOT_REQUESTED == Interlocked.CompareExchange(ref m_cancelRequest, CANCEL_REQUESTING, CANCEL_NOT_REQUESTED)) {
                             m_cancelationReason = reason;
                             m_cancelRequest = CANCEL_REQUESTED;
                             if (m_cancelationHandlers != null) {
                                 Action<Exception> handler;
                                 while (m_cancelationHandlers.TryDequeue(out handler))
                                     handler(m_cancelationReason);
                             }
                         }
                     }
                     #endregion
                 }
             }

Implab/ActionChainTask.cs +9 0

             using System;
             namespace Implab {
                 public class ActionChainTask : ActionChainTaskBase, IDeferred {
                     readonly Func<IPromise> m_task;
+                    /// <summary>
+                    /// Initializes a new instance of the <see cref="Implab.ActionChainTask"/> class.
+                    /// </summary>
+                    /// <param name="task">The operation which will be performed when the <see cref="Resolve()"/> is called.</param>
+                    /// <param name="error">The error handler which will invoke when the <see cref="Reject(Exception)"/> is called or when the task fails with an error.</param>
+                    /// <param name="cancel">The cancellation handler.</param>
+                    /// <param name="autoCancellable">If set to <c>true</c> will automatically accept
+                    ///  all cancel requests before the task is started with <see cref="Resolve()"/>,
+                    /// after that all requests are directed to the task.</param>
                     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 {
                                 var p = m_task();
                                 p.On(SetResult, HandleErrorInternal, SetCancelled);
                                 CancellationRequested(p.Cancel);
                             } catch(Exception err) {
                                 HandleErrorInternal(err);
                             }
                         }
                     }
                 }
             }

Implab/Components/RunnableComponent.cs +134 -67

             using System;
-            using Implab.Formats;
             namespace Implab.Components {
-                public class RunnableComponent : Disposable, IRunnable, IInitializable {
+                public abstract class RunnableComponent : IDisposable, IRunnable, IInitializable {
                     enum Commands {
                         Ok = 0,
                         Fail,
                         Init,
                         Start,
                         Stop,
                         Dispose,
                         Last = Dispose
                     }
                     class StateMachine {
                         static readonly ExecutionState[,] _transitions;
                         static StateMachine() {
                             _transitions = new ExecutionState[(int)ExecutionState.Last + 1, (int)Commands.Last + 1];
-                            Edge(ExecutionState.Created, ExecutionState.Ready, Commands.Ok);
+                            Edge(ExecutionState.Created, ExecutionState.Initializing, Commands.Init);
-                            Edge(ExecutionState.Created, ExecutionState.Failed, Commands.Fail);
+                            Edge(ExecutionState.Created, ExecutionState.Disposed, Commands.Dispose);
+                            Edge(ExecutionState.Initializing, ExecutionState.Ready, Commands.Ok);
+                            Edge(ExecutionState.Initializing, ExecutionState.Failed, Commands.Fail);
                             Edge(ExecutionState.Ready, ExecutionState.Starting, Commands.Start);
                             Edge(ExecutionState.Ready, ExecutionState.Disposed, Commands.Dispose);
                             Edge(ExecutionState.Starting, ExecutionState.Running, Commands.Ok);
                             Edge(ExecutionState.Starting, ExecutionState.Failed, Commands.Fail);
                             Edge(ExecutionState.Starting, ExecutionState.Stopping, Commands.Stop);
                             Edge(ExecutionState.Starting, ExecutionState.Disposed, Commands.Dispose);
                             Edge(ExecutionState.Running, ExecutionState.Failed, Commands.Fail);
                             Edge(ExecutionState.Running, ExecutionState.Stopping, Commands.Stop);
                             Edge(ExecutionState.Running, ExecutionState.Disposed, Commands.Dispose);
                             Edge(ExecutionState.Stopping, ExecutionState.Failed, Commands.Fail);
                             Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Ok);
-                            Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Dispose);
+                            Edge(ExecutionState.Failed, ExecutionState.Disposed, Commands.Dispose);
                         }
                         static void Edge(ExecutionState s1, ExecutionState s2, Commands cmd) {
                             _transitions[(int)s1, (int)cmd] = s2;
                         }
                         public ExecutionState State {
                             get;
                             private set;
                         }
                         public StateMachine(ExecutionState initial) {
                             State = initial;
                         }
                         public bool Move(Commands cmd) {
                             var next = _transitions[(int)State, (int)cmd];
                             if (next == ExecutionState.Undefined)
                                 return false;
                             State = next;
                             return true;
                         }
                     }
                     IPromise m_pending;
                     Exception m_lastError;
                     readonly StateMachine m_stateMachine;
                     protected RunnableComponent(bool initialized) {
                         m_stateMachine = new StateMachine(initialized ? ExecutionState.Ready : ExecutionState.Created);
                     }
+                    protected virtual int DisposeTimeout {
+                        get {
+                            return 10000;
+                        }
+                    }
                     void ThrowInvalidCommand(Commands cmd) {
+                        if (m_stateMachine.State == ExecutionState.Disposed)
+                            throw new ObjectDisposedException(ToString());
                         throw new InvalidOperationException(String.Format("Commnd {0} is not allowed in the state {1}", cmd, m_stateMachine.State));
                     }
-                    protected void Move(Commands cmd) {
+                    void Move(Commands cmd) {
-                        lock (m_stateMachine)
+                        if (!m_stateMachine.Move(cmd))
-                            if (!m_stateMachine.Move(cmd))
+                            ThrowInvalidCommand(cmd);
-                                ThrowInvalidCommand(cmd);
                     }
-                    protected void Fail(Exception err) {
+                    void Invoke(Commands cmd, Action action) {
-                        lock (m_stateMachine) {
+                        lock (m_stateMachine)
-                            if (!m_stateMachine.Move(Commands.Fail))
+                            Move(cmd);
-                                ThrowInvalidCommand(Commands.Fail);
-                            m_lastError = err;
-                    protected void Success() {
-                        Move(Commands.Ok);
-                    protected void Invoke(Commands cmd, Action action) {
-                        Move(cmd);
                         try {
                             action();
-                            Move(Commands.Ok);
+                            lock(m_stateMachine)
+                                Move(Commands.Ok);
                         } catch (Exception err) {
-                            Fail(err);
+                            lock (m_stateMachine) {
+                                Move(Commands.Fail);
+                                m_lastError = err;
+                            }
                             throw;
                         }
                     }
-                    protected IPromise InvokeAsync(Commands cmd, Func<IPromise> action) {
+                    IPromise InvokeAsync(Commands cmd, Func<IPromise> action, Action<IPromise, IDeferred> chain) {
-                        Move(cmd);
+                        IPromise promise = null;
-                        var medium = new Promise();
+                        IPromise prev;
-                        IPromise promise = null;
+                        var task = new ActionChainTask(action, null, null, true);
+                        lock (m_stateMachine) {
+                            Move(cmd);
+                            prev = m_pending;
-                        promise = medium.Then(
+                            promise = task.Then(
-                            () => {
+                                () => {
-                                lock(m_stateMachine) {
+                                    lock(m_stateMachine) {
-                                    if (m_pending == promise) {
+                                        if (m_pending == promise) {
-                                        m_pending = null;
+                                            Move(Commands.Ok);
-                                        Move(Commands.Ok);
+                                            m_pending = null;
+                                        }
                                     }
+                                }, e => {
+                                    lock(m_stateMachine) {
+                                        if (m_pending == promise) {
+                                            Move(Commands.Fail);
+                                            m_pending = null;
+                                            m_lastError = e;
+                                        }
+                                    }
+                                    throw new PromiseTransientException(e);
+                                },
+                                r => {
+                                    lock(m_stateMachine) {
+                                        if (m_pending == promise) {
+                                            Move(Commands.Fail);
+                                            m_pending = null;
+                                            m_lastError = new OperationCanceledException("The operation has been cancelled", r);
+                                        }
+                                    }
+                                    throw new OperationCanceledException("The operation has been cancelled", r);
                                 }
-                            }, e => {
+                            );
-                                if (m_pending == promise) {
-                                    m_pending = null;
-                                    Fail(
-                        );
+                            m_pending = promise;
+                        }
+                        if (prev == null)
+                            task.Resolve();
+                        else
+                            chain(prev, task);
-                        return Safe.InvokePromise(action).Then(
+                        return promise;
-                            Success,
-                            Fail
-                        );
-                    void AddPending(IPromise result) {
                     }
                     #region IInitializable implementation
                     public void Init() {
                         Invoke(Commands.Init, OnInitialize);
                     }
                     protected virtual void OnInitialize() {
                     }
                     #endregion
                     #region IRunnable implementation
                     public IPromise Start() {
-                        Move(Commands.Start);
+                        return InvokeAsync(Commands.Start, OnStart, null);
-                        return Safe.InvokePromise(OnStart).Then(
-                            () => {
-                                Move(Commands.Ok);
-                                Run();
-                            },
-                            () => {
-                                Move(Commands.Fail);
-                        );
                     }
                     protected virtual IPromise OnStart() {
                         return Promise.SUCCESS;
                     }
-                    protected virtual void Run() {
+                    public IPromise Stop() {
+                        return InvokeAsync(Commands.Stop, OnStop, StopPending).Then(Dispose);
+                    }
+                    protected virtual IPromise OnStop() {
+                        return Promise.SUCCESS;
                     }
-                    public IPromise Stop() {
+                    /// <summary>
-                        throw new NotImplementedException();
+                    /// Stops the current operation if one exists.
+                    /// </summary>
+                    /// <param name="current">Current.</param>
+                    /// <param name="stop">Stop.</param>
+                    protected virtual void StopPending(IPromise current, IDeferred stop) {
+                        if (current == null) {
+                            stop.Resolve();
+                        } else {
+                            current.On(stop.Resolve, stop.Reject, stop.CancelOperation);
+                            current.Cancel();
+                        }
                     }
                     public ExecutionState State {
                         get {
-                            throw new NotImplementedException();
+                            return m_stateMachine.State;
                         }
                     }
                     public Exception LastError {
                         get {
-                            throw new NotImplementedException();
+                            return m_lastError;
                         }
                     }
                     #endregion
+                    #region IDisposable implementation
+                    public void Dispose() {
+                        IPromise pending;
+                        lock (m_stateMachine) {
+                            if (m_stateMachine.State == ExecutionState.Disposed)
+                                return;
+                            Move(Commands.Dispose);
+                            GC.SuppressFinalize(this);
+                            pending = m_pending;
+                            m_pending = null;
+                        }
+                        if (pending != null) {
+                            pending.Cancel();
+                            pending.Timeout(DisposeTimeout).On(
+                                () => Dispose(true, null),
+                                err => Dispose(true, err),
+                                reason => Dispose(true, new OperationCanceledException("The operation is cancelled", reason))
+                            );
+                        } else {
+                            Dispose(true, m_lastError);
+                        }
+                    }
+                    ~RunnableComponent() {
+                        Dispose(false, null);
+                    }
+                    #endregion
+                    protected virtual void Dispose(bool disposing, Exception lastError) {
+                    }
                 }
             }

Implab/PromiseExtensions.cs +11 -21

             using System.Threading;
             using System;
             using Implab.Diagnostics;
             using System.Collections.Generic;
-            #if NET_4_5
-            using System.Threading.Tasks;
-            #endif
             namespace Implab {
                 public static class PromiseExtensions {
                     public static IPromise<T> DispatchToCurrentContext<T>(this IPromise<T> that) {
                         Safe.ArgumentNotNull(that, "that");
                         var context = SynchronizationContext.Current;
                         if (context == null)
                             return that;
                         var p = new SyncContextPromise<T>(context);
-                        p.On(that.Cancel, PromiseEventType.Cancelled);
+                        p.CancellationRequested(that.Cancel);
                         that.On(
                             p.Resolve,
                             p.Reject,
-                            p.Cancel
+                            p.CancelOperation
                         );
                         return p;
                     }
                     public static IPromise<T> DispatchToContext<T>(this IPromise<T> that, SynchronizationContext context) {
                         Safe.ArgumentNotNull(that, "that");
                         Safe.ArgumentNotNull(context, "context");
                         var p = new SyncContextPromise<T>(context);
-                        p.On(that.Cancel, PromiseEventType.Cancelled);
+                        p.CancellationRequested(that.Cancel);
                         that.On(
                             p.Resolve,
                             p.Reject,
-                            p.Cancel
+                            p.CancelOperation
                         );
                         return p;
                     }
                     /// <summary>
                     /// Ensures the dispatched.
                     /// </summary>
                     /// <returns>The dispatched.</returns>
                     /// <param name="that">That.</param>
                     /// <param name="head">Head.</param>
                     /// <param name="cleanup">Cleanup.</param>
                     /// <typeparam name="TPromise">The 1st type parameter.</typeparam>
                     /// <typeparam name="T">The 2nd type parameter.</typeparam>
                     public static TPromise EnsureDispatched<TPromise,T>(this TPromise that, IPromise<T> head, Action<T> cleanup) where TPromise : IPromise{
                         Safe.ArgumentNotNull(that, "that");
                         Safe.ArgumentNotNull(head, "head");
                         that.On(() => head.On(cleanup), PromiseEventType.Cancelled);
                         return that;
                     }
                     public static AsyncCallback AsyncCallback<T>(this Promise<T> that, Func<IAsyncResult,T> callback) {
                         Safe.ArgumentNotNull(that, "that");
                         Safe.ArgumentNotNull(callback, "callback");
                         var op = TraceContext.Instance.CurrentOperation;
                         return ar => {
                             TraceContext.Instance.EnterLogicalOperation(op,false);
                             try {
                                 that.Resolve(callback(ar));
                             } catch (Exception err) {
                                 that.Reject(err);
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
                         };
                     }
-                    static void CancelCallback(object cookie) {
+                    static void CancelByTimeoutCallback(object cookie) {
-                        ((ICancellable)cookie).Cancel();
+                        ((ICancellable)cookie).Cancel(new TimeoutException());
                     }
                     /// <summary>
                     /// Cancells promise after the specified timeout is elapsed.
                     /// </summary>
                     /// <param name="that">The promise to cancel on timeout.</param>
                     /// <param name="milliseconds">The timeout in milliseconds.</param>
                     /// <typeparam name="TPromise">The 1st type parameter.</typeparam>
                     public static TPromise Timeout<TPromise>(this TPromise that, int milliseconds) where TPromise : IPromise {
                         Safe.ArgumentNotNull(that, "that");
-                        var timer = new Timer(CancelCallback, that, milliseconds, -1);
+                        var timer = new Timer(CancelByTimeoutCallback, that, milliseconds, -1);
                         that.On(timer.Dispose, PromiseEventType.All);
                         return that;
                     }
                     public static IPromise Bundle(this ICollection<IPromise> that) {
                         Safe.ArgumentNotNull(that, "that");
                         int count = that.Count;
                         int errors = 0;
                         var medium = new Promise();
                         if (count == 0) {
                             medium.Resolve();
                             return medium;
                         }
                         medium.On(() => {
                             foreach(var p2 in that)
                                 p2.Cancel();
                         }, PromiseEventType.ErrorOrCancel);
                         foreach (var p in that)
                             p.On(
                                 () => {
                                     if (Interlocked.Decrement(ref count) == 0)
                                         medium.Resolve();
                                 },
                                 error => {
                                     if (Interlocked.Increment(ref errors) == 1)
                                         medium.Reject(
                                             new Exception("The dependency promise is failed", error)
                                         );
                                 },
                                 reason => {
                                     if (Interlocked.Increment(ref errors) == 1)
                                         medium.Cancel(
                                             new Exception("The dependency promise is cancelled")
                                         );
                                 }
                             );
                         return medium;
                     }
                     public static IPromise<T[]> Bundle<T>(this ICollection<IPromise<T>> that) {
                         Safe.ArgumentNotNull(that, "that");
                         int count = that.Count;
                         int errors = 0;
                         var medium = new Promise<T[]>();
                         var results = new T[that.Count];
                         medium.On(() => {
                             foreach(var p2 in that)
                                 p2.Cancel();
                         }, PromiseEventType.ErrorOrCancel);
                         int i = 0;
                         foreach (var p in that) {
                             var idx = i;
                             p.On(
                                 x => {
                                     results[idx] = x;
                                     if (Interlocked.Decrement(ref count) == 0)
                                         medium.Resolve(results);
                                 },
                                 error => {
                                     if (Interlocked.Increment(ref errors) == 1)
                                         medium.Reject(
                                             new Exception("The dependency promise is failed", error)
                                         );
                                 },
                                 reason => {
                                     if (Interlocked.Increment(ref errors) == 1)
                                         medium.Cancel(
                                             new Exception("The dependency promise is cancelled", reason)
                                         );
                                 }
                             );
                             i++;
                         }
                         return medium;
                     }
                     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, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
-                        if (success != null)
+                        d.CancellationRequested(that.Cancel);
-                            d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise Then(this IPromise that, Action success, Action<Exception> error) {
                         return Then(that, success, error, null);
                     }
                     public static IPromise Then(this IPromise that, Action success) {
                         return Then(that, success, null, null);
                     }
                     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, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
-                        if (success != null)
+                        d.CancellationRequested(that.Cancel);
-                            d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T> Then<T>(this IPromise that, Func<T> success, Func<Exception, T> error) {
                         return Then(that, success, error, null);
                     }
                     public static IPromise<T> Then<T>(this IPromise that, Func<T> success) {
                         return Then(that, success, null, null);
                     }
                     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, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
-                        if (success != null)
+                        d.CancellationRequested(that.Cancel);
-                            d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success, Func<Exception, T2> error) {
                         return Then(that, success, error, null);
                     }
                     public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success) {
                         return Then(that, success, null, null);
                     }
                     #region chain traits
                     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, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
-                        if (success != null)
+                        d.CancellationRequested(that.Cancel);
-                            d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise Chain(this IPromise that, Func<IPromise> success, Func<Exception,IPromise> error) {
                         return Chain(that, success, error, null);
                     }
                     public static IPromise Chain(this IPromise that, Func<IPromise> success) {
                         return Chain(that, success, null, null);
                     }
                     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, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         if (success != null)
                             d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success, Func<Exception, IPromise<T>> error) {
                         return Chain(that, success, error, null);
                     }
                     public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success) {
                         return Chain(that, success, null, null);
                     }
                     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, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         if (success != null)
                             d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success, Func<Exception, IPromise<T2>> error) {
                         return Chain(that, success, error, null);
                     }
                     public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success) {
                         return Chain(that, success, null, null);
                     }
                     #endregion
                     #if NET_4_5
                     public static PromiseAwaiter<T> GetAwaiter<T>(this IPromise<T> that) {
                         Safe.ArgumentNotNull(that, "that");
                         return new PromiseAwaiter<T>(that);
                     }
                     #endif
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages