implab/ImplabNet Commit - r184:d6a8cba73acc

working on runnable component

cin -

r184:d6a8cba73acc ref20160224

parent child

Context file:

r184:d6a8cba73acc

Collapse all files

Implab.Test/Implab.Format.Test/JsonTests.cs +1 -1

             using NUnit.Framework;
             using System;
             using Implab.Formats.JSON;
             using Implab.Automaton;
             namespace Implab.Format.Test {
                 [TestFixture]
                 public class JsonTests {
                     [Test]
                     public void TestScannerValidTokens() {
                         using (var scanner = new JSONScanner(@"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>[] expexted = {
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, 9123d),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, -123d),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, 0d),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, 0.1d),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, -0.2d),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, -0.1e3d),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, 1.3E-3d),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.String, "some \t\n  text"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Literal, "literal"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.BeginArray, " ["),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.EndArray, "]"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.BeginObject, "{"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.EndObject, "}"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.NameSeparator, ":")
                             };
                             object value;
                             JsonTokenType tokenType;
                             for (var i = 0; i < expexted.Length; i++) {
                                 Assert.IsTrue(scanner.ReadToken(out value, out tokenType));
                                 Assert.AreEqual(expexted[i].Item1, tokenType);
                                 Assert.AreEqual(expexted[i].Item2, value);
                             }
                             Assert.IsFalse(scanner.ReadToken(out value, out tokenType));
                         }
                     }
                     [Test]
                     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 = new JSONScanner(json)) {
                                 try {
                                     object 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);
                                 } catch (ParserException e) {
                                     Console.WriteLine(e.Message);
                                 }
                             }
                     }
                 }
             }

Implab/Components/ExecutionState.cs +14 -4

             namespace Implab.Components {
                 public enum ExecutionState {
-                    Reserved = 0,
+                    Undefined = 0,
-                    Uninitialized,
+                    Created,
+                    Initializing,
                     Ready,
                     Starting,
                     Running,
                     Stopping,
-                    Stopped,
+                    Failed,
                     Disposed,
-                    Failed
+                    Last = Disposed
                 }
             }

Implab/Components/IInitializable.cs +1 -1

             using System;
             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="Init()"/> method. All parameters needed
                 /// to complete the initialization must be passed before the calling <see cref="Init()"/>
                 /// </summary>
                 public interface IInitializable {
                     /// <summary>
                     /// Completes initialization.
                     /// </summary>
                     /// <remarks>
-                    /// Normally virtual shouldn't be called from the constructor, due to the incomplete object state, but
+                    /// 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.
                     /// </remarks>
                     void Init();
                 }
             }

Implab/Components/RunnableComponent.cs +138 -1

