implab/ImplabNet Commit - r203:4d9830a9bbb8

Added 'Fail' method to RunnableComponent which allows component to move from...

cin -

r203:4d9830a9bbb8 v2

parent child

Context file:

r203:4d9830a9bbb8

Collapse all files

Implab.Test/Mock/MockPollingComponent.cs created 644 +71 0

@@ -0,0 +1,71
	1	using System;
	2	using Implab.Components;
	3
	4	namespace Implab.Test.Mock {
	5	class MockPollingComponent : PollingComponent {
	6	public MockPollingComponent(TimeSpan interval, Func<Func<ICancellationToken, IPromise>, IPromise> dispatcher, bool initialized) : base(interval, dispatcher, initialized) {
	7	}
	8
	9	public Action MockInit {
	10	get;
	11	set;
	12	}
	13
	14	public Action<Exception> MockOnError {
	15	get;
	16	set;
	17	}
	18
	19	public Action<Exception> MockOnCancel {
	20	get;
	21	set;
	22	}
	23
	24	public Func<IPromise> MockStart {
	25	get;
	26	set;
	27	}
	28
	29	public Func<IPromise> MockStop {
	30	get;
	31	set;
	32	}
	33
	34	public Func<ICancellationToken, IPromise> MockTick {
	35	get;
	36	set;
	37	}
	38
	39	protected override IPromise OnStart() {
	40	return MockStart != null ? Safe.Run(MockStart).Chain(base.OnStart) : Safe.Run(base.OnStart);
	41	}
	42
	43	protected override IPromise OnStop() {
	44	return MockStop != null ? Safe.Run(MockStop).Chain(base.OnStop) : Safe.Run(base.OnStop);
	45	}
	46
	47	protected override void OnInitialize() {
	48	if (MockInit != null)
	49	MockInit();
	50	}
	51
	52	protected override IPromise OnTick(ICancellationToken cancellationToken) {
	53	return MockTick != null ? Safe.Run(() => MockTick(cancellationToken)) : Promise.SUCCESS;
	54	}
	55
	56	protected override void OnTickCancel(Exception error) {
	57	if (MockOnCancel != null)
	58	MockOnCancel(error);
	59	}
	60
	61	protected override void OnTickError(Exception error) {
	62	if (MockOnError != null)
	63	MockOnError(error);
	64	}
	65
	66	public void CallComponentFail(Exception error) {
	67	Fail(error);
	68	}
	69	}
	70	}
	71

Implab.Test/Mock/MockRunnableComponent.cs created 644 +38 0

@@ -0,0 +1,38
	1	using System;
	2	using Implab.Components;
	3
	4	namespace Implab.Test.Mock {
	5	class MockRunnableComponent : RunnableComponent {
	6	public MockRunnableComponent(bool initialized) : base(initialized) {
	7	}
	8
	9	public Action MockInit {
	10	get;
	11	set;
	12	}
	13
	14	public Func<IPromise> MockStart {
	15	get;
	16	set;
	17	}
	18
	19	public Func<IPromise> MockStop {
	20	get;
	21	set;
	22	}
	23
	24	protected override IPromise OnStart() {
	25	return MockStart != null ? Safe.Run(MockStart).Chain(base.OnStart) : Safe.Run(base.OnStart);
	26	}
	27
	28	protected override IPromise OnStop() {
	29	return MockStop != null ? Safe.Run(MockStop).Chain(base.OnStop) : Safe.Run(base.OnStop);
	30	}
	31
	32	protected override void OnInitialize() {
	33	if (MockInit != null)
	34	MockInit();
	35	}
	36	}
	37	}
	38

Implab.Test/PollingComponentTests.cs created 644 +230 0

@@ -0,0 +1,230
	1	using System;
	2	using System.Reflection;
	3	using System.Threading;
	4	using Implab.Parallels;
	5	using Implab.Components;
	6	using Implab.Test.Mock;
	7
	8	#if MONO
	9
	10	using NUnit.Framework;
	11	using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
	12	using TestMethodAttribute = NUnit.Framework.TestAttribute;
	13	using AssertFailedException = NUnit.Framework.AssertionException;
	14	#else
	15
	16	using Microsoft.VisualStudio.TestTools.UnitTesting;
	17
	18	#endif
	19
	20	namespace Implab.Test {
	21	[TestClass]
	22	public class PollingComponentTests {
	23	static void ShouldThrow(Action action) {
	24	try {
	25	action();
	26	Assert.Fail();
	27	} catch (AssertFailedException) {
	28	throw;
	29	} catch {
	30	}
	31	}
	32
	33	[TestMethod]
	34	public void NormalFlowTest() {
	35	var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, false);
	36
	37	Assert.AreEqual(ExecutionState.Created, comp.State);
	38
	39	comp.Init();
	40
	41	Assert.AreEqual(ExecutionState.Ready, comp.State);
	42
	43	comp.Start().Join(1000);
	44
	45	Assert.AreEqual(ExecutionState.Running, comp.State);
	46
	47	comp.Stop().Join(1000);
	48
	49	Assert.AreEqual(ExecutionState.Disposed, comp.State);
	50
	51	}
	52
	53	[TestMethod]
	54	public void ShouldStartTicks() {
	55	var signal = new Signal();
	56
	57	var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, true);
	58	comp.MockTick = ct => {
	59	signal.Set();
	60	return Promise.SUCCESS;
	61	};
	62
	63	comp.Start().Join(1000);
	64	signal.Wait(1000);
	65	comp.Stop().Join(1000);
	66	}
	67
	68	[TestMethod]
	69	public void StopShouldWaitForTickToComplete() {
	70	var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, true);
	71	var signal = new Signal();
	72	var promise = new Promise();
	73
	74	// timer should tick once
	75	comp.MockTick = ct => {
	76	signal.Set();
	77	return promise;
	78	};
	79
	80	// start timer
	81	comp.Start().Join(1000);
	82
	83	signal.Wait(); // wait for tick
	84
	85	// try to stop component
	86	var stopping = comp.Stop();
	87
	88	Assert.AreEqual(ExecutionState.Stopping, comp.State);
	89	ShouldThrow(() => stopping.Join(100));
	90	Assert.AreEqual(ExecutionState.Stopping, comp.State);
	91
	92	// complete operation
	93	promise.Resolve();
	94
	95	// the component should stop normally
	96	stopping.Join(1000);
	97
	98	Assert.AreEqual(ExecutionState.Disposed, comp.State);
	99	}
	100
	101	[TestMethod]
	102	public void ShouldRecoverAfterTickError() {
	103	var ticks = 0;
	104
	105	var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, true);
	106	var signal = new Signal(); // will signal when timer fires 10 times
	107
	108	comp.MockTick = ct => {
	109	ticks++;
	110	if (ticks == 10)
	111	signal.Set();
	112	// each time handler dies
	113	throw new Exception("tainted handler");
	114	};
	115
	116	comp.Start();
	117
	118	signal.Wait(1000);
	119
	120	comp.Stop().Join(1000);
	121
	122	Assert.AreEqual(ExecutionState.Disposed, comp.State);
	123	}
	124
	125	[TestMethod]
	126	public void StopCancelHandlerOnStop() {
	127	var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, true);
	128	var started = new Signal();
	129	bool cancelled = false;
	130
	131	// timer should tick once
	132	comp.MockTick = ct => {
	133	started.Set();
	134
	135	while(!ct.IsCancellationRequested) {
	136	Thread.Sleep(1);
	137	}
	138
	139	cancelled = true;
	140
	141	throw new OperationCanceledException();
	142	};
	143
	144	// start timer
	145	comp.Start().Join(1000);
	146
	147	started.Wait(); // wait for tick
	148
	149	// try to stop component
	150	comp.Stop().Join(1000);
	151
	152	Assert.AreEqual(true, cancelled);
	153
	154	Assert.AreEqual(ExecutionState.Disposed, comp.State);
	155	}
	156
	157	[TestMethod]
	158	public void FailTickOnStopShouldBeIgnored() {
	159	var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, true);
	160	var started = new Signal();
	161	var finish = new Signal();
	162
	163	// timer should tick once
	164	comp.MockTick = ct => {
	165	started.Set();
	166	finish.Wait();
	167	// component is in stopping state here
	168	throw new Exception("Die, die, die!!!");
	169	};
	170
	171
	172	comp.MockOnError = comp.CallComponentFail;
	173
	174	// start timer
	175	comp.Start().Join(1000);
	176
	177	started.Wait(); // wait for tick
	178
	179	// try to stop component
	180	var stopping = comp.Stop();
	181
	182	// the component is in stopping state but it is waiting for the tick handler to complete
	183	finish.Set(); // signal the tick handler to finish
	184
	185	// tick handler should stop rather soon
	186	stopping.Join(1000);
	187
	188	// validate the component is disposed
	189	Assert.AreEqual(ExecutionState.Disposed, comp.State);
	190	}
	191
	192	[TestMethod]
	193	public void FailTickShouldFailComponent() {
	194	var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, true);
	195	var started = new Signal();
	196	var finish = new Signal();
	197
	198	// timer should tick once
	199	comp.MockTick = ct => {
	200	started.Set();
	201	throw new Exception("Die, die, die!!!");
	202	};
	203
	204
	205	comp.MockOnError = err => {
	206	comp.CallComponentFail(err);
	207	finish.Set();
	208	};
	209
	210	// start timer
	211	comp.Start().Join(1000);
	212
	213	started.Wait(); // wait for tick
	214
	215	finish.Wait();
	216
	217	// try to stop component
	218	ShouldThrow(() => comp.Stop());
	219
	220	Assert.AreEqual(ExecutionState.Failed, comp.State);
	221	Assert.IsNotNull(comp.LastError);
	222	Assert.AreEqual("Die, die, die!!!", comp.LastError.Message);
	223
	224	comp.Dispose();
	225	Assert.AreEqual(ExecutionState.Disposed, comp.State);
	226	}
	227
	228	}
	229	}
	230

