implab/ImplabNet Commit - r260:547a2fc0d93e

minor fixes

cin -

r260:547a2fc0d93e v3.0.6 v3

parent child

Context file:

r260:547a2fc0d93e

Collapse all files

Implab.Test/MockPollComponent.cs created 644 +35 0

@@ -0,0 +1,35
	1	using System;
	2	using System.Threading;
	3	using System.Threading.Tasks;
	4	using Implab.Components;
	5
	6	namespace Implab.Test {
	7	public class MockPollComponent : PollingComponent {
	8
	9	public Func<CancellationToken,Task> PollWorker { get; set;}
	10
	11	public Func<CancellationToken, Task> StartWorker { get; set; }
	12
	13	public Func<CancellationToken, Task> StopWorker { get; set; }
	14
	15	public MockPollComponent(bool initialized) : base(initialized) {
	16	}
	17
	18	protected async override Task Poll(CancellationToken ct) {
	19	if(PollWorker!= null)
	20	await PollWorker.Invoke(ct);
	21	}
	22
	23	protected async override Task StopInternalAsync(CancellationToken ct) {
	24	if (StopWorker != null)
	25	await StopWorker.Invoke(ct);
	26	}
	27
	28	protected async override Task StartInternalAsync(CancellationToken ct) {
	29	if (StartWorker != null)
	30	await StartWorker.Invoke(ct);
	31	}
	32
	33
	34	}
	35	} No newline at end of file

Implab.Playground/Implab.Playground.csproj +15 -64

@@ -1,69 +1,20
1	<?xml version="1.0" encoding="utf-8"?>	1	<Project Sdk="Microsoft.NET.Sdk">
2	<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">	2	<PropertyGroup Condition="'$(OSTYPE)'=='linux'">
3	<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />	3	<TargetFrameworks>netcoreapp2.0;net46</TargetFrameworks>
4	<PropertyGroup>	4	<FrameworkPathOverride Condition="'$(TargetFramework)'=='net46'">/usr/lib/mono/4.6-api/</FrameworkPathOverride>
5	<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
6	<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
7	<ProjectGuid>{100DFEB0-75BE-436F-ADDF-1F46EF433F46}</ProjectGuid>
8	<OutputType>Exe</OutputType>
9	<AppDesignerFolder>Properties</AppDesignerFolder>
10	<RootNamespace>Implab.Playground</RootNamespace>
11	<AssemblyName>Implab.Playground</AssemblyName>
12	<TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
13	<FileAlignment>512</FileAlignment>
14	<AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
15	<TargetFrameworkProfile />
16	</PropertyGroup>	5	</PropertyGroup>
17	<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Debug\|AnyCPU' ">	6
18	<PlatformTarget>AnyCPU</PlatformTarget>	7	<PropertyGroup Condition="'$(OSTYPE)'=='windows'">
19	<DebugSymbols>true</DebugSymbols>	8	<TargetFrameworks>netcoreapp2.0;net46</TargetFrameworks>
20	<DebugType>full</DebugType>
21	<Optimize>false</Optimize>
22	<OutputPath>bin\Debug\</OutputPath>
23	<DefineConstants>DEBUG;TRACE</DefineConstants>
24	<ErrorReport>prompt</ErrorReport>
25	<WarningLevel>4</WarningLevel>
26	</PropertyGroup>	9	</PropertyGroup>
27	<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Release\|AnyCPU' ">	10
28	<PlatformTarget>AnyCPU</PlatformTarget>	11	<PropertyGroup>
29	<DebugType>pdbonly</DebugType>	12	<OutputType>Exe</OutputType>
30	<Optimize>true</Optimize>	13	<IsPackable>false</IsPackable>
31	<OutputPath>bin\Release\</OutputPath>
32	<DefineConstants>TRACE</DefineConstants>
33	<ErrorReport>prompt</ErrorReport>
34	<WarningLevel>4</WarningLevel>
35	<Prefer32Bit>true</Prefer32Bit>
36	<DebugSymbols>true</DebugSymbols>
37	</PropertyGroup>	14	</PropertyGroup>
38	<ItemGroup>	15
39	<Reference Include="System" />
40	<Reference Include="System.Core" />
41	<Reference Include="System.Xml.Linq" />
42	<Reference Include="System.Data.DataSetExtensions" />
43	<Reference Include="Microsoft.CSharp" />
44	<Reference Include="System.Data" />
45	<Reference Include="System.Net.Http" />
46	<Reference Include="System.Xml" />
47	</ItemGroup>
48	<ItemGroup>	16	<ItemGroup>
49	<Compile Include="Program.cs" />	17	<ProjectReference Include="../Implab/Implab.csproj"/>
50	<Compile Include="Properties\AssemblyInfo.cs" />
51	</ItemGroup>
52	<ItemGroup>
53	<None Include="App.config" />
54	</ItemGroup>	18	</ItemGroup>
55	<ItemGroup>	19
56	<ProjectReference Include="..\Implab\Implab.csproj">	20	</Project>
57	<Project>{f550f1f8-8746-4ad0-9614-855f4c4b7f05}</Project>
58	<Name>Implab</Name>
59	</ProjectReference>
60	</ItemGroup>
61	<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
62	<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
63	Other similar extension points exist, see Microsoft.Common.targets.
64	<Target Name="BeforeBuild">
65	</Target>
66	<Target Name="AfterBuild">
67	</Target>
68	-->
69	</Project> No newline at end of file

