implab/ImplabNet Commit - r262:f1696cdc3d7a

Added IInitializable.Initialize() overload...

cin -

r262:f1696cdc3d7a v3.0.8 v3

parent child

Context file:

r262:f1696cdc3d7a

Collapse all files

Implab.Test/JsonTests.cs ~~Implab.Format.Test/JsonTests.cs~~ renamed +25 -46

-            using NUnit.Framework;
+            using Xunit;
             using System;
             using Implab.Automaton;
             using Implab.Xml;
             using System.Xml;
             using Implab.Formats;
             using Implab.Formats.Json;
             using System.IO;
-            namespace Implab.Format.Test {
+            namespace Implab.Test {
-                [TestFixture]
                 public class JsonTests {
-                    [Test]
+                    [Fact]
                     public void TestScannerValidTokens() {
                         using (var scanner = JsonStringScanner.Create(@"9123, -123, 0, 0.1, -0.2, -0.1e3, 1.3E-3, ""some \t\n\u0020 text"", literal []{}:")) {
                             Tuple<JsonTokenType, object>[] expexted = {
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "9123"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "-123"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "0"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "0.1"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "-0.2"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "-0.1e3"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "1.3E-3"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.String, "some \t\n  text"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Literal, "literal"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.BeginArray, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.EndArray, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.BeginObject, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.EndObject, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.NameSeparator, null)
                             };
                             string value;
                             JsonTokenType tokenType;
                             for (var i = 0; i < expexted.Length; i++) {
-                                Assert.IsTrue(scanner.ReadToken(out value, out tokenType));
+                                Assert.True(scanner.ReadToken(out value, out tokenType));
-                                Assert.AreEqual(expexted[i].Item1, tokenType);
+                                Assert.Equal(expexted[i].Item1, tokenType);
-                                Assert.AreEqual(expexted[i].Item2, value);
+                                Assert.Equal(expexted[i].Item2, value);
                             }
-                            Assert.IsFalse(scanner.ReadToken(out value, out tokenType));
+                            Assert.False(scanner.ReadToken(out value, out tokenType));
                         }
                     }
-                    [Test]
+                    [Fact]
                     public void TestScannerBadTokens() {
                         var bad = new[] {
                             " 1",
                             " literal",
                             " \"",
                             "\"unclosed string",
                             "1.bad",
                             "001", // should be read as three numbers
                             "--10",
                             "+10",
                             "1.0.0",
                             "1e1.0",
                             "l1teral0",
                             ".123",
                             "-.123"
                         };
                         foreach (var json in bad) {
                             using (var scanner = JsonStringScanner.Create(json)) {
                                 try {
                                     string value;
                                     JsonTokenType token;
                                     scanner.ReadToken(out value, out token);
                                     if (!Object.Equals(value, json)) {
                                         Console.WriteLine("'{0}' is read as {1}", json, value is String ? String.Format("'{0}'", value) : value);
                                         continue;
                                     }
-                                    Assert.Fail("Token '{0}' shouldn't pass", json);
+                                    Assert.True(false, $"Token '{json}' shouldn't pass");
                                 } catch (ParserException e) {
                                     Console.WriteLine(e.Message);
                                 }
                             }
                         }
                     }
-                    [Test]
+                    [Fact]
                     public void JsonXmlReaderSimpleTest() {
                         var json = "\"some text\"";
                         //Console.WriteLine($"JSON: {json}");
                         //Console.WriteLine("XML");
                         /*using (var xmlReader = new JsonXmlReader(new JSONParser(json), new JsonXmlReaderOptions { NamespaceUri = "JsonXmlReaderSimpleTest", RootName = "string", NodesPrefix = "json" })) {
                             Assert.AreEqual(xmlReader.ReadState, System.Xml.ReadState.Initial);
                             AssertRead(xmlReader, XmlNodeType.XmlDeclaration);
                             AssertRead(xmlReader, XmlNodeType.Element);
                             AssertRead(xmlReader, XmlNodeType.Text);
                             AssertRead(xmlReader, XmlNodeType.EndElement);
                             Assert.IsFalse(xmlReader.Read());
                         }*/
-                        //DumpJsonParse("\"text value\"");
+                        DumpJsonParse("\"text value\"");
-                        //DumpJsonParse("null");
+                        DumpJsonParse("null");
-                        //DumpJsonParse("true");
+                        DumpJsonParse("true");
-                        //DumpJsonParse("{}");
+                        DumpJsonParse("{}");
-                        //DumpJsonParse("[]");
+                        DumpJsonParse("[]");
                         DumpJsonParse("{\"one\":1, \"two\":2}");
                         DumpJsonParse("[1,\"\",2,3]");
                         DumpJsonParse("[{\"info\": [7,8,9]}]");
                         DumpJsonFlatParse("[1,2,\"\",[3,4],{\"info\": [5,6]},{\"num\": [7,8,null]}, null,[null]]");
                     }
-                    [Test]
-                    public void JsonBenchmark() {
-                        var t = Environment.TickCount;
-                        using (var reader = new JsonXmlReader(JsonReader.Create("e:\\citylots.json"), new JsonXmlReaderOptions { NamespaceUri = "XmlReaderSimpleTest", RootName = "data" })) {
-                            while (reader.Read()) {
-                        Console.WriteLine($"JsonXmlReader: {Environment.TickCount - t} ms");
-                        t = Environment.TickCount;
-                        using(var reader = JsonReader.Create("e:\\citylots.json")) {
-                            while(reader.Read()) {
-                        Console.WriteLine($"JsonReader: {Environment.TickCount - t} ms");
-                        t = Environment.TickCount;
-                        using (var reader = XmlReader.Create("file:///e:\\citylots.xml")) {
-                            while (reader.Read()) {
-                        Console.WriteLine($"XmlReader: {Environment.TickCount - t} ms");
                     void AssertRead(XmlReader reader, XmlNodeType expected) {
-                        Assert.IsTrue(reader.Read());
+                        Assert.True(reader.Read());
                         Console.WriteLine($"{new string(' ', reader.Depth * 2)}{reader}");
-                        Assert.AreEqual(expected, reader.NodeType);
+                        Assert.Equal(expected, reader.NodeType);
                     }
                     void DumpJsonParse(string json) {
                         Console.WriteLine($"JSON: {json}");
                         Console.WriteLine("XML");
+                        using (var xmlWriter = XmlWriter.Create(Console.Out, new XmlWriterSettings {
+                            Indent = true,
+                            CloseOutput = false,
+                            ConformanceLevel = ConformanceLevel.Document
+                        }))
                         using (var xmlReader = new JsonXmlReader(JsonReader.ParseString(json), new JsonXmlReaderOptions { NamespaceUri = "JsonXmlReaderSimpleTest", NodesPrefix = "json" })) {
-                            while (xmlReader.Read())
+                            xmlWriter.WriteNode(xmlReader, false);
-                                Console.WriteLine($"{new string(' ', xmlReader.Depth * 2)}{xmlReader}");
                         }
+                        Console.WriteLine();
                     }
                     void DumpJsonFlatParse(string json) {
                         Console.WriteLine($"JSON: {json}");
                         Console.WriteLine("XML");
                         using (var xmlWriter = XmlWriter.Create(Console.Out, new XmlWriterSettings {
                             Indent = true,
                             CloseOutput = false,
                             ConformanceLevel = ConformanceLevel.Document
                         }))
                         using (var xmlReader = new JsonXmlReader(JsonReader.ParseString(json), new JsonXmlReaderOptions { NamespaceUri = "JsonXmlReaderSimpleTest", NodesPrefix = "", FlattenArrays = true })) {
                             xmlWriter.WriteNode(xmlReader, false);
                         }
+                        Console.WriteLine();
                     }
                 }
             }

Implab.Test/MockPollComponent.cs +2 0

             using System;
             using System.Threading;
             using System.Threading.Tasks;
             using Implab.Components;
             namespace Implab.Test {
                 public class MockPollComponent : PollingComponent {
                     public Func<CancellationToken,Task> PollWorker { get; set;}
                     public Func<CancellationToken, Task> StartWorker { get; set; }
                     public Func<CancellationToken, Task> StopWorker { get; set; }
                     public MockPollComponent(bool initialized) : base(initialized) {
                     }
                     protected async override Task Poll(CancellationToken ct) {
                         if(PollWorker!= null)
                             await PollWorker.Invoke(ct);
                     }
                     protected async override Task StopInternalAsync(CancellationToken ct) {
+                        await base.StopInternalAsync(ct);
                         if (StopWorker != null)
                             await StopWorker.Invoke(ct);
                     }
                     protected async override Task StartInternalAsync(CancellationToken ct) {
+                        await base.StartInternalAsync(ct);
                         if (StartWorker != null)
                             await StartWorker.Invoke(ct);
                     }
                 }
             }

Implab.Test/RunnableComponentTests.cs +236 -2

@@ -1,30 +1,264
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		8
9	public class RunnableComponentTests {	9	public class RunnableComponentTests {
10	[Fact]	10	[Fact]
11	public async Task ~~Test1~~() {	11	public async Task SimpleStartStop() {
12		12
13	using (var m = new MockPollComponent(true)) {	13	using (var m = new MockPollComponent(true)) {
14	m.StartWorker = async (ct) => await Task.Yield();	14	m.StartWorker = async (ct) => await Task.Yield();
15	m.StopWorker = async (ct) => await Task.Yield();	15	m.StopWorker = async (ct) => await Task.Yield();
16		16
17	Assert.Equal(ExecutionState.Ready, m.State);	17	Assert.Equal(ExecutionState.Ready, m.State);
18	Assert.NotNull(m.Completion);	18	Assert.NotNull(m.Completion);
19		19
20	m.Start(~~CancellationToken~~.~~None~~);	20	m.Start();
21	await m.Completion;	21	await m.Completion;
22	Assert.Equal(ExecutionState.Running, m.State);	22	Assert.Equal(ExecutionState.Running, m.State);
23		23
		24	m.Stop();
		25	await m.Completion;
		26	Assert.Equal(ExecutionState.Stopped, m.State);
		27	}
		28	}
		29
		30	[Fact]
		31	public async Task SyncStart() {
		32	using (var m = new MockPollComponent(true)) {
		33	m.Start();
		34	Assert.Equal(ExecutionState.Running, m.State);
		35	await m.Completion;
		36	}
		37	}
		38
		39	[Fact]
		40	public async Task AsyncStarting() {
		41	using (var m = new MockPollComponent(true)) {
		42	var signal = Safe.CreateTask();
		43
		44	m.StartWorker = async (ct) => await signal;
		45	m.Start();
		46
		47	Assert.Equal(ExecutionState.Starting, m.State);
		48	Assert.False(m.Completion.IsCompleted);
		49
		50	signal.Start();
		51
		52	await m.Completion;
		53
		54	Assert.Equal(ExecutionState.Running, m.State);
		55	}
		56	}
		57
		58	[Fact]
		59	public async Task FailWhileStarting() {
		60	using (var m = new MockPollComponent(true)) {
		61	const string failMessage = "Fail me";
		62	var signal = new Task(() => {
		63	throw new Exception(failMessage);
		64	});
		65
		66	m.StartWorker = async (ct) => await signal;
		67	m.Start();
		68
		69	Assert.Equal(ExecutionState.Starting, m.State);
		70	Assert.False(m.Completion.IsCompleted);
		71
		72	signal.Start();
		73	try {
		74	await m.Completion;
		75	Assert.True(false);
		76	} catch (Exception e) {
		77	Assert.Equal(failMessage, e.Message);
		78	}
		79
		80	Assert.Equal(ExecutionState.Failed, m.State);
		81	}
		82	}
		83
		84	[Fact]
		85	public async Task SyncStop() {
		86	using (var m = new MockPollComponent(true)) {
		87	m.Start();
		88	Assert.Equal(ExecutionState.Running, m.State);
		89	m.Stop();
		90	Assert.Equal(ExecutionState.Stopped, m.State);
		91	await m.Completion;
		92	}
		93	}
		94
		95	[Fact]
		96	public async Task AsyncStopping() {
		97	using (var m = new MockPollComponent(true)) {
		98	var signal = Safe.CreateTask();
		99
		100	m.StopWorker = async (ct) => await signal;
		101
		102	// Start
		103	m.Start();
		104	Assert.Equal(ExecutionState.Running, m.State);
		105
		106	// Stop
		107	m.Stop();
		108	Assert.Equal(ExecutionState.Stopping, m.State);
		109	Assert.False(m.Completion.IsCompleted);
		110	signal.Start();
		111
		112	await m.Completion;
		113
		114	Assert.Equal(ExecutionState.Stopped, m.State);
		115	}
		116	}
		117
		118	[Fact]
		119	public async Task FailWhileStopping() {
		120	using (var m = new MockPollComponent(true)) {
		121	const string failMessage = "Fail me";
		122	var signal = new Task(() => {
		123	throw new Exception(failMessage);
		124	});
		125
		126	m.StopWorker = async (ct) => await signal;
		127
		128	// Start
		129	m.Start();
		130	Assert.Equal(ExecutionState.Running, m.State);
		131
		132	// Stop
		133	m.Stop();
		134	Assert.Equal(ExecutionState.Stopping, m.State);
		135	Assert.False(m.Completion.IsCompleted);
		136
		137	signal.Start();
		138	try {
		139	await m.Completion;
		140	Assert.True(false);
		141	} catch (Exception e) {
		142	Assert.Equal(failMessage, e.Message);
		143	}
		144
		145	Assert.Equal(ExecutionState.Failed, m.State);
		146	}
		147	}
		148
		149	[Fact]
		150	public async Task ThrowOnInvalidTrasition() {
		151	using (var m = new MockPollComponent(false)) {
		152	var started = Safe.CreateTask();
		153	var stopped = Safe.CreateTask();
		154
		155	m.StartWorker = async (ct) => await started;
		156	m.StopWorker = async (ct) => await stopped;
		157
		158	Assert.Throws<InvalidOperationException>(() => m.Start());
		159
		160	// Initialize
		161	m.Initialize();
		162	await m.Completion;
		163
		164	// Start
		165	m.Start();
		166	Assert.Equal(ExecutionState.Starting, m.State);
		167
		168	// Check invalid transitions
		169	Assert.Throws<InvalidOperationException>(() => m.Start());
		170
		171	// Component can be stopped before started
		172	// m.Stop(CancellationToken.None);
		173
		174	// Running
		175	started.Start();
		176	await m.Completion;
		177	Assert.Equal(ExecutionState.Running, m.State);
		178
		179
		180	Assert.Throws<InvalidOperationException>(() => m.Start());
		181
		182	// Stop
		183	m.Stop();
		184
		185	// Check invalid transitions
		186	Assert.Throws<InvalidOperationException>(() => m.Start());
		187	Assert.Throws<InvalidOperationException>(() => m.Stop());
		188
		189	// Stopped
		190	stopped.Start();
		191	await m.Completion;
		192	Assert.Equal(ExecutionState.Stopped, m.State);
		193
		194	// Check invalid transitions
		195	Assert.Throws<InvalidOperationException>(() => m.Start());
		196	Assert.Throws<InvalidOperationException>(() => m.Stop());
		197	}
		198	}
		199
		200	[Fact]
		201	public async Task CancelStart() {
		202	using (var m = new MockPollComponent(true)) {
		203	m.StartWorker = (ct) => Safe.CreateTask(ct);
		204
		205	m.Start();
		206	var start = m.Completion;
		207
		208	Assert.Equal(ExecutionState.Starting, m.State);
		209	m.Stop();
		210	await m.Completion;
		211	Assert.Equal(ExecutionState.Stopped, m.State);
		212	Assert.True(start.IsCompleted);
		213	Assert.True(start.IsCanceled);
		214	}
		215	}
		216
		217	[Fact]
		218	public async Task AwaitWorker() {
		219	using (var m = new MockPollComponent(true)) {
		220	var worker = Safe.CreateTask();
		221
		222	m.PollWorker = (ct) => worker;
		223
		224	m.Start(CancellationToken.None);
		225	await m.Completion;
		226
		227	Assert.Equal(ExecutionState.Running, m.State);
		228
24	m.Stop(CancellationToken.None);	229	m.Stop(CancellationToken.None);
		230	Assert.Equal(ExecutionState.Stopping, m.State);
		231	worker.Start();
		232	await m.Completion;
		233	Assert.Equal(ExecutionState.Stopped, m.State);
		234	}
		235	}
		236
		237	[Fact]
		238	public async Task CancelWorker() {
		239	using (var m = new MockPollComponent(true)) {
		240	var worker = Safe.CreateTask();
		241
		242	var started = Safe.CreateTask();
		243
		244	m.PollWorker = async (ct) => {
		245	started.Start();
		246	await worker;
		247	ct.ThrowIfCancellationRequested();
		248	};
		249
		250	m.Start(CancellationToken.None);
		251	await m.Completion;
		252	await started; // await for the poll worker to start
		253
		254	Assert.Equal(ExecutionState.Running, m.State);
		255
		256	m.Stop(CancellationToken.None);
		257	Assert.Equal(ExecutionState.Stopping, m.State);
		258	worker.Start();
25	await m.Completion;	259	await m.Completion;
26	Assert.Equal(ExecutionState.Stopped, m.State);	260	Assert.Equal(ExecutionState.Stopped, m.State);
27	}	261	}
28	}	262	}
29	}	263	}
30	}	264	}

Implab/Components/IInitializable.cs +2 0

             using System;
+            using System.Threading;
             namespace Implab.Components {
                 /// <summary>
                 /// Initializable components are created and initialized in two steps, first we have create the component,
                 /// then we have to complete it's creation by calling an <see cref="Initialize()"/> method. All parameters needed
                 /// to complete the initialization must be passed before the calling <see cref="Initialize()"/>
                 /// </summary>
                 public interface IInitializable {
                     /// <summary>
                     /// Completes initialization.
                     /// </summary>
                     /// <remarks>
                     /// <para>
                     /// Normally virtual methods shouldn't be called from the constructor, due to the incomplete object state, but
                     /// they can be called from this method. This method is also usefull when we constructing a complex grpah
                     /// of components where cyclic references may take place.
                     /// </para>
                     /// <para>
                     /// In asyncronous patterns <see cref="Initialize()"/> can be called
                     /// to start initialization and the <see cref="IRunnable.Completion"/>
                     /// property can be used to track operation completion.
                     /// </para>
                     /// </remarks>
                     void Initialize();
+                    void Initialize(CancellationToken ct);
                 }
             }

Implab/Components/IRunnable.cs +2 0

             using System;
             using System.Threading;
             using System.Threading.Tasks;
             namespace Implab.Components {
                 /// <summary>
                 /// Interface for the component which performs a long running task.
                 /// </summary>
                 /// <remarks>
                 /// The access to the runnable component should be sequential, the
                 /// componet should support asynchronous completion of the initiated
                 /// operation but operations itself must be initiated sequentially.
                 /// </remarks>
                 public interface IRunnable {
                     /// <summary>
                     /// Starts this instance
                     /// </summary>
                     /// <remarks>
                     /// This operation is cancellable and it's expected to move to
                     /// the failed state or just ignore the cancellation request,
                     /// </remarks>
+                    void Start();
                     void Start(CancellationToken ct);
                     /// <summary>
                     /// Stops this instance and releases all resources, after the
                     /// instance is stopped it is moved to Disposed state and
                     /// can't be reused.
                     /// </summary>
                     /// <remarks>
                     /// If the componet was in the starting state the pending operation
                     /// will be requested to cancel. The stop operatin will be
                     /// performed only if the component in the running state.
                     /// </remarks>
+                    void Stop();
                     void Stop(CancellationToken ct);
                     /// <summary>
                     /// Current state of the componenet, dynamically reflects the current state.
                     /// </summary>
                     ExecutionState State { get; }
                     /// <summary>
                     /// Event to monitor the state of the component.
                     /// </summary>
                     event EventHandler<StateChangeEventArgs> StateChanged;
                     /// <summary>
                     /// The last error
                     /// </summary>
                     Exception LastError { get; }
                 }
             }

Implab/Components/PollingComponent.cs +1 0

             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
+                            if (m_poll != null)
                                 await m_poll;
                         } 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);
                         }
                     }
                     protected override void Dispose(bool disposing) {
                         if (disposing)
                             Safe.Dispose(m_timer, m_cancellation);
                         base.Dispose(disposing);
                     }
                 }
             }