Implab/Components/PollingComponent.cs created 644 +155 0

@@ -0,0 +1,155
	1	using System;
	2	using System.Threading;
	3	using Implab.Diagnostics;
	4
	5	namespace Implab.Components {
	6	public class PollingComponent : RunnableComponent {
	7	readonly Timer m_timer;
	8	readonly Func<Func<ICancellationToken, IPromise>, IPromise> m_dispatcher;
	9	readonly TimeSpan m_interval;
	10
	11	readonly object m_lock = new object();
	12
	13	ActionTask m_pending;
	14
	15	protected PollingComponent(TimeSpan interval, Func<Func<ICancellationToken, IPromise>, IPromise> dispatcher, bool initialized) : base(initialized) {
	16	m_timer = new Timer(OnInternalTick);
	17
	18	m_interval = interval;
	19	m_dispatcher = dispatcher;
	20	}
	21
	22	protected override IPromise OnStart() {
	23	m_timer.Change(TimeSpan.Zero, m_interval);
	24
	25	return base.OnStart();
	26	}
	27
	28	void OnInternalTick(object state) {
	29	if (StartTick()) {
	30	try {
	31	if (m_dispatcher != null) {
	32	var result = m_dispatcher(OnTick);
	33	m_pending.CancellationRequested(result.Cancel);
	34	AwaitTick(result);
	35	} else {
	36	AwaitTick(OnTick(m_pending));
	37	}
	38	} catch (Exception error) {
	39	HandleTickError(error);
	40	}
	41	}
	42	}
	43
	44	/// <summary>
	45	/// Checks wheather there is no running handler in the component and marks that the handler is starting.
	46	/// </summary>
	47	/// <returns>boolean value, true - the new tick handler may be invoked, false - a tick handler is already running or a component isn't running.</returns>
	48	/// <remarks>
	49	/// If the component is stopping no new handlers can be run. Every successful call to this method must be completed with either AwaitTick or HandleTickError handlers.
	50	/// </remarks>
	51	protected virtual bool StartTick() {
	52	lock (m_lock) {
	53	if (State != ExecutionState.Running \|\| m_pending != null)
	54	return false;
	55	// actually the component may be in a not running state here (stopping, disposed or what ever),
	56	// but OnStop method also locks on the same object and will handle operation in m_pending
	57	m_pending = new ActionTask(
	58	() => {
	59	// only one operation is running, it's safe to assing m_pending from it
	60	m_pending = null;
	61	},
	62	ex => {
	63	try {
	64	OnTickError(ex);
	65	// Analysis disable once EmptyGeneralCatchClause
	66	} catch {
	67	} finally {
	68	m_pending = null;
	69	}
	70	// suppress error
	71	},
	72	ex => {
	73	try {
	74	OnTickCancel(ex);
	75	// Analysis disable once EmptyGeneralCatchClause
	76	} catch {
	77	} finally {
	78	m_pending = null;
	79	}
	80	// supress cancellation
	81	},
	82	false
	83	);
	84	return true;
	85	}
	86	}
	87
	88	/// <summary>
	89	/// Awaits the tick.
	90	/// </summary>
	91	/// <param name="tick">Tick.</param>
	92	/// <remarks>
	93	/// This method is called only after StartTick method and m_pending will hold the promise which should be fulfilled.
	94	/// </remarks>
	95	void AwaitTick(IPromise tick) {
	96	if (tick == null) {
	97	m_pending.Resolve();
	98	} else {
	99	tick.On(
	100	m_pending.Resolve,
	101	m_pending.Reject,
	102	m_pending.CancelOperation
	103	);
	104	}
	105	}
	106
	107	/// <summary>
	108	/// Handles the tick error.
	109	/// </summary>
	110	/// <remarks>
	111	/// This method is called only after StartTick method and m_pending will hold the promise which should be fulfilled.
	112	/// </remarks>
	113	void HandleTickError(Exception error) {
	114	m_pending.Reject(error);
	115	}
	116
	117	protected virtual void OnTickError(Exception error) {
	118	}
	119
	120	protected virtual void OnTickCancel(Exception error) {
	121	}
	122
	123	/// <summary>
	124	/// Invoked when the timer ticks, use this method to implement your logic
	125	/// </summary>
	126	protected virtual IPromise OnTick(ICancellationToken cancellationToken) {
	127	return Promise.SUCCESS;
	128	}
	129
	130	protected override IPromise OnStop() {
	131	m_timer.Change(-1, -1);
	132
	133	// the component is in the stopping state
	134	lock (m_lock) {
	135	// after this lock no more pending operations could be created
	136	var pending = m_pending;
	137	// m_pending could be fulfilled and set to null already
	138	if (pending != null) {
	139	pending.Cancel();
	140	return pending.Then(base.OnStop);
	141	}
	142	}
	143
	144	return base.OnStop();
	145	}
	146
	147	protected override void Dispose(bool disposing, Exception lastError) {
	148	if (disposing)
	149	Safe.Dispose(m_timer);
	150
	151	base.Dispose(disposing, lastError);
	152	}
	153	}
	154	}
	155