Implab.Playground/Program.cs 0 -1

             using Implab.Diagnostics;
             using Implab.Formats.Json;
             using Implab.Parallels;
             using Implab.Xml;
             using System;
             using System.Collections.Concurrent;
             using System.Collections.Generic;
             using System.IO;
             using System.Linq;
             using System.Text;
             using System.Threading;
             using System.Threading.Tasks;
             using System.Xml;
             using System.Xml.Serialization;
             namespace Implab.Playground {
                 using System.Diagnostics;
-                using System.Runtime.Remoting.Messaging;
                 using static Trace<Program>;
                 public class Program {
                     static void Main(string[] args) {
                         var listener = new SimpleTraceListener(Console.Out);
                         var source = Trace<Program>.TraceSource;
                         source.Switch.Level = SourceLevels.All;
                         source.Listeners.Add(listener);
                         var t = Environment.TickCount;
                         Main().Wait();
                         Console.WriteLine($"Done: {Environment.TickCount - t} ms");
                         Console.ReadKey();
                     }
                     static async Task Main() {
                         using (LogicalOperation(nameof(Main))) {
                             Log("Start");
                             await SomeAsync();
                             Log("End");
                         }
                     }
                     static async Task SomeAsync() {
                         using (LogicalOperation(nameof(SomeAsync))) {
                             Log("Do prepare");
                             await Task.Yield();
                             Log("Yield");
                         }
                     }
                 }
             }

Implab.Test/Implab.Test.csproj +9 -3

             <Project Sdk="Microsoft.NET.Sdk">
+              <PropertyGroup Condition="'$(OSTYPE)'=='linux'">
+                <TargetFrameworks>netcoreapp2.0</TargetFrameworks>
+                <FrameworkPathOverride Condition="'$(TargetFramework)'=='net46'">/usr/lib/mono/4.5/</FrameworkPathOverride>
+              </PropertyGroup>
+              <PropertyGroup Condition="'$(OSTYPE)'=='windows'">
+                <TargetFrameworks>netcoreapp2.0;net46</TargetFrameworks>
+              </PropertyGroup>
               <PropertyGroup>
-                <TargetFramework>netcoreapp2.1</TargetFramework>
                 <IsPackable>false</IsPackable>
               </PropertyGroup>
               <ItemGroup>
                 <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.6.0-preview-20180109-01" />
                 <PackageReference Include="xunit" Version="2.3.1" />
                 <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
                 <ProjectReference Include="../Implab/Implab.csproj"/>
                 <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.1" />
               </ItemGroup>
             </Project>

