|
|
using System;
|
|
|
using System.Diagnostics.CodeAnalysis;
|
|
|
|
|
|
namespace Implab.Components {
|
|
|
public abstract class RunnableComponent : IDisposable, IRunnable, IInitializable {
|
|
|
enum Commands {
|
|
|
Ok = 0,
|
|
|
Fail,
|
|
|
Init,
|
|
|
Start,
|
|
|
Stop,
|
|
|
Dispose,
|
|
|
Reset,
|
|
|
Last = Reset
|
|
|
}
|
|
|
|
|
|
class StateMachine {
|
|
|
public static readonly ExecutionState[,] ReusableTransitions;
|
|
|
public static readonly ExecutionState[,] NonreusableTransitions;
|
|
|
|
|
|
class StateBuilder {
|
|
|
readonly ExecutionState[,] m_states;
|
|
|
|
|
|
public ExecutionState[,] States {
|
|
|
get { return m_states; }
|
|
|
}
|
|
|
public StateBuilder(ExecutionState[,] states) {
|
|
|
m_states = states;
|
|
|
}
|
|
|
|
|
|
public StateBuilder() {
|
|
|
m_states = new ExecutionState[(int)ExecutionState.Last + 1, (int)Commands.Last + 1];
|
|
|
}
|
|
|
|
|
|
public StateBuilder Edge(ExecutionState s1, ExecutionState s2, Commands cmd) {
|
|
|
m_states[(int)s1, (int)cmd] = s2;
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
public StateBuilder Clone() {
|
|
|
return new StateBuilder((ExecutionState[,])m_states.Clone());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
static StateMachine() {
|
|
|
ReusableTransitions = new ExecutionState[(int)ExecutionState.Last + 1, (int)Commands.Last + 1];
|
|
|
|
|
|
var common = new StateBuilder()
|
|
|
.Edge(ExecutionState.Created, ExecutionState.Initializing, Commands.Init)
|
|
|
.Edge(ExecutionState.Created, ExecutionState.Disposed, Commands.Dispose)
|
|
|
|
|
|
.Edge(ExecutionState.Initializing, ExecutionState.Ready, Commands.Ok)
|
|
|
.Edge(ExecutionState.Initializing, 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.Failed, ExecutionState.Disposed, Commands.Dispose)
|
|
|
.Edge(ExecutionState.Failed, ExecutionState.Initializing, Commands.Reset)
|
|
|
|
|
|
.Edge(ExecutionState.Stopping, ExecutionState.Failed, Commands.Fail)
|
|
|
.Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Dispose)
|
|
|
|
|
|
.Edge(ExecutionState.Disposed, ExecutionState.Disposed, Commands.Dispose);
|
|
|
|
|
|
var reusable = common
|
|
|
.Clone()
|
|
|
.Edge(ExecutionState.Stopping, ExecutionState.Ready, Commands.Ok);
|
|
|
|
|
|
var nonreusable = common
|
|
|
.Clone()
|
|
|
.Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Ok);
|
|
|
|
|
|
NonreusableTransitions = nonreusable.States;
|
|
|
ReusableTransitions = reusable.States;
|
|
|
|
|
|
}
|
|
|
|
|
|
readonly ExecutionState[,] m_states;
|
|
|
|
|
|
public ExecutionState State {
|
|
|
get;
|
|
|
private set;
|
|
|
}
|
|
|
|
|
|
public StateMachine(ExecutionState[,] states, ExecutionState initial) {
|
|
|
State = initial;
|
|
|
m_states = states;
|
|
|
}
|
|
|
|
|
|
public bool Move(Commands cmd) {
|
|
|
var next = m_states[(int)State, (int)cmd];
|
|
|
if (next == ExecutionState.Undefined)
|
|
|
return false;
|
|
|
State = next;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
IPromise m_pending;
|
|
|
Exception m_lastError;
|
|
|
|
|
|
readonly StateMachine m_stateMachine;
|
|
|
readonly bool m_reusable;
|
|
|
public event EventHandler<StateChangeEventArgs> StateChanged;
|
|
|
|
|
|
/// <summary>
|
|
|
/// Initializes component state.
|
|
|
/// </summary>
|
|
|
/// <param name="initialized">If set, the component initial state is <see cref="ExecutionState.Ready"/> and the component is ready to start, otherwise initialization is required.</param>
|
|
|
/// <param name="reusable">If set, the component may start after it has been stopped, otherwise the component is disposed after being stopped.</param>
|
|
|
protected RunnableComponent(bool initialized, bool reusable) {
|
|
|
m_stateMachine = new StateMachine(
|
|
|
reusable ? StateMachine.ReusableTransitions : StateMachine.NonreusableTransitions,
|
|
|
initialized ? ExecutionState.Ready : ExecutionState.Created
|
|
|
);
|
|
|
m_reusable = reusable;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Initializes component state. The component created with this constructor is not reusable, i.e. it will be disposed after stop.
|
|
|
/// </summary>
|
|
|
/// <param name="initialized">If set, the component initial state is <see cref="ExecutionState.Ready"/> and the component is ready to start, otherwise initialization is required.</param>
|
|
|
protected RunnableComponent(bool initialized) : this(initialized, false) {
|
|
|
}
|
|
|
|
|
|
void ThrowInvalidCommand(Commands cmd) {
|
|
|
if (m_stateMachine.State == ExecutionState.Disposed)
|
|
|
throw new ObjectDisposedException(ToString());
|
|
|
|
|
|
throw new InvalidOperationException(String.Format("Command {0} is not allowed in the state {1}", cmd, m_stateMachine.State));
|
|
|
}
|
|
|
|
|
|
bool MoveIfInState(Commands cmd, IPromise pending, Exception error, ExecutionState state) {
|
|
|
ExecutionState prev, current;
|
|
|
lock (m_stateMachine) {
|
|
|
if (m_stateMachine.State != state)
|
|
|
return false;
|
|
|
|
|
|
prev = m_stateMachine.State;
|
|
|
if (!m_stateMachine.Move(cmd))
|
|
|
ThrowInvalidCommand(cmd);
|
|
|
current = m_stateMachine.State;
|
|
|
|
|
|
m_pending = pending;
|
|
|
m_lastError = error;
|
|
|
}
|
|
|
if (prev != current)
|
|
|
OnStateChanged(prev, current, error);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool MoveIfPending(Commands cmd, IPromise pending, Exception error, IPromise expected) {
|
|
|
ExecutionState prev, current;
|
|
|
lock (m_stateMachine) {
|
|
|
if (m_pending != expected)
|
|
|
return false;
|
|
|
prev = m_stateMachine.State;
|
|
|
if (!m_stateMachine.Move(cmd))
|
|
|
ThrowInvalidCommand(cmd);
|
|
|
current = m_stateMachine.State;
|
|
|
m_pending = pending;
|
|
|
m_lastError = error;
|
|
|
}
|
|
|
if (prev != current)
|
|
|
OnStateChanged(prev, current, error);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
IPromise Move(Commands cmd, IPromise pending, Exception error) {
|
|
|
ExecutionState prev, current;
|
|
|
IPromise ret;
|
|
|
lock (m_stateMachine) {
|
|
|
prev = m_stateMachine.State;
|
|
|
if (!m_stateMachine.Move(cmd))
|
|
|
ThrowInvalidCommand(cmd);
|
|
|
current = m_stateMachine.State;
|
|
|
|
|
|
ret = m_pending;
|
|
|
m_pending = pending;
|
|
|
m_lastError = error;
|
|
|
|
|
|
}
|
|
|
if (prev != current)
|
|
|
OnStateChanged(prev, current, error);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Handles the state of the component change event, raises the <see cref="StateChanged"/> event, handles
|
|
|
/// the transition to the <see cref="ExecutionState.Disposed"/> state (calls <see cref="Dispose(bool)"/> method).
|
|
|
/// </summary>
|
|
|
/// <param name="previous">The previous state</param>
|
|
|
/// <param name="current">The current state</param>
|
|
|
/// <param name="error">The last error if any.</param>
|
|
|
/// <remarks>
|
|
|
/// <para>
|
|
|
/// If the previous state and the current state are same this method isn't called, such situiation is treated
|
|
|
/// as the component hasn't changed it's state.
|
|
|
/// </para>
|
|
|
/// <para>
|
|
|
/// When overriding this method ensure the call is made to the base implementation, otherwise it will lead to
|
|
|
/// the wrong behavior of the component.
|
|
|
/// </para>
|
|
|
/// </remarks>
|
|
|
protected virtual void OnStateChanged(ExecutionState previous, ExecutionState current, Exception error) {
|
|
|
StateChanged.DispatchEvent(
|
|
|
this,
|
|
|
new StateChangeEventArgs {
|
|
|
State = current,
|
|
|
LastError = error
|
|
|
}
|
|
|
);
|
|
|
if (current == ExecutionState.Disposed) {
|
|
|
GC.SuppressFinalize(this);
|
|
|
Dispose(true);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Moves the component from running to failed state.
|
|
|
/// </summary>
|
|
|
/// <param name="error">The exception which is describing the error.</param>
|
|
|
protected bool Fail(Exception error) {
|
|
|
return MoveIfInState(Commands.Fail, null, error, ExecutionState.Running);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Tries to reset <see cref="ExecutionState.Failed"/> state to <see cref="ExecutionState.Ready"/>.
|
|
|
/// </summary>
|
|
|
/// <returns>True if component is reset to <see cref="ExecutionState.Ready"/>, false if the componet wasn't
|
|
|
/// in <see cref="ExecutionState.Failed"/> state.</returns>
|
|
|
/// <remarks>
|
|
|
/// This method checks the current state of the component and if it's in <see cref="ExecutionState.Failed"/>
|
|
|
/// moves component to <see cref="ExecutionState.Initializing"/>.
|
|
|
/// The <see cref="OnResetState()"/> is called and if this method completes succesfully the component moved
|
|
|
/// to <see cref="ExecutionState.Ready"/> state, otherwise the component is moved to <see cref="ExecutionState.Failed"/>
|
|
|
/// state. If <see cref="OnResetState()"/> throws an exception it will be propagated by this method to the caller.
|
|
|
/// </remarks>
|
|
|
protected bool ResetState() {
|
|
|
if (!MoveIfInState(Commands.Reset, null, null, ExecutionState.Failed))
|
|
|
return false;
|
|
|
|
|
|
try {
|
|
|
OnResetState();
|
|
|
Move(Commands.Ok, null, null);
|
|
|
return true;
|
|
|
} catch (Exception err) {
|
|
|
Move(Commands.Fail, null, err);
|
|
|
throw;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// This method is called by <see cref="ResetState"/> to reinitialize component in the failed state.
|
|
|
/// </summary>
|
|
|
/// <remarks>
|
|
|
/// Default implementation throws <see cref="NotImplementedException"/> which will cause the component
|
|
|
/// fail to reset it's state and it left in <see cref="ExecutionState.Failed"/> state.
|
|
|
/// If this method doesn't throw exceptions the component is moved to <see cref="ExecutionState.Ready"/> state.
|
|
|
/// </remarks>
|
|
|
protected virtual void OnResetState() {
|
|
|
throw new NotImplementedException();
|
|
|
}
|
|
|
|
|
|
IPromise InvokeAsync(Commands cmd, Func<IPromise> action, Action<IPromise, IResolvable> chain) {
|
|
|
IPromise promise = null;
|
|
|
IPromise prev;
|
|
|
|
|
|
var task = new ActionChainTask(action, null, null, true);
|
|
|
|
|
|
Action<Exception> errorOrCancel = e => {
|
|
|
if (e == null)
|
|
|
e = new OperationCanceledException();
|
|
|
MoveIfPending(Commands.Fail, null, e, promise);
|
|
|
throw new PromiseTransientException(e);
|
|
|
};
|
|
|
|
|
|
promise = task.Then(
|
|
|
() => MoveIfPending(Commands.Ok, null, null, promise),
|
|
|
errorOrCancel,
|
|
|
errorOrCancel
|
|
|
);
|
|
|
|
|
|
prev = Move(cmd, promise, null);
|
|
|
|
|
|
if (prev == null)
|
|
|
task.Resolve();
|
|
|
else
|
|
|
chain(prev, task);
|
|
|
|
|
|
return promise;
|
|
|
}
|
|
|
|
|
|
|
|
|
#region IInitializable implementation
|
|
|
|
|
|
public void Initialize() {
|
|
|
Move(Commands.Init, null, null);
|
|
|
|
|
|
try {
|
|
|
OnInitialize();
|
|
|
Move(Commands.Ok, null, null);
|
|
|
} catch (Exception err) {
|
|
|
Move(Commands.Fail, null, err);
|
|
|
throw;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
protected virtual void OnInitialize() {
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region IRunnable implementation
|
|
|
|
|
|
public IPromise Start() {
|
|
|
return InvokeAsync(Commands.Start, OnStart, null);
|
|
|
}
|
|
|
|
|
|
protected virtual IPromise OnStart() {
|
|
|
return Promise.Success;
|
|
|
}
|
|
|
|
|
|
public IPromise Stop() {
|
|
|
return InvokeAsync(Commands.Stop, OnStop, StopPending);
|
|
|
}
|
|
|
|
|
|
protected virtual IPromise OnStop() {
|
|
|
return Promise.Success;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Stops the current operation if one exists.
|
|
|
/// </summary>
|
|
|
/// <param name="current">Current.</param>
|
|
|
/// <param name="stop">Stop.</param>
|
|
|
protected virtual void StopPending(IPromise current, IResolvable stop) {
|
|
|
if (current == null) {
|
|
|
stop.Resolve();
|
|
|
} else {
|
|
|
// связваем текущую операцию с операцией остановки
|
|
|
current.On(
|
|
|
stop.Resolve, // если текущая операция заверщилась, то можно начинать остановку
|
|
|
stop.Reject, // если текущая операция дала ошибку - то все плохо, нельзя продолжать
|
|
|
e => stop.Resolve() // если текущая отменилась, то можно начинать остановку
|
|
|
);
|
|
|
// посылаем текущей операции сигнал остановки
|
|
|
current.Cancel();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public ExecutionState State {
|
|
|
get {
|
|
|
return m_stateMachine.State;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public Exception LastError {
|
|
|
get {
|
|
|
return m_lastError;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region IDisposable implementation
|
|
|
|
|
|
/// <summary>
|
|
|
/// Releases all resource used by the <see cref="Implab.Components.RunnableComponent"/> object.
|
|
|
/// </summary>
|
|
|
/// <remarks>
|
|
|
/// <para>Will not try to stop the component, it will just release all resources.
|
|
|
/// To cleanup the component gracefully use <see cref="Stop()"/> method.</para>
|
|
|
/// <para>
|
|
|
/// In normal cases the <see cref="Dispose()"/> method shouldn't be called, the call to the <see cref="Stop()"/>
|
|
|
/// method is sufficient to cleanup the component. Call <see cref="Dispose()"/> only to cleanup after errors,
|
|
|
/// especially if <see cref="Stop"/> method is failed. Using this method insted of <see cref="Stop()"/> may
|
|
|
/// lead to the data loss by the component.
|
|
|
/// </para></remarks>
|
|
|
[SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification = "Dipose(bool) and GC.SuppessFinalize are called")]
|
|
|
public void Dispose() {
|
|
|
Move(Commands.Dispose, null, null);
|
|
|
}
|
|
|
|
|
|
~RunnableComponent() {
|
|
|
Dispose(false);
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
/// <summary>
|
|
|
/// Releases all resources used by the component, called automatically, override this method to implement your cleanup.
|
|
|
/// </summary>
|
|
|
/// <param name="disposing">true if this method is called during normal dispose process.</param>
|
|
|
/// <param name="pending">The operation which is currenty pending</param>
|
|
|
protected virtual void Dispose(bool disposing) {
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