Implab/FailedPromise.cs created 644 +100 0

@@ -0,0 +1,100
	1	using System;
	2	using System.Reflection;
	3
	4	namespace Implab {
	5	public class FailedPromise : IPromise {
	6	readonly Exception m_error;
	7	public FailedPromise(Exception error) {
	8	Safe.ArgumentNotNull(error, "error");
	9	m_error = error;
	10	}
	11
	12	#region IPromise implementation
	13
	14	public IPromise On(Action success, Action<Exception> error, Action<Exception> cancel) {
	15	if (error != null) {
	16	try {
	17	error(m_error);
	18	// Analysis disable once EmptyGeneralCatchClause
	19	} catch {
	20	}
	21	}
	22	return this;
	23	}
	24
	25	public IPromise On(Action success, Action<Exception> error) {
	26	if (error != null) {
	27	try {
	28	error(m_error);
	29	// Analysis disable once EmptyGeneralCatchClause
	30	} catch {
	31	}
	32	}
	33	return this;
	34	}
	35
	36	public IPromise On(Action success) {
	37	return this;
	38	}
	39
	40	public IPromise On(Action handler, PromiseEventType events) {
	41	if ((events & PromiseEventType.Error) != 0) {
	42	try {
	43	handler();
	44	// Analysis disable once EmptyGeneralCatchClause
	45	} catch {
	46	}
	47	}
	48	return this;
	49	}
	50
	51	public IPromise<T> Cast<T>() {
	52	return (IPromise<T>)this;
	53	}
	54
	55	public void Join() {
	56	throw new TargetInvocationException(Error);
	57	}
	58
	59	public void Join(int timeout) {
	60	throw new TargetInvocationException(Error);
	61	}
	62
	63	public virtual Type PromiseType {
	64	get {
	65	return typeof(void);
	66	}
	67	}
	68
	69	public bool IsResolved {
	70	get {
	71	return true;
	72	}
	73	}
	74
	75	public bool IsCancelled {
	76	get {
	77	return false;
	78	}
	79	}
	80
	81	public Exception Error {
	82	get {
	83	return m_error;
	84	}
	85	}
	86
	87	#endregion
	88
	89	#region ICancellable implementation
	90
	91	public void Cancel() {
	92	}
	93
	94	public void Cancel(Exception reason) {
	95	}
	96
	97	#endregion
	98	}
	99	}
	100

Implab/FailedPromiseT.cs created 644 +65 0

@@ -0,0 +1,65
	1	using System;
	2	using System.Reflection;
	3
	4	namespace Implab {
	5	public class FailedPromise<T> : FailedPromise, IPromise<T> {
	6	public FailedPromise(Exception error) : base(error) {
	7	}
	8
	9	public IPromise<T> On(Action<T> success, Action<Exception> error, Action<Exception> cancel) {
	10	if (error != null) {
	11	try {
	12	error(Error);
	13	// Analysis disable once EmptyGeneralCatchClause
	14	} catch {
	15	}
	16	}
	17	return this;
	18	}
	19
	20	public IPromise<T> On(Action<T> success, Action<Exception> error) {
	21	if (error != null) {
	22	try {
	23	error(Error);
	24	// Analysis disable once EmptyGeneralCatchClause
	25	} catch {
	26	}
	27	}
	28	return this;
	29	}
	30
	31	public IPromise<T> On(Action<T> success) {
	32	return this;
	33	}
	34
	35	T IPromise<T>.Join() {
	36	throw new TargetInvocationException(Error);
	37	}
	38
	39	T IPromise<T>.Join(int timeout) {
	40	throw new TargetInvocationException(Error);
	41	}
	42
	43
	44	IPromise<T> IPromise<T>.On(Action success, Action<Exception> error, Action<Exception> cancel) {
	45	On(success, error, cancel);
	46	return this;
	47	}
	48
	49	IPromise<T> IPromise<T>.On(Action success, Action<Exception> error) {
	50	On(success, error);
	51	return this;
	52	}
	53
	54	IPromise<T> IPromise<T>.On(Action success) {
	55	On(success);
	56	return this;
	57	}
	58
	59	IPromise<T> IPromise<T>.On(Action handler, PromiseEventType events) {
	60	On(handler, events);
	61	return this;
	62	}
	63	}
	64	}
	65

Implab.Test/Implab.Test.mono.csproj +6 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" />
+                <Compile Include="PollingComponentTests.cs" />
+                <Compile Include="Mock\MockRunnableComponent.cs" />
+                <Compile Include="Mock\MockPollingComponent.cs" />
               </ItemGroup>
               <ItemGroup>
                 <ProjectReference Include="..\Implab\Implab.csproj">
                   <Project>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</Project>
                   <Name>Implab</Name>
                 </ProjectReference>
               </ItemGroup>
+              <ItemGroup>
+                <Folder Include="Mock\" />
+              </ItemGroup>
             </Project>

Implab.Test/PromiseHelper.cs +8 0

             using Implab.Parallels;
             using System.Threading;
             namespace Implab.Test {
                 static class PromiseHelper {
                     public static IPromise<T> Sleep<T>(int timeout, T retVal) {
                         return AsyncPool.Invoke((ct) => {
                             ct.CancellationRequested(ct.CancelOperation);
                             Thread.Sleep(timeout);
                             return retVal;
                         });
                     }
+                    public static IPromise Sleep(int timeout) {
+                        return AsyncPool.Invoke((ct) => {
+                            ct.CancellationRequested(ct.CancelOperation);
+                            Thread.Sleep(timeout);
+                            return 0;
+                        });
+                    }
                 }
             }