Implab/Components/RunnableComponent.cs +21 -3

             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() {
+                        Initialize(CancellationToken.None);
+                    }
+                    public void Initialize(CancellationToken ct) {
                         var cookie = new object();
                         if (MoveInitialize(cookie))
-                            Safe.NoWait(ScheduleTask(InitializeInternalAsync, CancellationToken.None, cookie));
+                            Safe.NoWait(ScheduleTask(InitializeInternalAsync, ct, 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() {
+                        Start(CancellationToken.None);
+                    }
                     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() {
+                        Stop(CancellationToken.None);
+                    }
                     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();
+                        try {
                             await Completion;
+                        } catch(OperationCanceledException) {
+                            // OK
+                        }
                         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) {
+                    bool MoveFailed(Exception err, object cookie) {
                         lock (m_lock) {
                             if (m_cookie != cookie)
-                                return;
+                                return false;
                             LastError = err;
                             State = ExecutionState.Failed;
+                            return true;
                         }
                     }
                     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/Implab.csproj +2 -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>
-                <Version>3.0.6</Version>
+                <Version>3.0.8</Version>
-                <PackageLicenseUrl>https://opensource.org/licenses/BSD-2-Clause</PackageLicenseUrl>
+                <PackageLicenseUrl>https://hg.implab.org/pub/ImplabNet/file/tip/Implab/license.txt</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.Format.Test/Implab.Format.Test.csproj removed 0 -57

NO CONTENT: file was removed

Implab.Format.Test/packages.config removed 0 -4

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