implab/ImplabNet Commit - r259:7d52dc684bbd

PollingComponent: implemented correct stopping

cin -

r259:7d52dc684bbd v3

parent child

Context file:

r259:7d52dc684bbd

Collapse all files

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

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

Implab.Test/Implab.Test.csproj +4 -4

             <Project Sdk="Microsoft.NET.Sdk">
               <PropertyGroup>
-                <TargetFramework>net46</TargetFramework>
+                <TargetFramework>netcoreapp2.1</TargetFramework>
-                <FrameworkPathOverride Condition="'$(TargetFramework)'=='net46' and '$(OSTYPE)'=='linux'">/usr/lib/mono/4.5/</FrameworkPathOverride>
                 <IsPackable>false</IsPackable>
               </PropertyGroup>
               <ItemGroup>
-                <ProjectReference Include="../Implab/Implab.csproj" />
+                <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.6.0-preview-20180109-01" />
-                <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
                 <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/Components/PollingComponent.cs +20 -4

             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);
                     }
-                    //TODO override stop
+                    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) {
+                            // OK
+                        }
+                    }
                     protected abstract Task Poll(CancellationToken ct);
                     void ScheduleNextPoll(int timeout) {
                         lock (SynchronizationObject) {
-                            if (State == ExecutionState.Running)
+                            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);
+                            }
                         }
                     }
-                    void OnTimer(object state) {
+                    async void OnTimer(object state) {
                         try {
-                            Poll(m_cancellation.Token);
+                            m_pending.Start();
+                            await m_poll;
                         } catch (Exception e) {
                             UnhandledException.DispatchEvent(this, new UnhandledExceptionEventArgs(e, false));
                             if (FailOnError)
                                 Fail(e);
                         }
                         ScheduleNextPoll(Interval);
                     }
                     protected override void Dispose(bool disposing) {
                         if (disposing)
                             Safe.Dispose(m_timer, m_cancellation);
                         base.Dispose(disposing);
                     }
                 }
             }