Implab.Test/RunnableComponentTests.cs +14 -26

@@ -1,42 +1,30
1	using System;	1	using System;
2	using System.Threading;	2	using System.Threading;
3	using System.Threading.Tasks;	3	using System.Threading.Tasks;
4	using Implab.Components;	4	using Implab.Components;
5	using Xunit;	5	using Xunit;
6		6
7	namespace Implab.Test	7	namespace Implab.Test {
8	{
9	class TimeLog : PollingComponent {
10	public TimeLog() : base(true) {
11	}
12		8
13	protected override Task Poll(CancellationToken ct) {	9	public class RunnableComponentTests {
14	Console.WriteLine("Poll");
15	return Task.CompletedTask;
16	}
17	}
18
19	public class UnitTest1
20	{
21	[Fact]	10	[Fact]
22	public async Task Test1()	11	public async Task Test1() {
23	{
24		12
25	using(var tl = new ~~TimeLog~~()) {	13	using (var m = new MockPollComponent(true)) {
26	tl.StateChanged += (self, args) => Console.WriteLine("{0}", args.State);	14	m.StartWorker = async (ct) => await Task.Yield();
27	tl.Delay = 1000;	15	m.StopWorker = async (ct) => await Task.Yield();
28	tl.Interval = 500;
29		16
		17	Assert.Equal(ExecutionState.Ready, m.State);
		18	Assert.NotNull(m.Completion);
30		19
31	tl.Start(CancellationToken.None);	20	m.Start(CancellationToken.None);
32	await tl.Completion;	21	await m.Completion;
		22	Assert.Equal(ExecutionState.Running, m.State);
33		23
34	await Task.Delay(2000);	24	m.Stop(CancellationToken.None);
35		25	await m.Completion;
36	tl.Stop(CancellationToken.None);	26	Assert.Equal(ExecutionState.Stopped, m.State);
37	await tl.Completion;
38	await Task.Delay(3000);
39	}	27	}
40	}	28	}
41	}	29	}
42	}	30	}

Implab/Components/PollingComponent.cs +6 -2

             using System;
             using System.Threading;
             using System.Threading.Tasks;
             namespace Implab.Components {
                 public abstract class PollingComponent : RunnableComponent {
                     readonly Timer m_timer;
                     readonly CancellationTokenSource m_cancellation = new CancellationTokenSource();
                     Task m_pending;
                     Task m_poll;
                     /// <summary>
                     /// Poll interval in milliseconds.
                     /// </summary>
                     /// <returns></returns>
                     public int Interval { get; set; }
                     /// <summary>
                     /// Delay to the first poll after start in milliseconds
                     /// </summary>
                     /// <returns></returns>
                     public int Delay { get; set; }
                     /// <summary>
                     /// Indicates how to handle unhandled exceptions in <see cref="Poll()"/> method.
                     /// </summary>
                     /// <returns></returns>
                     public bool FailOnError { get; set; }
                     /// <summary>
                     /// Event for the unhandled exceptions in <see cref="Poll()"/> method.
                     /// </summary>
                     public event EventHandler<UnhandledExceptionEventArgs> UnhandledException;
                     protected PollingComponent(bool initialized) : base(initialized) {
                         m_timer = new Timer(OnTimer);
                     }
                     protected override void RunInternal() {
                         ScheduleNextPoll(Delay);
                     }
                     protected override async Task StopInternalAsync(CancellationToken ct) {
                         // component in Stopping state, no new polls will be scheduled
                         m_cancellation.Cancel();
                         try {
                             // await for pending poll
                             await m_poll;
-                        } catch (OperationCanceledException e) {
+                        } catch (OperationCanceledException) {
                             // OK
                         }
                     }
                     protected abstract Task Poll(CancellationToken ct);
                     void ScheduleNextPoll(int timeout) {
                         lock (SynchronizationObject) {
                             if (State == ExecutionState.Running) {
                                 m_pending = Safe.CreateTask(m_cancellation.Token);
                                 m_poll = m_pending.Then(() => Poll(m_cancellation.Token));
                                 m_timer.Change(timeout, Timeout.Infinite);
                             }
                         }
                     }
                     async void OnTimer(object state) {
                         try {
                             m_pending.Start();
                             await m_poll;
+                            ScheduleNextPoll(Interval);
                         } catch (Exception e) {
                             UnhandledException.DispatchEvent(this, new UnhandledExceptionEventArgs(e, false));
                             if (FailOnError)
                                 Fail(e);
+                            else
+                                ScheduleNextPoll(Interval);
                         }
-                        ScheduleNextPoll(Interval);
                     }
                     protected override void Dispose(bool disposing) {
                         if (disposing)
                             Safe.Dispose(m_timer, m_cancellation);
                         base.Dispose(disposing);
                     }
                 }
             }

