|
|
using System;
|
|
|
using Implab.Formats;
|
|
|
|
|
|
namespace Implab.Components {
|
|
|
public class RunnableComponent : Disposable, IRunnable, IInitializable {
|
|
|
enum Commands {
|
|
|
Ok = 0,
|
|
|
Fail,
|
|
|
Init,
|
|
|
Start,
|
|
|
Stop,
|
|
|
Dispose,
|
|
|
Last = Dispose
|
|
|
}
|
|
|
|
|
|
class StateMachine {
|
|
|
static readonly ExecutionState[,] _transitions;
|
|
|
|
|
|
static StateMachine() {
|
|
|
_transitions = new ExecutionState[(int)ExecutionState.Last + 1, (int)Commands.Last + 1];
|
|
|
|
|
|
Edge(ExecutionState.Created, ExecutionState.Ready, Commands.Ok);
|
|
|
Edge(ExecutionState.Created, ExecutionState.Failed, Commands.Fail);
|
|
|
|
|
|
Edge(ExecutionState.Ready, ExecutionState.Starting, Commands.Start);
|
|
|
Edge(ExecutionState.Ready, ExecutionState.Disposed, Commands.Dispose);
|
|
|
|
|
|
Edge(ExecutionState.Starting, ExecutionState.Running, Commands.Ok);
|
|
|
Edge(ExecutionState.Starting, ExecutionState.Failed, Commands.Fail);
|
|
|
Edge(ExecutionState.Starting, ExecutionState.Stopping, Commands.Stop);
|
|
|
Edge(ExecutionState.Starting, ExecutionState.Disposed, Commands.Dispose);
|
|
|
|
|
|
Edge(ExecutionState.Running, ExecutionState.Failed, Commands.Fail);
|
|
|
Edge(ExecutionState.Running, ExecutionState.Stopping, Commands.Stop);
|
|
|
Edge(ExecutionState.Running, ExecutionState.Disposed, Commands.Dispose);
|
|
|
|
|
|
Edge(ExecutionState.Stopping, ExecutionState.Failed, Commands.Fail);
|
|
|
Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Ok);
|
|
|
Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Dispose);
|
|
|
}
|
|
|
|
|
|
static void Edge(ExecutionState s1, ExecutionState s2, Commands cmd) {
|
|
|
_transitions[(int)s1, (int)cmd] = s2;
|
|
|
}
|
|
|
|
|
|
public ExecutionState State {
|
|
|
get;
|
|
|
private set;
|
|
|
}
|
|
|
|
|
|
public StateMachine(ExecutionState initial) {
|
|
|
State = initial;
|
|
|
}
|
|
|
|
|
|
public bool Move(Commands cmd) {
|
|
|
var next = _transitions[(int)State, (int)cmd];
|
|
|
if (next == ExecutionState.Undefined)
|
|
|
return false;
|
|
|
State = next;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
IPromise m_pending;
|
|
|
Exception m_lastError;
|
|
|
|
|
|
readonly StateMachine m_stateMachine;
|
|
|
|
|
|
protected RunnableComponent(bool initialized) {
|
|
|
m_stateMachine = new StateMachine(initialized ? ExecutionState.Ready : ExecutionState.Created);
|
|
|
}
|
|
|
|
|
|
void ThrowInvalidCommand(Commands cmd) {
|
|
|
throw new InvalidOperationException(String.Format("Commnd {0} is not allowed in the state {1}", cmd, m_stateMachine.State));
|
|
|
}
|
|
|
|
|
|
protected void Move(Commands cmd) {
|
|
|
lock (m_stateMachine)
|
|
|
if (!m_stateMachine.Move(cmd))
|
|
|
ThrowInvalidCommand(cmd);
|
|
|
}
|
|
|
|
|
|
protected void Fail(Exception err) {
|
|
|
lock (m_stateMachine) {
|
|
|
if (!m_stateMachine.Move(Commands.Fail))
|
|
|
ThrowInvalidCommand(Commands.Fail);
|
|
|
|
|
|
m_lastError = err;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
protected void Success() {
|
|
|
Move(Commands.Ok);
|
|
|
}
|
|
|
|
|
|
protected void Invoke(Commands cmd, Action action) {
|
|
|
Move(cmd);
|
|
|
try {
|
|
|
action();
|
|
|
Move(Commands.Ok);
|
|
|
} catch (Exception err) {
|
|
|
Fail(err);
|
|
|
throw;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
protected IPromise InvokeAsync(Commands cmd, Func<IPromise> action) {
|
|
|
Move(cmd);
|
|
|
var medium = new Promise();
|
|
|
|
|
|
IPromise promise = null;
|
|
|
|
|
|
promise = medium.Then(
|
|
|
() => {
|
|
|
lock(m_stateMachine) {
|
|
|
if (m_pending == promise) {
|
|
|
m_pending = null;
|
|
|
Move(Commands.Ok);
|
|
|
}
|
|
|
}
|
|
|
}, e => {
|
|
|
if (m_pending == promise) {
|
|
|
m_pending = null;
|
|
|
Fail(
|
|
|
}
|
|
|
}
|
|
|
);
|
|
|
|
|
|
|
|
|
|
|
|
return Safe.InvokePromise(action).Then(
|
|
|
Success,
|
|
|
Fail
|
|
|
);
|
|
|
}
|
|
|
|
|
|
void AddPending(IPromise result) {
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
#region IInitializable implementation
|
|
|
|
|
|
public void Init() {
|
|
|
Invoke(Commands.Init, OnInitialize);
|
|
|
}
|
|
|
|
|
|
protected virtual void OnInitialize() {
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region IRunnable implementation
|
|
|
|
|
|
public IPromise Start() {
|
|
|
Move(Commands.Start);
|
|
|
|
|
|
return Safe.InvokePromise(OnStart).Then(
|
|
|
() => {
|
|
|
Move(Commands.Ok);
|
|
|
Run();
|
|
|
},
|
|
|
() => {
|
|
|
Move(Commands.Fail);
|
|
|
}
|
|
|
);
|
|
|
}
|
|
|
|
|
|
protected virtual IPromise OnStart() {
|
|
|
return Promise.SUCCESS;
|
|
|
}
|
|
|
|
|
|
protected virtual void Run() {
|
|
|
}
|
|
|
|
|
|
public IPromise Stop() {
|
|
|
throw new NotImplementedException();
|
|
|
}
|
|
|
|
|
|
public ExecutionState State {
|
|
|
get {
|
|
|
throw new NotImplementedException();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public Exception LastError {
|
|
|
get {
|
|
|
throw new NotImplementedException();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