Implab/PromiseExtensions.cs +9 0

             using System.Threading;
             using System;
             using Implab.Diagnostics;
             using System.Collections.Generic;
             using System.Linq;
             namespace Implab {
                 public static class PromiseExtensions {
                     public static IPromise Then(this IPromise that, Action fulfilled, Action<Exception> rejected) {
                         var reaction = PromiseActionReaction.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise Then(this IPromise that, Action fulfilled) {
                         var reaction = PromiseActionReaction.Create(fulfilled, null, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise Then(this IPromise that, Action fulfilled, Func<Exception, IPromise> rejected) {
                         var reaction = PromiseActionReaction.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise Then(this IPromise that, Func<IPromise> fulfilled, Action<Exception> rejected) {
                         var reaction = PromiseActionReaction.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise Then(this IPromise that, Func<IPromise> fulfilled) {
                         var reaction = PromiseActionReaction.Create(fulfilled, null, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise Then(this IPromise that, Func<IPromise> fulfilled, Func<Exception, IPromise> rejected) {
                         var reaction = PromiseActionReaction.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise Then<T>(this IPromise<T> that, Action<T> fulfilled, Action<Exception> rejected) {
                         var reaction = PromiseActionReaction<T>.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise Then<T>(this IPromise<T> that, Action<T> fulfilled) {
                         var reaction = PromiseActionReaction<T>.Create(fulfilled, null, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise Then<T>(this IPromise<T> that, Action<T> fulfilled, Func<Exception, IPromise> rejected) {
                         var reaction = PromiseActionReaction<T>.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise Then<T>(this IPromise<T> that, Func<T, IPromise> fulfilled, Action<Exception> rejected) {
                         var reaction = PromiseActionReaction<T>.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise Then<T>(this IPromise<T> that, Func<T, IPromise> fulfilled) {
                         var reaction = PromiseActionReaction<T>.Create(fulfilled, null, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise Then<T>(this IPromise<T> that, Func<T, IPromise> fulfilled, Func<Exception, IPromise> rejected) {
                         var reaction = PromiseActionReaction<T>.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise<Tout> Then<Tout>(this IPromise that, Func<Tout> fulfilled, Func<Exception, Tout> rejected) {
                         var reaction = PromiseFuncReaction<Tout>.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise<Tout> Then<Tout>(this IPromise that, Func<Tout> fulfilled) {
                         var reaction = PromiseFuncReaction<Tout>.Create(fulfilled, (Func<Exception, Tout>)null, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise<Tout> Then<Tout>(this IPromise that, Func<Tout> fulfilled, Func<Exception, IPromise<Tout>> rejected) {
                         var reaction = PromiseFuncReaction<Tout>.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise<Tout> Then<Tout>(this IPromise that, Func<IPromise<Tout>> fulfilled, Func<Exception, Tout> rejected) {
                         var reaction = PromiseFuncReaction<Tout>.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise<Tout> Then<Tout>(this IPromise that, Func<IPromise<Tout>> fulfilled) {
                         var reaction = PromiseFuncReaction<Tout>.Create(fulfilled, (Func<Exception, Tout>)null, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise<Tout> Then<Tout>(this IPromise that, Func<IPromise<Tout>> fulfilled, Func<Exception, IPromise<Tout>> rejected) {
                         var reaction = PromiseFuncReaction<Tout>.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise<Tout> Then<Tin, Tout>(this IPromise<Tin> that, Func<Tin, Tout> fulfilled, Func<Exception, Tout> rejected) {
                         var reaction = PromiseFuncReaction<Tin, Tout>.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise<Tout> Then<Tin, Tout>(this IPromise<Tin> that, Func<Tin, Tout> fulfilled) {
                         var reaction = PromiseFuncReaction<Tin, Tout>.Create(fulfilled, (Func<Exception, Tout>)null, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise<Tout> Then<Tin, Tout>(this IPromise<Tin> that, Func<Tin, Tout> fulfilled, Func<Exception, IPromise<Tout>> rejected) {
                         var reaction = PromiseFuncReaction<Tin, Tout>.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise<Tout> Then<Tin, Tout>(this IPromise<Tin> that, Func<Tin, IPromise<Tout>> fulfilled, Func<Exception, Tout> rejected) {
                         var reaction = PromiseFuncReaction<Tin, Tout>.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise<Tout> Then<Tin, Tout>(this IPromise<Tin> that, Func<Tin, IPromise<Tout>> fulfilled) {
                         var reaction = PromiseFuncReaction<Tin, Tout>.Create(fulfilled, (Func<Exception, Tout>)null, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise<Tout> Then<Tin, Tout>(this IPromise<Tin> that, Func<Tin, IPromise<Tout>> fulfilled, Func<Exception, IPromise<Tout>> rejected) {
                         var reaction = PromiseFuncReaction<Tin, Tout>.Create(fulfilled, rejected, Promise.DefaultDispatcher);
                         that.Then(reaction);
                         return reaction.Promise;
                     }
                     public static IPromise Catch(this IPromise that, Action<Exception> rejected) {
                         return Then(that, null, rejected);
                     }
                     public static IPromise Catch(this IPromise that, Func<Exception, IPromise> rejected) {
                         return Then(that, null, rejected);
                     }
                     public static IPromise<Tout> Catch<Tout>(this IPromise that, Func<Exception, Tout> rejected) {
                         return Then(that, (Func<Tout>)null, rejected);
                     }
                     public static IPromise<Tout> Catch<Tout>(this IPromise that, Func<Exception, IPromise<Tout>> rejected) {
                         return Then(that, (Func<Tout>)null, rejected);
                     }
                     public static IPromise<Tout> Catch<Tin, Tout>(this IPromise<Tin> that, Func<Exception, Tout> rejected) {
                         return Then(that, (Func<Tin, Tout>)null, rejected);
                     }
                     public static IPromise<Tout> Catch<Tin, Tout>(this IPromise<Tin> that, Func<Exception, IPromise<Tout>> rejected) {
                         return Then(that, (Func<Tin, Tout>)null, rejected);
                     }
                     public static IPromise Finally(this IPromise that, Action final) {
                         return Then(that, final, e => {
                             final();
                             throw e.Rethrow();
                         });
                     }
                     public static IPromise Finally(this IPromise that, Func<IPromise> final) {
                         return Then(that, final, e => {
                             final();
                             throw e.Rethrow();
                         });
                     }
                     public static IPromise<T> Finally<T>(this IPromise<T> that, Action final) {
                         return Then<T, T>(that, x => {
                             final();
                             return x;
                         }, new Func<Exception, T>(e => {
                             final();
                             throw e.Rethrow();
                         }));
                     }
                     public static IPromise<T> Finally<T>(this IPromise<T> that, Func<IPromise> final) {
                         return Then<T, T>(that, x => {
                             return final()
                                 .Then(() => x);
                         }, new Func<Exception, IPromise<T>>(e => {
                             return final()
                                 .Then(new Func<T>(() => {
                                     throw e.Rethrow();
                                 }));
                         }));
                     }
+                    public static PromiseAwaiter GetAwaiter(this IPromise that) {
+                        Safe.ArgumentNotNull(that, nameof(that));
+                        return new PromiseAwaiter(that);
+                    }
+                    public static PromiseAwaiter<T> GetAwaiter<T>(this IPromise<T> that) {
+                        Safe.ArgumentNotNull(that, nameof(that));
+                        return new PromiseAwaiter<T>(that);
+                    }
                 }
             }

Implab/Safe.cs +16 -5

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Text.RegularExpressions;
             using System.Diagnostics;
             using System.Collections;
             using System.Runtime.CompilerServices;
             using System.Threading.Tasks;
+            using System.Threading;
             #if NET_4_5
             using System.Threading.Tasks;
             #endif
             namespace Implab
             {
                 public static class Safe
                 {
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentAssert(bool condition, string paramName) {
                         if (!condition)
                             throw new ArgumentException("The parameter is invalid", paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     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);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentNotEmpty(string value, string paramName) {
                         if (String.IsNullOrEmpty(value))
                             throw new ArgumentException("The parameter can't be empty", paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     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);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentNotNull(object value, string paramName) {
                         if (value == null)
                             throw new ArgumentNullException(paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     internal static void ArgumentGreaterEqThan(int value, int min, string paramName) {
                         if (value < min)
                             throw new ArgumentOutOfRangeException(paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentInRange(bool condition, string paramName) {
                         if (!condition)
                             throw new ArgumentOutOfRangeException(paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     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 DisposeCollection(IEnumerable<IDisposable> objects) {
                         foreach (var d in objects)
                             Dispose(d);
                     }
                     public static void DisposeCollection(IEnumerable objects) {
                         foreach (var d in objects)
                             Dispose(d);
                     }
                     public static void Dispose(object obj) {
                         if (obj is IDisposable)
                             Dispose((IDisposable)obj);
                     }
                     [DebuggerStepThrough]
                     public static void DispatchEvent<T>(this EventHandler<T> handler, object sender, T args) {
                         if (handler != null)
                             handler(sender, args);
                     }
                     [DebuggerStepThrough]
                     public static void DispatchEvent(this EventHandler handler, object sender, EventArgs args) {
                         if (handler != null)
                             handler(sender, args);
                     }
                     [DebuggerStepThrough]
                     public static IPromise<T> Run<T>(Func<T> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return Promise.Resolve(action());
                         } catch (Exception err) {
                             return Promise.Reject<T>(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise Run(Action action) {
                         ArgumentNotNull(action, "action");
                         try {
                             action();
                             return Promise.Resolve();
                         } catch (Exception err) {
                             return Promise.Reject(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise Run(Func<IPromise> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? Promise.Reject(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return Promise.Reject(err);
                         }
                     }
                     public static void NoWait(IPromise promise) {
                     }
                     public static void NoWait(Task promise) {
                     }
                     public static void NoWait<T>(Task<T> promise) {
                     }
+                    public static void Noop() {
+                    }
+                    public static void Noop(CancellationToken ct) {
+                        ct.ThrowIfCancellationRequested();
+                    }
+                    public static Task CreateTask() {
+                        return new Task(Noop);
+                    }
+                    public static Task CreateTask(CancellationToken ct) {
+                        return new Task(Noop, ct);
+                    }
                     [DebuggerStepThrough]
                     public static IPromise<T> Run<T>(Func<IPromise<T>> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? Promise.Reject<T>(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return Promise.Reject<T>(err);
                         }
                     }
-            #if NET_4_5
-                    public static void NoWait(Task t) {
-            #endif
                 }
             }

Implab.Test/UnitTest1.cs removed 0 -40

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