Implab/Components/RunnableComponent.cs +1 0

             using System;
             using System.Diagnostics;
             using System.Threading;
             using System.Threading.Tasks;
             namespace Implab.Components {
                 /// <summary>
                 /// Base class for implementing components which support start and stop operations,
                 /// such components may represent running services.
                 /// </summary>
                 /// <remarks>
                 /// This class provides a basic lifecycle from the creation to the
                 /// termination of the component.
                 /// </remarks>
                 public abstract class RunnableComponent : IAsyncComponent, IRunnable, IInitializable, IDisposable {
                     /// <summary>
                     /// This class bounds <see cref="CancellationTokenSource"/> lifetime to the task,
                     /// when the task completes the associated token source will be disposed.
                     /// </summary>
                     class AsyncOperationDescriptor {
                         public static AsyncOperationDescriptor None { get; } = new AsyncOperationDescriptor();
                         readonly CancellationTokenSource m_cts;
                         bool m_done;
                         public CancellationToken Token {
                             get { return m_cts == null ? CancellationToken.None : m_cts.Token; }
                         }
                         public Task Task { get; private set; }
                         private AsyncOperationDescriptor(Task task, CancellationTokenSource cts) {
                             m_cts = cts;
                             Task = Chain(task);
                         }
                         private AsyncOperationDescriptor() {
                             Task = Task.CompletedTask;
                         }
                         public void Cancel() {
                             if (m_cts != null) {
                                 lock (m_cts) {
                                     if (!m_done)
                                         m_cts.Cancel();
                                 }
                             }
                         }
                         void Done() {
                             if (m_cts != null) {
                                 lock (m_cts) {
                                     m_done = true;
                                     m_cts.Dispose();
                                 }
                             } else {
                                 m_done = true;
                             }
                         }
                         async Task Chain(Task other) {
                             try {
                                 await other;
                             } finally {
                                 Done();
                             }
                         }
                         public static AsyncOperationDescriptor Create(Func<CancellationToken, Task> factory, CancellationToken ct) {
                             var cts = ct.CanBeCanceled ?
                                 CancellationTokenSource.CreateLinkedTokenSource(ct) :
                                 new CancellationTokenSource();
                             return new AsyncOperationDescriptor(factory(cts.Token), cts);
                         }
                     }
                     // this lock is used to synchronize state flow of the component during
                     // processing calls from a client and internal processes.
                     readonly object m_lock = new object();
                     // current operation cookie, used to check wheather a call to
                     // MoveSuccess/MoveFailed method belongs to the current
                     // operation, if cookies didn't match ignore completion result.
                     object m_cookie;
                     // AsyncOperationDscriptor aggregates a task and it's cancellation token
                     AsyncOperationDescriptor m_current = AsyncOperationDescriptor.None;
                     ExecutionState m_state;
                     /// <summary>
                     /// Объект синхронизации используется для обеспечения совместного доступа
                     /// клиента компоненты и процессов, протекающих внутри компоненты, к общему
                     /// состоянию, т.е.true таким свойствам, как <see cref="State"/>,
                     /// <see cref="LastError"/>. Обработчики события <see cref="StateChanged"/>
                     /// вызываются уже с установленной блокировкой, поэтому дополнительная
                     /// синхронизация не требуется.
                     /// </summary>
                     public object SynchronizationObject { get { return m_lock; } }
                     protected RunnableComponent(bool initialized) {
                         State = initialized ? ExecutionState.Ready : ExecutionState.Created;
                     }
                     public Task Completion {
                         get { return m_current.Task; }
                     }
                     public ExecutionState State {
                         get { return m_state; }
                         private set {
                             if (m_state != value) {
                                 m_state = value;
                                 StateChanged.DispatchEvent(this, new StateChangeEventArgs {
                                     State = value,
                                     LastError = LastError
                                 });
                             }
                         }
                     }
                     public Exception LastError { get; private set; }
                     /// <summary>
                     /// Событие изменения состояния компоненты.see Обработчики данного события
                     /// вызываются внутри блокировки <see cref="SynchronizationObject"/> и должны
                     /// выполняться максимально быстро.
                     /// </summary>
                     public event EventHandler<StateChangeEventArgs> StateChanged;
                     /// <summary>
                     /// Releases all resources used by the current component regardless of its
                     /// execution state.
                     /// </summary>
                     /// <remarks>
                     /// Calling to this method may result unexpedted results if the component
                     /// isn't in the stopped state. Call this method after the component is
                     /// stopped if needed or if the component is in the failed state.
                     /// </remarks>
                     public void Dispose() {
                         bool dispose = false;
                         lock (SynchronizationObject) {
                             if (m_state != ExecutionState.Disposed) {
                                 dispose = true;
                                 m_state = ExecutionState.Disposed;
                                 m_cookie = new object();
                             }
                         }
                         if (dispose) {
                             Dispose(true);
                             GC.SuppressFinalize(this);
                         }
                     }
                     ~RunnableComponent() {
                         Dispose(false);
                     }
                     /// <summary>
                     /// Releases all resources used by the current component regardless of its
                     /// execution state.
                     /// </summary>
                     /// <param name="disposing">Indicates that the component is disposed
                     /// during a normal disposing or during GC.</param>
                     protected virtual void Dispose(bool disposing) {
                     }
                     public void Initialize() {
                         var cookie = new object();
                         if (MoveInitialize(cookie))
                             Safe.NoWait(ScheduleTask(InitializeInternalAsync, CancellationToken.None, cookie));
                         else
                             throw new InvalidOperationException();
                     }
                     /// <summary>
                     /// This method is used for initialization during a component creation.
                     /// </summary>
                     /// <param name="ct">A cancellation token for this operation</param>
                     /// <remarks>
                     /// This method should be used for short and mostly syncronous operations,
                     /// other operations which require time to run shoud be placed in
                     /// <see cref="StartInternalAsync(CancellationToken)"/> method.
                     /// </remarks>
                     protected virtual Task InitializeInternalAsync(CancellationToken ct) {
                         return Task.CompletedTask;
                     }
                     public void Start(CancellationToken ct) {
                         var cookie = new object();
                         if (MoveStart(cookie))
                             Safe.NoWait(ScheduleStartAndRun(ct, cookie));
                         else
                             throw new InvalidOperationException();
                     }
                     async Task ScheduleStartAndRun(CancellationToken ct, object cookie) {
                         try {
                             await ScheduleTask(StartInternalAsync, ct, cookie);
                             RunInternal();
                         } catch (Exception err) {
                             Fail(err);
                         }
                     }
                     protected virtual Task StartInternalAsync(CancellationToken ct) {
                         return Task.CompletedTask;
                     }
                     /// <summary>
                     /// This method is called after the component is enetered running state,
                     /// use this method to
                     /// </summary>
                     protected virtual void RunInternal() {
                     }
                     public void Stop(CancellationToken ct) {
                         var cookie = new object();
                         if (MoveStop(cookie))
                             Safe.NoWait(ScheduleTask(StopAsync, ct, cookie));
                         else
                             throw new InvalidOperationException();
                     }
                     async Task StopAsync(CancellationToken ct) {
                         m_current.Cancel();
                         await Completion;
                         ct.ThrowIfCancellationRequested();
                         await StopInternalAsync(ct);
                     }
                     protected virtual Task StopInternalAsync(CancellationToken ct) {
                         return Task.CompletedTask;
                     }
                     protected void Fail(Exception err) {
                         lock(m_lock) {
                             if (m_state != ExecutionState.Running)
                                 return;
                             m_cookie = new object();
                             LastError = err;
                             State = ExecutionState.Failed;
                         }
                     }
                     #region state management
                     bool MoveInitialize(object cookie) {
                         lock (m_lock) {
                             if (State != ExecutionState.Created)
                                 return false;
                             State = ExecutionState.Initializing;
                             m_cookie = cookie;
                             return true;
                         }
                     }
                     bool MoveStart(object cookie) {
                         lock (m_lock) {
                             if (State != ExecutionState.Ready)
                                 return false;
                             State = ExecutionState.Starting;
                             m_cookie = cookie;
                             return true;
                         }
                     }
                     bool MoveStop(object cookie) {
                         lock (m_lock) {
                             if (State != ExecutionState.Starting && State != ExecutionState.Running)
                                 return false;
                             State = ExecutionState.Stopping;
                             m_cookie = cookie;
                             return true;
                         }
                     }
                     void MoveSuccess(object cookie) {
                         lock (m_lock) {
                             if (m_cookie != cookie)
                                 return;
                             switch (State) {
                                 case ExecutionState.Initializing:
                                     State = ExecutionState.Ready;
                                     break;
                                 case ExecutionState.Starting:
                                     State = ExecutionState.Running;
                                     break;
                                 case ExecutionState.Stopping:
                                     State = ExecutionState.Stopped;
                                     break;
                             }
                         }
                     }
                     void MoveFailed(Exception err, object cookie) {
                         lock (m_lock) {
                             if (m_cookie != cookie)
                                 return;
                             LastError = err;
                             State = ExecutionState.Failed;
                         }
                     }
                     Task ScheduleTask(Func<CancellationToken, Task> next, CancellationToken ct, object cookie) {
                         var op = AsyncOperationDescriptor.Create(async (x) => {
                             try {
                                 await next(x);
                                 MoveSuccess(cookie);
                             } catch (Exception e) {
                                 MoveFailed(e, cookie);
+                                throw;
                             }
                         }, ct);
                         m_current = op;
                         return op.Task;
                     }
                     #endregion
                 }
             }