Implab.Test/RunnableComponentTests.cs +8 -38

             using System;
             using System.Reflection;
             using System.Threading;
             using Implab.Parallels;
             using Implab.Components;
+            using Implab.Test.Mock;
             #if MONO
             using NUnit.Framework;
             using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
             using TestMethodAttribute = NUnit.Framework.TestAttribute;
             using AssertFailedException = NUnit.Framework.AssertionException;
             #else
             using Microsoft.VisualStudio.TestTools.UnitTesting;
             #endif
             namespace Implab.Test {
                 [TestClass]
                 public class RunnableComponentTests {
                     static void ShouldThrow(Action action) {
                         try {
                             action();
                             Assert.Fail();
                         } catch (AssertFailedException) {
                             throw;
                         } catch {
                         }
                     }
-                    class Runnable : RunnableComponent {
-                        public Runnable(bool initialized) : base(initialized) {
-                        public Action MockInit {
-                            get;
-                            set;
-                        public Func<IPromise> MockStart {
-                            get;
-                            set;
-                        public Func<IPromise> MockStop {
-                            get;
-                            set;
-                        protected override IPromise OnStart() {
-                            return MockStart != null ? MockStart() : base.OnStart();
-                        protected override IPromise OnStop() {
-                            return MockStop != null ? MockStop() : base.OnStart();
-                        protected override void OnInitialize() {
-                            if (MockInit != null)
-                                MockInit();
                     [TestMethod]
                     public void NormalFlowTest() {
-                        var comp = new Runnable(false);
+                        var comp = new MockRunnableComponent(false);
                         Assert.AreEqual(ExecutionState.Created, comp.State);
                         comp.Init();
                         Assert.AreEqual(ExecutionState.Ready, comp.State);
                         comp.Start().Join(1000);
                         Assert.AreEqual(ExecutionState.Running, comp.State);
                         comp.Stop().Join(1000);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void InitFailTest() {
-                        var comp = new Runnable(false) {
+                        var comp = new MockRunnableComponent(false) {
                             MockInit = () => {
                                 throw new Exception("BAD");
                             }
                         };
                         ShouldThrow(() => comp.Start());
                         ShouldThrow(() => comp.Stop());
                         Assert.AreEqual(ExecutionState.Created, comp.State);
                         ShouldThrow(comp.Init);
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
                         ShouldThrow(() => comp.Start());
                         ShouldThrow(() => comp.Stop());
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
                         comp.Dispose();
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void DisposedTest() {
-                        var comp = new Runnable(false);
+                        var comp = new MockRunnableComponent(false);
                         comp.Dispose();
                         ShouldThrow(() => comp.Start());
                         ShouldThrow(() => comp.Stop());
                         ShouldThrow(comp.Init);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void StartCancelTest() {
-                        var comp = new Runnable(true) {
+                        var comp = new MockRunnableComponent(true) {
                             MockStart = () => PromiseHelper.Sleep(100000, 0)
                         };
                         var p = comp.Start();
                         Assert.AreEqual(ExecutionState.Starting, comp.State);
                         p.Cancel();
                         ShouldThrow(() => p.Join(1000));
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
                         Assert.IsTrue(comp.LastError is OperationCanceledException);
                         comp.Dispose();
                     }
                     [TestMethod]
                     public void StartStopTest() {
                         var stop = new Signal();
-                        var comp = new Runnable(true) {
+                        var comp = new MockRunnableComponent(true) {
                             MockStart = () => PromiseHelper.Sleep(100000, 0),
                             MockStop = () => AsyncPool.RunThread(stop.Wait)
                         };
                         var p1 = comp.Start();
                         var p2 = comp.Stop();
                         // should enter stopping state
                         ShouldThrow(p1.Join);
                         Assert.IsTrue(p1.IsCancelled);
                         Assert.AreEqual(ExecutionState.Stopping, comp.State);
                         stop.Set();
                         p2.Join(1000);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void StartStopFailTest() {
-                        var comp = new Runnable(true) {
+                        var comp = new MockRunnableComponent(true) {
                             MockStart = () => PromiseHelper.Sleep(100000, 0).Then(null,null,x => { throw new Exception("I'm dead"); })
                         };
                         comp.Start();
                         var p = comp.Stop();
                         // if Start fails to cancel, should fail to stop
                         ShouldThrow(() => p.Join(1000));
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
                         Assert.IsNotNull(comp.LastError);
                         Assert.AreEqual("I'm dead", comp.LastError.Message);
                     }
                     [TestMethod]
                     public void StopCancelTest() {
-                        var comp = new Runnable(true) {
+                        var comp = new MockRunnableComponent(true) {
                             MockStop = () => PromiseHelper.Sleep(100000, 0)
                         };
                         comp.Start();
                         var p = comp.Stop();
                         Assert.AreEqual(ExecutionState.Stopping, comp.State);
                         p.Cancel();
                         ShouldThrow(() => p.Join(1000));
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
                         Assert.IsTrue(comp.LastError is OperationCanceledException);
                         comp.Dispose();
                     }
                 }
             }

Implab/Components/IRunnable.cs +6 0

             using System;
             namespace Implab.Components {
                 public interface IRunnable {
+                    /// <summary>
+                    /// Starts this instance.
+                    /// </summary>
                     IPromise Start();
+                    /// <summary>
+                    /// Stops this instance. After the instance is stopped it can't be started again, stopping should be treated as gracefull and async dispose.
+                    /// </summary>
                     IPromise Stop();
                     ExecutionState State { get; }
                     Exception LastError { get; }
                 }
             }

Implab/Components/RunnableComponent.cs +37 -6

             using System;
             namespace Implab.Components {
                 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.Initializing, Commands.Init);
                             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.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);
+                        DisposeTimeout = 10000;
                     }
-                    protected virtual int DisposeTimeout {
+                    /// <summary>
-                        get {
+                    /// Gets or sets the timeout to wait for the pending operation to complete. If the pending operation doesn't finish than the component will be disposed anyway.
-                            return 10000;
+                    /// </summary>
+                    protected int DisposeTimeout {
+                        get;
+                        set;
                     }
                     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));
                     }
                     void Move(Commands cmd) {
                         if (!m_stateMachine.Move(cmd))
                             ThrowInvalidCommand(cmd);
                     }
+                    /// <summary>
+                    /// Moves the component from running to failed state.
+                    /// </summary>
+                    /// <param name="error">The exception which is describing the error.</param>
+                    /// <returns>Returns true if the component is set to the failed state, false - otherwise.
+                    /// This method works only for the running state, in any other state it will return false.</returns>
+                    protected bool Fail(Exception error) {
+                        lock (m_stateMachine) {
+                            if(m_stateMachine.State == ExecutionState.Running) {
+                                m_stateMachine.Move(Commands.Fail);
+                                m_lastError = error;
+                                return true;
+                            }
+                        }
+                        return false;
+                    }
                     void Invoke(Commands cmd, Action action) {
                         lock (m_stateMachine)
                             Move(cmd);
                         try {
                             action();
                             lock(m_stateMachine)
                                 Move(Commands.Ok);
                         } catch (Exception err) {
                             lock (m_stateMachine) {
                                 Move(Commands.Fail);
                                 m_lastError = err;
                             }
                             throw;
                         }
                     }
                     IPromise InvokeAsync(Commands cmd, Func<IPromise> action, Action<IPromise, IDeferred> chain) {
                         IPromise promise = null;
                         IPromise prev;
                         var task = new ActionChainTask(action, null, null, true);
                         lock (m_stateMachine) {
                             Move(cmd);
                             prev = m_pending;
                             Action<Exception> errorOrCancel = e => {
                                 if (e == null)
                                     e = new OperationCanceledException();
                                 lock (m_stateMachine) {
                                     if (m_pending == promise) {
                                         Move(Commands.Fail);
                                         m_pending = null;
                                         m_lastError = e;
                                     }
                                 }
                                 throw new PromiseTransientException(e);
                             };
                             promise = task.Then(
                                 () => {
                                     lock(m_stateMachine) {
                                         if (m_pending == promise) {
                                             Move(Commands.Ok);
                                             m_pending = null;
                                         }
                                     }
                                 },
                                 errorOrCancel,
                                 errorOrCancel
                             );
                             m_pending = promise;
                         }
                         if (prev == null)
                             task.Resolve();
                         else
                             chain(prev, task);
                         return promise;
                     }
                     #region IInitializable implementation
                     public void Init() {
                         Invoke(Commands.Init, OnInitialize);
                     }
                     protected virtual void OnInitialize() {
                     }
                     #endregion
                     #region IRunnable implementation
                     public IPromise Start() {
                         return InvokeAsync(Commands.Start, OnStart, null);
                     }
                     protected virtual IPromise OnStart() {
                         return Promise.SUCCESS;
                     }
                     public IPromise Stop() {
                         return InvokeAsync(Commands.Stop, OnStop, StopPending).Then(Dispose);
                     }
                     protected virtual IPromise OnStop() {
                         return Promise.SUCCESS;
                     }
                     /// <summary>
                     /// 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, // если текущая операция дала ошибку - то все плохо, нельзя продолжать
                                 e => stop.Resolve() // если текущая отменилась, то можно начинать остановку
                             );
                             // посылаем текущей операции сигнал остановки
                             current.Cancel();
                         }
                     }
                     public ExecutionState State {
                         get {
-                            lock (m_stateMachine)
+                            return m_stateMachine.State;
-                                return m_stateMachine.State;
                         }
                     }
                     public Exception LastError {
                         get {
                             return m_lastError;
                         }
                     }
                     #endregion
                     #region IDisposable implementation
+                    /// <summary>
+                    /// Releases all resource used by the <see cref="Implab.Components.RunnableComponent"/> object.
+                    /// </summary>
+                    /// <remarks>
+                    /// <para>Will not try to stop the component, it will just release all resources.
+                    /// To cleanup the component gracefully use <see cref="Stop()"/> method.</para>
+                    /// <para>
+                    /// In normal cases the <see cref="Dispose()"/> method shouldn't be called, the call to the <see cref="Stop()"/>
+                    /// method is sufficient to cleanup the component. Call <see cref="Dispose()"/> only to cleanup after errors,
+                    /// especially if <see cref="Stop"/> method is failed. Using this method insted of <see cref="Stop()"/> may
+                    /// lead to the data loss by the component.
+                    /// </para></remarks>
                     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/Implab.csproj +3 -1

             <?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>
                 <ProjectGuid>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <RootNamespace>Implab</RootNamespace>
                 <AssemblyName>Implab</AssemblyName>
                 <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
                 <ReleaseVersion>0.2</ReleaseVersion>
                 <ProductVersion>8.0.30703</ProductVersion>
                 <SchemaVersion>2.0</SchemaVersion>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                 <DebugType>full</DebugType>
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;NET_4_5</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <DefineConstants>NET_4_5</DefineConstants>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'DebugMono|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;NET_4_5;MONO</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'ReleaseMono|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="System.Xml" />
                 <Reference Include="mscorlib" />
               </ItemGroup>
               <ItemGroup>
                 <Compile Include="CustomEqualityComparer.cs" />
                 <Compile Include="Diagnostics\ConsoleTraceListener.cs" />
                 <Compile Include="Diagnostics\LogChannel.cs" />
                 <Compile Include="Diagnostics\LogicalOperation.cs" />
                 <Compile Include="Diagnostics\TextFileListener.cs" />
                 <Compile Include="Diagnostics\TraceLog.cs" />
                 <Compile Include="Diagnostics\TraceEvent.cs" />
                 <Compile Include="Diagnostics\TraceEventType.cs" />
                 <Compile Include="ICancellable.cs" />
                 <Compile Include="IProgressHandler.cs" />
                 <Compile Include="IProgressNotifier.cs" />
                 <Compile Include="IPromiseT.cs" />
                 <Compile Include="IPromise.cs" />
                 <Compile Include="IServiceLocator.cs" />
                 <Compile Include="ITaskController.cs" />
                 <Compile Include="Parallels\DispatchPool.cs" />
                 <Compile Include="Parallels\ArrayTraits.cs" />
                 <Compile Include="Parallels\MTQueue.cs" />
                 <Compile Include="Parallels\WorkerPool.cs" />
                 <Compile Include="ProgressInitEventArgs.cs" />
                 <Compile Include="Properties\AssemblyInfo.cs" />
                 <Compile Include="Parallels\AsyncPool.cs" />
                 <Compile Include="Safe.cs" />
                 <Compile Include="ValueEventArgs.cs" />
                 <Compile Include="PromiseExtensions.cs" />
                 <Compile Include="SyncContextPromise.cs" />
                 <Compile Include="Diagnostics\OperationContext.cs" />
                 <Compile Include="Diagnostics\TraceContext.cs" />
                 <Compile Include="Diagnostics\LogEventArgs.cs" />
                 <Compile Include="Diagnostics\LogEventArgsT.cs" />
                 <Compile Include="Diagnostics\Extensions.cs" />
                 <Compile Include="PromiseEventType.cs" />
                 <Compile Include="Parallels\AsyncQueue.cs" />
                 <Compile Include="PromiseT.cs" />
                 <Compile Include="IDeferred.cs" />
                 <Compile Include="IDeferredT.cs" />
                 <Compile Include="Promise.cs" />
                 <Compile Include="PromiseTransientException.cs" />
                 <Compile Include="Parallels\Signal.cs" />
                 <Compile Include="Parallels\SharedLock.cs" />
                 <Compile Include="Diagnostics\ILogWriter.cs" />
                 <Compile Include="Diagnostics\ListenerBase.cs" />
                 <Compile Include="Parallels\BlockingQueue.cs" />
                 <Compile Include="AbstractEvent.cs" />
                 <Compile Include="AbstractPromise.cs" />
                 <Compile Include="AbstractPromiseT.cs" />
                 <Compile Include="FuncTask.cs" />
                 <Compile Include="FuncTaskBase.cs" />
                 <Compile Include="FuncTaskT.cs" />
                 <Compile Include="ActionChainTaskBase.cs" />
                 <Compile Include="ActionChainTask.cs" />
                 <Compile Include="ActionChainTaskT.cs" />
                 <Compile Include="FuncChainTaskBase.cs" />
                 <Compile Include="FuncChainTask.cs" />
                 <Compile Include="FuncChainTaskT.cs" />
                 <Compile Include="ActionTaskBase.cs" />
                 <Compile Include="ActionTask.cs" />
                 <Compile Include="ActionTaskT.cs" />
                 <Compile Include="ICancellationToken.cs" />
                 <Compile Include="SuccessPromise.cs" />
                 <Compile Include="SuccessPromiseT.cs" />
                 <Compile Include="PromiseAwaiterT.cs" />
                 <Compile Include="PromiseAwaiter.cs" />
                 <Compile Include="Components\ComponentContainer.cs" />
                 <Compile Include="Components\Disposable.cs" />
                 <Compile Include="Components\DisposablePool.cs" />
                 <Compile Include="Components\ObjectPool.cs" />
                 <Compile Include="Components\ServiceLocator.cs" />
                 <Compile Include="Components\IInitializable.cs" />
                 <Compile Include="TaskController.cs" />
                 <Compile Include="Components\App.cs" />
                 <Compile Include="Components\IRunnable.cs" />
                 <Compile Include="Components\ExecutionState.cs" />
                 <Compile Include="Components\RunnableComponent.cs" />
                 <Compile Include="Components\IFactory.cs" />
                 <Compile Include="Automaton\IAlphabet.cs" />
                 <Compile Include="Automaton\ParserException.cs" />
                 <Compile Include="Automaton\IndexedAlphabetBase.cs" />
                 <Compile Include="Automaton\IAlphabetBuilder.cs" />
                 <Compile Include="Automaton\RegularExpressions\AltToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\BinaryToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\CatToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\StarToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\SymbolToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\EmptyToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\Token.cs" />
                 <Compile Include="Automaton\RegularExpressions\IVisitor.cs" />
                 <Compile Include="Automaton\AutomatonTransition.cs" />
                 <Compile Include="Formats\JSON\JSONElementContext.cs" />
                 <Compile Include="Formats\JSON\JSONElementType.cs" />
                 <Compile Include="Formats\JSON\JSONGrammar.cs" />
                 <Compile Include="Formats\JSON\JSONParser.cs" />
                 <Compile Include="Formats\JSON\JSONScanner.cs" />
                 <Compile Include="Formats\JSON\JsonTokenType.cs" />
                 <Compile Include="Formats\JSON\JSONWriter.cs" />
                 <Compile Include="Formats\JSON\JSONXmlReader.cs" />
                 <Compile Include="Formats\JSON\JSONXmlReaderOptions.cs" />
                 <Compile Include="Formats\JSON\StringTranslator.cs" />
                 <Compile Include="Automaton\MapAlphabet.cs" />
                 <Compile Include="Formats\CharAlphabet.cs" />
                 <Compile Include="Formats\ByteAlphabet.cs" />
                 <Compile Include="Automaton\IDFATable.cs" />
                 <Compile Include="Automaton\IDFATableBuilder.cs" />
                 <Compile Include="Automaton\DFATable.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularExpressionVisitor.cs" />
                 <Compile Include="Automaton\RegularExpressions\ITaggedDFABuilder.cs" />
                 <Compile Include="Formats\TextScanner.cs" />
                 <Compile Include="Formats\StringScanner.cs" />
                 <Compile Include="Formats\ReaderScanner.cs" />
                 <Compile Include="Formats\ScannerContext.cs" />
                 <Compile Include="Formats\Grammar.cs" />
                 <Compile Include="Automaton\RegularExpressions\EndTokenT.cs" />
                 <Compile Include="Automaton\RegularExpressions\EndToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularExpressionVisitorT.cs" />
                 <Compile Include="Automaton\AutomatonConst.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularDFA.cs" />
                 <Compile Include="Components\LazyAndWeak.cs" />
                 <Compile Include="AbstractTask.cs" />
                 <Compile Include="AbstractTaskT.cs" />
-                <Compile Include="Components\PollingRunnableComponent.cs" />
+                <Compile Include="FailedPromise.cs" />
+                <Compile Include="FailedPromiseT.cs" />
+                <Compile Include="Components\PollingComponent.cs" />
               </ItemGroup>
               <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
               <ItemGroup />
               <ProjectExtensions>
                 <MonoDevelop>
                   <Properties>
                     <Policies>
                       <CSharpFormattingPolicy IndentSwitchBody="True" NamespaceBraceStyle="EndOfLine" ClassBraceStyle="EndOfLine" InterfaceBraceStyle="EndOfLine" StructBraceStyle="EndOfLine" EnumBraceStyle="EndOfLine" MethodBraceStyle="EndOfLine" ConstructorBraceStyle="EndOfLine" DestructorBraceStyle="EndOfLine" BeforeMethodDeclarationParentheses="False" BeforeMethodCallParentheses="False" BeforeConstructorDeclarationParentheses="False" NewLineBeforeConstructorInitializerColon="NewLine" NewLineAfterConstructorInitializerColon="SameLine" BeforeIndexerDeclarationBracket="False" BeforeDelegateDeclarationParentheses="False" NewParentheses="False" SpacesBeforeBrackets="False" inheritsSet="Mono" inheritsScope="text/x-csharp" scope="text/x-csharp" />
                       <TextStylePolicy FileWidth="120" EolMarker="Unix" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/x-csharp" />
                       <DotNetNamingPolicy DirectoryNamespaceAssociation="PrefixedHierarchical" ResourceNamePolicy="MSBuild" />
                       <TextStylePolicy FileWidth="120" TabsToSpaces="False" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="application/xml" />
                       <XmlFormattingPolicy inheritsSet="Mono" inheritsScope="application/xml" scope="application/xml" />
                       <TextStylePolicy FileWidth="120" TabsToSpaces="False" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/plain" />
                       <NameConventionPolicy>
                         <Rules>
                           <NamingRule Name="Namespaces" AffectedEntity="Namespace" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Types" AffectedEntity="Class, Struct, Enum, Delegate" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Interfaces" AffectedEntity="Interface" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>I</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Attributes" AffectedEntity="CustomAttributes" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>Attribute</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Event Arguments" AffectedEntity="CustomEventArgs" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>EventArgs</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Exceptions" AffectedEntity="CustomExceptions" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>Exception</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Methods" AffectedEntity="Methods" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Static Readonly Fields" AffectedEntity="ReadonlyField" VisibilityMask="Internal, Protected, Public" NamingStyle="CamelCase" IncludeInstanceMembers="False" IncludeStaticEntities="True" />
                           <NamingRule Name="Fields (Non Private)" AffectedEntity="Field" VisibilityMask="Internal, Public" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="ReadOnly Fields (Non Private)" AffectedEntity="ReadonlyField" VisibilityMask="Internal, Public" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False" />
                           <NamingRule Name="Fields (Private)" AffectedEntity="Field, ReadonlyField" VisibilityMask="Private, Protected" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False">
                             <RequiredPrefixes>
                               <String>m_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Static Fields (Private)" AffectedEntity="Field" VisibilityMask="Private" NamingStyle="CamelCase" IncludeInstanceMembers="False" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="ReadOnly Fields (Private)" AffectedEntity="ReadonlyField" VisibilityMask="Private, Protected" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False">
                             <RequiredPrefixes>
                               <String>m_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Constant Fields" AffectedEntity="ConstantField" VisibilityMask="VisibilityMask" NamingStyle="AllUpper" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Properties" AffectedEntity="Property" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Events" AffectedEntity="Event" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Enum Members" AffectedEntity="EnumMember" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Parameters" AffectedEntity="Parameter, LocalVariable" VisibilityMask="VisibilityMask" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Type Parameters" AffectedEntity="TypeParameter" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>T</String>
                             </RequiredPrefixes>
                           </NamingRule>
                         </Rules>
                       </NameConventionPolicy>
                     </Policies>
                   </Properties>
                 </MonoDevelop>
               </ProjectExtensions>
               <ItemGroup>
                 <Folder Include="Components\" />
                 <Folder Include="Automaton\RegularExpressions\" />
                 <Folder Include="Formats\" />
                 <Folder Include="Formats\JSON\" />
               </ItemGroup>
             </Project>

Implab/PromiseT.cs +1 -3

             using System;
             using System.Diagnostics;
             using Implab.Parallels;
             namespace Implab {
                 /// <summary>
                 /// Класс для асинхронного получения результатов. Так называемое "обещание".
                 /// </summary>
                 /// <typeparam name="T">Тип получаемого результата</typeparam>
                 /// <remarks>
                 /// <para>Сервис при обращении к его методу дает обещаиние о выполнении операции,
                 /// клиент получив такое обещание может установить ряд обратных вызово для получения
                 /// событий выполнения обещания, тоесть завершения операции и предоставлении результатов.</para>
                 /// <para>
                 /// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на
                 /// данные события клиент должен использовать методы <c>Then</c>.
                 /// </para>
                 /// <para>
                 /// Сервис, в свою очередь, по окончанию выполнения операции (возможно с ошибкой),
                 /// использует методы <c>Resolve</c> либо <c>Reject</c> для оповещения клиетна о
                 /// выполнении обещания.
                 /// </para>
                 /// <para>
                 /// Если сервер успел выполнить обещание еще до того, как клиент на него подписался,
                 /// то в момент подписки клиента будут вызваны соответсвующие события в синхронном
                 /// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в
                 /// список в порядке подписания и в этом же порядке они будут вызваны при выполнении
                 /// обещания.
                 /// </para>
                 /// <para>
                 /// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать
                 /// связанные асинхронные операции, которые также возвращают обещания. Для этого следует
                 /// использовать соответствующую форму методе <c>Then</c>.
                 /// </para>
                 /// <para>
                 /// Также хорошим правилом является то, что <c>Resolve</c> и <c>Reject</c> должен вызывать
                 /// только инициатор обещания иначе могут возникнуть противоречия.
                 /// </para>
                 /// </remarks>
                 public class Promise<T> : AbstractPromise<T>, IDeferred<T> {
                     public static IPromise<T> FromResult(T value) {
                         return new SuccessPromise<T>(value);
                     }
                     public static IPromise<T> FromException(Exception error) {
-                        var p = new Promise<T>();
+                        return new FailedPromise<T>(error);
-                        p.Reject(error);
-                        return p;
                     }
                     public virtual void Resolve(T value) {
                         SetResult(value);
                     }
                     public void Reject(Exception error) {
                         SetError(error);
                     }
                 }
             }

Implab/Safe.cs +27 -41

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Text.RegularExpressions;
             using System.Diagnostics;
             namespace Implab
             {
                 public static class Safe
                 {
                     public static void ArgumentAssert(bool condition, string paramName) {
                         if (!condition)
                             throw new ArgumentException("The parameter is invalid", paramName);
                     }
                     public static void ArgumentMatch(string value, string paramName, Regex rx) {
                         if (rx == null)
                             throw new ArgumentNullException("rx");
                         if (!rx.IsMatch(value))
                             throw new ArgumentException(String.Format("The prameter value must match {0}", rx), paramName);
                     }
                     public static void ArgumentNotEmpty(string value, string paramName) {
                         if (String.IsNullOrEmpty(value))
                             throw new ArgumentException("The parameter can't be empty", paramName);
                     }
                     public static void ArgumentNotEmpty<T>(T[] value, string paramName) {
                         if (value == null || value.Length == 0)
                             throw new ArgumentException("The array must be not emty", paramName);
                     }
                     public static void ArgumentNotNull(object value, string paramName) {
                         if (value == null)
                             throw new ArgumentNullException(paramName);
                     }
                     public static void ArgumentInRange(int value, int min, int max, string paramName) {
                         if (value < min || value > max)
                             throw new ArgumentOutOfRangeException(paramName);
                     }
                     public static void ArgumentOfType(object value, Type type, string paramName) {
                         if (!type.IsInstanceOfType(value))
                             throw new ArgumentException(String.Format("The parameter must be of type {0}", type), paramName);
                     }
                     public static void Dispose(params IDisposable[] objects) {
                         foreach (var d in objects)
                             if (d != null)
                                 d.Dispose();
                     }
                     public static void Dispose(params object[] objects) {
                         foreach (var obj in objects) {
                             var d = obj as IDisposable;
                             if (d != null)
                                 d.Dispose();
                         }
                     }
                     public static void Dispose(object obj) {
                         var d = obj as IDisposable;
                         if (d != null)
                             d.Dispose();
                     }
                     [DebuggerStepThrough]
-                    public static IPromise<T> WrapPromise<T>(Func<T> action) {
+                    public static IPromise<T> Run<T>(Func<T> action) {
-                        ArgumentNotNull(action, "action");
-                        var p = new Promise<T>();
-                        try {
-                            p.Resolve(action());
-                        } catch (Exception err) {
-                            p.Reject(err);
-                        return p;
-                    [DebuggerStepThrough]
-                    public static IPromise WrapPromise(Action action) {
-                        ArgumentNotNull(action, "action");
-                        var p = new Promise();
-                        try {
-                            action();
-                            p.Resolve();
-                        } catch (Exception err) {
-                            p.Reject(err);
-                        return p;
-                    [DebuggerStepThrough]
-                    public static IPromise InvokePromise(Func<IPromise> action) {
                         ArgumentNotNull(action, "action");
                         try {
-                            var p = action();
+                            return Promise<T>.FromResult(action());
-                            if (p == null) {
-                                var d = new Promise();
-                                d.Reject(new Exception("The action returned null"));
-                                p = d;
-                            return p;
                         } catch (Exception err) {
-                            var p = new Promise();
+                            return Promise<T>.FromException(err);
-                            p.Reject(err);
-                            return p;
                         }
                     }
                     [DebuggerStepThrough]
-                    public static IPromise<T> InvokePromise<T>(Func<IPromise<T>> action) {
+                    public static IPromise Run(Action action) {
+                        ArgumentNotNull(action, "action");
+                        try {
+                            action();
+                            return Promise.SUCCESS;
+                        } catch (Exception err) {
+                            return new FailedPromise(err);
+                        }
+                    }
+                    [DebuggerStepThrough]
+                    public static IPromise Run(Func<IPromise> action) {
+                        ArgumentNotNull(action, "action");
+                        try {
+                            return action() ?? new FailedPromise(new Exception("The action returned null"));
+                        } catch (Exception err) {
+                            return new FailedPromise(err);
+                        }
+                    }
+                    [DebuggerStepThrough]
+                    public static IPromise<T> Run<T>(Func<IPromise<T>> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? Promise<T>.FromException(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return Promise<T>.FromException(err);
                         }
                     }
                 }
             }

Implab/SuccessPromise.cs +4 -16

             using System;
             namespace Implab {
                 public class SuccessPromise : IPromise {
                     #region IPromise implementation
                     public IPromise On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         if (success != null) {
                             try {
                                 success();
-                            } catch(Exception err) {
+                                // Analysis disable once EmptyGeneralCatchClause
-                                if (error != null) {
+                            } catch {
-                                    try {
-                                        error(err);
-                                    // Analysis disable once EmptyGeneralCatchClause
-                                    } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise On(Action success, Action<Exception> error) {
                         if (success != null) {
                             try {
                                 success();
-                            } catch(Exception err) {
+                                // Analysis disable once EmptyGeneralCatchClause
-                                if (error != null) {
+                            } catch {
-                                    try {
-                                        error(err);
-                                        // Analysis disable once EmptyGeneralCatchClause
-                                    } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise On(Action success) {
                         if (success != null) {
                             try {
                                 success();
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise On(Action handler, PromiseEventType events) {
                         if (handler != null && events.HasFlag(PromiseEventType.Success)) {
                             try {
                                 handler();
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> Cast<T>() {
                         throw new InvalidCastException();
                     }
                     public void Join() {
                     }
                     public void Join(int timeout) {
                     }
                     public Type PromiseType {
                         get {
                             return typeof(void);
                         }
                     }
                     public bool IsResolved {
                         get {
                             return true;
                         }
                     }
                     public bool IsCancelled {
                         get {
                             return false;
                         }
                     }
                     public Exception Error {
                         get {
                             return null;
                         }
                     }
                     #endregion
                     #region ICancellable implementation
                     public void Cancel() {
                     }
                     public void Cancel(Exception reason) {
                     }
                     #endregion
                 }
             }

Implab/SuccessPromiseT.cs +8 -32

             using System;
             namespace Implab {
                 public class SuccessPromise<T> : IPromise<T> {
                     readonly T m_value;
                     public SuccessPromise(T value){
                         m_value = value;
                     }
                     public IPromise<T> On(Action<T> success, Action<Exception> error, Action<Exception> cancel) {
                         if (success != null) {
                             try {
                                 success(m_value);
-                            } catch(Exception err) {
+                                // Analysis disable once EmptyGeneralCatchClause
-                                if (error != null) {
+                            } catch {
-                                    try {
-                                        error(err);
-                                        // Analysis disable once EmptyGeneralCatchClause
-                                    } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> On(Action<T> success, Action<Exception> error) {
                         if (success != null) {
                             try {
                                 success(m_value);
-                            } catch(Exception err) {
+                                // Analysis disable once EmptyGeneralCatchClause
-                                if (error != null) {
+                            } catch {
-                                    try {
-                                        error(err);
-                                        // Analysis disable once EmptyGeneralCatchClause
-                                    } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> On(Action<T> success) {
                         if (success != null) {
                             try {
                                 success(m_value);
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public T Join() {
                         return m_value;
                     }
                     public T Join(int timeout) {
                         return m_value;
                     }
                     public IPromise<T> On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         if (success != null) {
                             try {
                                 success();
-                            } catch(Exception err) {
+                                // Analysis disable once EmptyGeneralCatchClause
-                                if (error != null) {
+                            } catch {
-                                    try {
-                                        error(err);
-                                        // Analysis disable once EmptyGeneralCatchClause
-                                    } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> On(Action success, Action<Exception> error) {
                         if (success != null) {
                             try {
                                 success();
-                            } catch(Exception err) {
+                                // Analysis disable once EmptyGeneralCatchClause
-                                if (error != null) {
+                            } catch {
-                                    try {
-                                        error(err);
-                                        // Analysis disable once EmptyGeneralCatchClause
-                                    } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> On(Action success) {
                         if (success != null) {
                             try {
                                 success();
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> On(Action handler, PromiseEventType events) {
                         if (handler != null && events.HasFlag(PromiseEventType.Success)) {
                             try {
                                 handler();
                             // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     IPromise IPromise.On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         return On(success, error, cancel);
                     }
                     IPromise IPromise.On(Action success, Action<Exception> error) {
                         return On(success, error);
                     }
                     IPromise IPromise.On(Action success) {
                         return On(success);
                     }
                     IPromise IPromise.On(Action handler, PromiseEventType events) {
                         return On(handler, events);
                     }
                     public IPromise<T2> Cast<T2>() {
                         return new SuccessPromise<T2>((T2)(object)m_value);
                     }
                     void IPromise.Join() {
                     }
                     void IPromise.Join(int timeout) {
                     }
                     public Type PromiseType {
                         get {
                             return typeof(T);
                         }
                     }
                     public bool IsResolved {
                         get {
                             return true;
                         }
                     }
                     public bool IsCancelled {
                         get {
                             return false;
                         }
                     }
                     public Exception Error {
                         get {
                             return null;
                         }
                     }
                     public void Cancel() {
                     }
                     public void Cancel(Exception reason) {
                     }
                 }
             }

Implab/Components/PollingRunnableComponent.cs removed 0 -98

NO CONTENT: file was removed

General Comments 3

sergey

|

Auto status change to "Under Review"

sergey

|

ok, latest stable version should be in default

Write
Preview

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

	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