@@ -1,58 +1,195
1	using System;	1	using System;
2	using Implab.Formats;	2	using Implab.Formats;
3		3
4	namespace Implab.Components {	4	namespace Implab.Components {
5	public class RunnableComponent : Disposable, IRunnable, IInitializable {	5	public class RunnableComponent : Disposable, IRunnable, IInitializable {
		6	enum Commands {
		7	Ok = 0,
		8	Fail,
		9	Init,
		10	Start,
		11	Stop,
		12	Dispose,
		13	Last = Dispose
		14	}
6		15
		16	class StateMachine {
		17	static readonly ExecutionState[,] _transitions;
		18
		19	static StateMachine() {
		20	_transitions = new ExecutionState[(int)ExecutionState.Last + 1, (int)Commands.Last + 1];
		21
		22	Edge(ExecutionState.Created, ExecutionState.Ready, Commands.Ok);
		23	Edge(ExecutionState.Created, ExecutionState.Failed, Commands.Fail);
		24
		25	Edge(ExecutionState.Ready, ExecutionState.Starting, Commands.Start);
		26	Edge(ExecutionState.Ready, ExecutionState.Disposed, Commands.Dispose);
		27
		28	Edge(ExecutionState.Starting, ExecutionState.Running, Commands.Ok);
		29	Edge(ExecutionState.Starting, ExecutionState.Failed, Commands.Fail);
		30	Edge(ExecutionState.Starting, ExecutionState.Stopping, Commands.Stop);
		31	Edge(ExecutionState.Starting, ExecutionState.Disposed, Commands.Dispose);
7		32
		33	Edge(ExecutionState.Running, ExecutionState.Failed, Commands.Fail);
		34	Edge(ExecutionState.Running, ExecutionState.Stopping, Commands.Stop);
		35	Edge(ExecutionState.Running, ExecutionState.Disposed, Commands.Dispose);
8		36
		37	Edge(ExecutionState.Stopping, ExecutionState.Failed, Commands.Fail);
		38	Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Ok);
		39	Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Dispose);
		40	}
9		41
		42	static void Edge(ExecutionState s1, ExecutionState s2, Commands cmd) {
		43	_transitions[(int)s1, (int)cmd] = s2;
		44	}
		45
		46	public ExecutionState State {
		47	get;
		48	private set;
		49	}
		50
		51	public StateMachine(ExecutionState initial) {
		52	State = initial;
		53	}
		54
		55	public bool Move(Commands cmd) {
		56	var next = _transitions[(int)State, (int)cmd];
		57	if (next == ExecutionState.Undefined)
		58	return false;
		59	State = next;
		60	return true;
		61	}
		62	}
10		63
11	IPromise m_pending;	64	IPromise m_pending;
12	Exception m_lastError;	65	Exception m_lastError;
13		66
		67	readonly StateMachine m_stateMachine;
		68
14	protected RunnableComponent(bool initialized) {	69	protected RunnableComponent(bool initialized) {
		70	m_stateMachine = new StateMachine(initialized ? ExecutionState.Ready : ExecutionState.Created);
		71	}
		72
		73	void ThrowInvalidCommand(Commands cmd) {
		74	throw new InvalidOperationException(String.Format("Commnd {0} is not allowed in the state {1}", cmd, m_stateMachine.State));
		75	}
		76
		77	protected void Move(Commands cmd) {
		78	lock (m_stateMachine)
		79	if (!m_stateMachine.Move(cmd))
		80	ThrowInvalidCommand(cmd);
		81	}
		82
		83	protected void Fail(Exception err) {
		84	lock (m_stateMachine) {
		85	if (!m_stateMachine.Move(Commands.Fail))
		86	ThrowInvalidCommand(Commands.Fail);
		87
		88	m_lastError = err;
		89	}
		90	}
		91
		92	protected void Success() {
		93	Move(Commands.Ok);
		94	}
		95
		96	protected void Invoke(Commands cmd, Action action) {
		97	Move(cmd);
		98	try {
		99	action();
		100	Move(Commands.Ok);
		101	} catch (Exception err) {
		102	Fail(err);
		103	throw;
		104	}
		105	}
		106
		107	protected IPromise InvokeAsync(Commands cmd, Func<IPromise> action) {
		108	Move(cmd);
		109	var medium = new Promise();
		110
		111	IPromise promise = null;
		112
		113	promise = medium.Then(
		114	() => {
		115	lock(m_stateMachine) {
		116	if (m_pending == promise) {
		117	m_pending = null;
		118	Move(Commands.Ok);
		119	}
		120	}
		121	}, e => {
		122	if (m_pending == promise) {
		123	m_pending = null;
		124	Fail(
		125	}
		126	}
		127	);
		128
		129
		130
		131	return Safe.InvokePromise(action).Then(
		132	Success,
		133	Fail
		134	);
		135	}
		136
		137	void AddPending(IPromise result) {
15		138
16	}	139	}
17		140
		141
18	#region IInitializable implementation	142	#region IInitializable implementation
19		143
20	public void Init() {	144	public void Init() {
		145	Invoke(Commands.Init, OnInitialize);
		146	}
21		147
		148	protected virtual void OnInitialize() {
22	}	149	}
23		150
24	#endregion	151	#endregion
25		152
26	#region IRunnable implementation	153	#region IRunnable implementation
27		154
28	public IPromise Start() {	155	public IPromise Start() {
29	throw new NotImplementedException();	156	Move(Commands.Start);
		157
		158	return Safe.InvokePromise(OnStart).Then(
		159	() => {
		160	Move(Commands.Ok);
		161	Run();
		162	},
		163	() => {
		164	Move(Commands.Fail);
		165	}
		166	);
30	}	167	}
31		168
32	protected virtual IPromise OnStart() {	169	protected virtual IPromise OnStart() {
33	return Promise.SUCCESS;	170	return Promise.SUCCESS;
34	}	171	}
35		172
36	protected virtual void Run() {	173	protected virtual void Run() {
37	}	174	}
38		175
39	public IPromise Stop() {	176	public IPromise Stop() {
40	throw new NotImplementedException();	177	throw new NotImplementedException();
41	}	178	}
42		179
43	public ExecutionState State {	180	public ExecutionState State {
44	get {	181	get {
45	throw new NotImplementedException();	182	throw new NotImplementedException();
46	}	183	}
47	}	184	}
48		185
49	public Exception LastError {	186	public Exception LastError {
50	get {	187	get {
51	throw new NotImplementedException();	188	throw new NotImplementedException();
52	}	189	}
53	}	190	}
54		191
55	#endregion	192	#endregion
56	}	193	}
57	}	194	}
58		195

General Comments 0

Write
Preview

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

No TODOs yet

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

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