Implab/Deferred.cs +1 -1

             using System;
             using System.Diagnostics;
             using System.Threading.Tasks;
             namespace Implab {
                 /// <summary>
                 /// This class is responsible for the promise resolution, dispatching and chaining
                 /// </summary>
                 public class Deferred : IResolvable {
                     readonly Promise m_promise;
                     internal Deferred() {
                         m_promise = new Promise();
                     }
-                    internal Deferred(Promise promise, IDispatcher dispatcher) {
+                    internal Deferred(Promise promise) {
                         Debug.Assert(promise != null);
                         m_promise = promise;
                     }
                     public IPromise Promise {
                         get { return m_promise; }
                     }
                     public void Cancel() {
                         Reject(new OperationCanceledException());
                     }
                     public virtual void Reject(Exception error) {
                         if (error is PromiseTransientException)
                             error = ((PromiseTransientException)error).InnerException;
                         m_promise.RejectPromise(error);
                     }
                     public virtual void Resolve() {
                         m_promise.ResolvePromise();
                     }
                     public virtual void Resolve(IPromise thenable) {
                         if (thenable == null)
                             Reject(new Exception("The promise or task are expected"));
                         if (thenable == m_promise)
                             Reject(new Exception("The promise cannot be resolved with oneself"));
                         try {
                             thenable.Then(this);
                         } catch (Exception err) {
                             Reject(err);
                         }
                     }
                     public virtual void Resolve(Task thenable) {
                         if (thenable == null)
                             Reject(new Exception("The promise or task are expected"));
                         try {
                             thenable.Then(this);
                         } catch(Exception err) {
                             Reject(err);
                         }
                     }
                 }
             }

Implab/Implab.csproj +5 -2

             <Project Sdk="Microsoft.NET.Sdk">
               <PropertyGroup>
                 <Authors>Sergey Smirnov</Authors>
                 <Title>Implab library</Title>
                 <Description>Provides some helper clesses like XML serialization helpers, JSON XML reader,
                 JSON pull-parser, ECMA-style promises, lightweight synchonization routines Signal
                 and SharedLock, Trace helpers on top of System.Diagnostics, ObjectPool etc.
                 </Description>
                 <Copyright>2012-2018 Sergey Smirnov</Copyright>
-                <LicenseUrl>https://opensource.org/licenses/BSD-2-Clause</LicenseUrl>
+                <Version>3.0.6</Version>
-                <ProjectUrl>https://implab.org</ProjectUrl>
+                <PackageLicenseUrl>https://opensource.org/licenses/BSD-2-Clause</PackageLicenseUrl>
+                <PackageProjectUrl>https://implab.org</PackageProjectUrl>
                 <RepositoryUrl>https://hg.implab.org/pub/ImplabNet/</RepositoryUrl>
+                <RepositoryType>mercurial</RepositoryType>
+                <PackageTags>IMPLAB;Json pull-parser;Json Xml;async;diagnostics;serialization;</PackageTags>
                 <TargetFrameworks>netstandard2.0;net46</TargetFrameworks>
                 <FrameworkPathOverride Condition="'$(TargetFramework)'=='net46' and '$(OSTYPE)'=='linux'">/usr/lib/mono/4.5/</FrameworkPathOverride>
                 <DefineConstants Condition="'$(TargetFramework)'=='net46'">NETFX_TRACE_BUG;$(DefineConstants)</DefineConstants>
               </PropertyGroup>
             </Project>

Implab/Promise.cs +25 -11

             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Reflection;
+            using System.Threading;
             using System.Threading.Tasks;
             using Implab.Parallels;
             namespace Implab {
                 public class Promise : AbstractEvent<IResolvable>, IPromise {
                     public static IDispatcher DefaultDispatcher {
                         get {
                             return ThreadPoolDispatcher.Instance;
                         }
                     }
                     class ResolvableSignal : IResolvable {
                         public Signal Signal { get; private set; }
                         public ResolvableSignal() {
                             Signal = new Signal();
                         }
                         public void Reject(Exception error) {
                             Signal.Set();
                         }
                         public void Resolve() {
                             Signal.Set();
                         }
                     }
                     PromiseState m_state;
                     Exception m_error;
                     public bool IsRejected {
                         get {
                             return m_state == PromiseState.Rejected;
                         }
                     }
                     public bool IsFulfilled {
                         get {
                             return m_state == PromiseState.Fulfilled;
                         }
                     }
                     public Exception RejectReason {
                         get {
                             return m_error;
                         }
                     }
                     internal Promise() {
                     }
                     internal void ResolvePromise() {
                         if (BeginTransit()) {
                             m_state = PromiseState.Fulfilled;
                             CompleteTransit();
                         }
                     }
                     internal void RejectPromise(Exception reason) {
                         if (BeginTransit()) {
                             m_error = reason;
                             m_state = PromiseState.Rejected;
                             CompleteTransit();
                         }
                     }
                     #region implemented abstract members of AbstractPromise
                     protected override void SignalHandler(IResolvable handler) {
                         switch (m_state) {
                             case PromiseState.Fulfilled:
                                 handler.Resolve();
                                 break;
                             case PromiseState.Rejected:
                                 handler.Reject(RejectReason);
                                 break;
                             default:
                                 throw new InvalidOperationException(String.Format("Invalid promise signal: {0}", m_state));
                         }
                     }
                     protected void WaitResult(int timeout) {
                         if (!(IsResolved || GetFulfillSignal().Wait(timeout)))
                             throw new TimeoutException();
                     }
                     protected Signal GetFulfillSignal() {
                         var next = new ResolvableSignal();
                         Then(next);
                         return next.Signal;
                     }
                     #endregion
                     public Type ResultType {
                         get {
                             return typeof(void);
                         }
                     }
                     protected void Rethrow() {
                         Debug.Assert(m_error != null);
                         if (m_error is OperationCanceledException)
                             throw new OperationCanceledException("Operation cancelled", m_error);
                         else
                             throw new TargetInvocationException(m_error);
                     }
                     public void Then(IResolvable next) {
                         AddHandler(next);
                     }
                     public IPromise<T> Cast<T>() {
                         throw new InvalidCastException();
                     }
                     public void Join() {
                         WaitResult(-1);
                         if (IsRejected)
                             Rethrow();
                     }
                     public void Join(int timeout) {
                         WaitResult(timeout);
                         if (IsRejected)
                             Rethrow();
                     }
                     public static ResolvedPromise Resolve() {
                         return new ResolvedPromise();
                     }
                     public static ResolvedPromise<T> Resolve<T>(T result) {
                         return new ResolvedPromise<T>(result);
                     }
                     public static RejectedPromise Reject(Exception reason) {
                         return new RejectedPromise(reason);
                     }
                     public static RejectedPromise<T> Reject<T>(Exception reason) {
                         return new RejectedPromise<T>(reason);
                     }
                     public static IPromise Create(PromiseExecutor executor) {
-                        Safe.ArgumentNotNull(executor, nameof(executor));
+                        return Create(executor, CancellationToken.None);
+                    }
-                        var p = new Promise();
+                    public static IPromise Create(PromiseExecutor executor, CancellationToken ct) {
-                        var d = new Deferred(p, DefaultDispatcher);
+                        Safe.ArgumentNotNull(executor, nameof(executor));
+                        if (!ct.CanBeCanceled)
+                            return Create(executor);
+                        var d = new Deferred();
+                        ct.Register(d.Cancel);
                         try {
-                            executor(d);
+                            if (!ct.IsCancellationRequested)
-                        } catch (Exception e) {
+                                executor(d);
+                        } catch(Exception e) {
                             d.Reject(e);
                         }
                         return d.Promise;
                     }
                     public static IPromise<T> Create<T>(PromiseExecutor<T> executor) {
+                        return Create(executor, CancellationToken.None);
+                    }
+                    public static IPromise<T> Create<T>(PromiseExecutor<T> executor, CancellationToken ct) {
                         Safe.ArgumentNotNull(executor, nameof(executor));
                         var d = new Deferred<T>();
+                        ct.Register(d.Cancel);
                         try {
-                            executor(d);
+                            if (!ct.IsCancellationRequested)
-                        } catch (Exception e) {
+                                executor(d);
+                        } catch(Exception e) {
                             d.Reject(e);
                         }
                         return d.Promise;
                     }
                     public static IPromise All(IEnumerable<IPromise> promises) {
                         var d = new Deferred();
                         var all = new PromiseAll(d);
                         foreach (var promise in promises) {
                             all.AddPromise(promise);
                             if (all.Done)
                                 break;
                         }
                         all.Complete();
                         return all.ResultPromise;
                     }
                     public static IPromise<T[]> All<T>(IEnumerable<IPromise<T>> promises, Func<T, IPromise> cleanup = null, Action cancel = null) {
                         var d = new Deferred<T[]>();
                         var all = new PromiseAll<T>(d, cleanup, cancel);
                         foreach (var promise in promises) {
                             all.AddPromise(promise);
                             if (all.Done)
                                 break;
                         }
                         all.Complete();
                         return all.ResultPromise;
                     }
                 }
             }

Implab.Playground/Properties/AssemblyInfo.cs removed 0 -36

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