pub/ImplabNet: Implab/Components/RunnableComponent.cs comparison

comparison Implab/Components/RunnableComponent.cs @ 205:8200ab154c8a v2

Added ResetState to RunnableComponent to reset in case of failure Added StateChanged event to IRunnable Renamed Promise.SUCCESS -> Promise.Success Added Promise.FromException Renamed Bundle -> PromiseAll in PromiseExtensions

author	cin
date	Tue, 25 Oct 2016 17:40:33 +0300
parents	4d9830a9bbb8
children	7d07503621fe

comparison

equal deleted inserted replaced

-:4d9830a9bbb8
+:8200ab154c8a
 Fail,
 Init,
 Start,
 Stop,
 Dispose,
-Last = Dispose
+Reset,
+Last = Reset
 }
 class StateMachine {
 static readonly ExecutionState[,] _transitions;
 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.Ready, Commands.Ok);
+Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Dispose);
 Edge(ExecutionState.Failed, ExecutionState.Disposed, Commands.Dispose);
+Edge(ExecutionState.Failed, ExecutionState.Initializing, Commands.Reset);
 }
 static void Edge(ExecutionState s1, ExecutionState s2, Commands cmd) {
 _transitions[(int)s1, (int)cmd] = s2;
 }
 IPromise m_pending;
 Exception m_lastError;
 readonly StateMachine m_stateMachine;
+readonly bool m_reusable;
-protected RunnableComponent(bool initialized) {
+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(initialized ? ExecutionState.Ready : ExecutionState.Created);
+m_reusable = reusable;
 DisposeTimeout = 10000;
+}
+/// <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) {
 }
 /// <summary>
 /// Gets or sets the timeout to wait for the pending operation to complete. If the pending operation doesn't finish than the component will be disposed anyway.
 /// </summary>
 }
 void ThrowInvalidCommand(Commands cmd) {
 if (m_stateMachine.State == ExecutionState.Disposed)
 throw new ObjectDisposedException(ToString());
-throw new InvalidOperationException(String.Format("Commnd {0} is not allowed in the state {1}", cmd, m_stateMachine.State));
+throw new InvalidOperationException(String.Format("Command {0} is not allowed in the state {1}", cmd, m_stateMachine.State));
 }
-void Move(Commands cmd) {
+bool MoveIfInState(Commands cmd, IPromise pending, Exception error, ExecutionState state) {
-if (!m_stateMachine.Move(cmd))
+ExecutionState prev, current;
-ThrowInvalidCommand(cmd);
+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;
+}
+protected virtual void OnStateChanged(ExecutionState previous, ExecutionState current, Exception error) {
+var h = StateChanged;
+if (h != null)
+h(this, new StateChangeEventArgs {
+State = current,
+LastError = error
+});
 }
 /// <summary>
 /// Moves the component from running to failed state.
 /// </summary>
 /// <param name="error">The exception which is describing the error.</param>
-/// <returns>Returns true if the component is set to the failed state, false - otherwise.
-/// This method works only for the running state, in any other state it will return false.</returns>
 protected bool Fail(Exception error) {
-lock (m_stateMachine) {
+return MoveIfInState(Commands.Fail, null, error, ExecutionState.Running);
-if(m_stateMachine.State == ExecutionState.Running) {
+}
-m_stateMachine.Move(Commands.Fail);
-m_lastError = error;
+/// <summary>
-return true;
+/// 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
-return false;
+/// 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"/>
-void Invoke(Commands cmd, Action action) {
+/// moves component to <see cref="ExecutionState.Initializing"/>.
-lock (m_stateMachine)
+/// The <see cref="OnResetState()"/> is called and if this method completes succesfully the component moved
-Move(cmd);
+/// 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 {
-action();
+OnResetState();
-lock(m_stateMachine)
+Move(Commands.Ok, null, null);
-Move(Commands.Ok);
+return true;
 } catch (Exception err) {
-lock (m_stateMachine) {
+Move(Commands.Fail, null, err);
-Move(Commands.Fail);
-m_lastError = 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, IDeferred> chain) {
 IPromise promise = null;
 IPromise prev;
 var task = new ActionChainTask(action, null, null, true);
-lock (m_stateMachine) {
+Action<Exception> errorOrCancel = e => {
-Move(cmd);
+if (e == null)
+e = new OperationCanceledException();
-prev = m_pending;
+MoveIfPending(Commands.Fail, null, e, promise);
+throw new PromiseTransientException(e);
-Action<Exception> errorOrCancel = e => {
+};
-if (e == null)
-e = new OperationCanceledException();
+promise = task.Then(
+() => MoveIfPending(Commands.Ok, null, null, promise),
-lock (m_stateMachine) {
+errorOrCancel,
-if (m_pending == promise) {
+errorOrCancel
-Move(Commands.Fail);
+);
-m_pending = null;
-m_lastError = e;
+prev = Move(cmd, promise, null);
-}
-}
-throw new PromiseTransientException(e);
-};
-promise = task.Then(
-() => {
-lock(m_stateMachine) {
-if (m_pending == promise) {
-Move(Commands.Ok);
-m_pending = null;
-}
-}
-},
-errorOrCancel,
-errorOrCancel
-);
-m_pending = promise;
-}
 if (prev == null)
 task.Resolve();
 else
 chain(prev, task);
 }
 #region IInitializable implementation
-public void Init() {
+public void Initialize() {
-Invoke(Commands.Init, OnInitialize);
+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() {
 }
 public IPromise Start() {
 return InvokeAsync(Commands.Start, OnStart, null);
 }
 protected virtual IPromise OnStart() {
-return Promise.SUCCESS;
+return Promise.Success;
 }
 public IPromise Stop() {
-return InvokeAsync(Commands.Stop, OnStop, StopPending).Then(Dispose);
+var pending = InvokeAsync(Commands.Stop, OnStop, StopPending);
+return m_reusable ? pending : pending.Then(Dispose);
 }
 protected virtual IPromise OnStop() {
-return Promise.SUCCESS;
+return Promise.Success;
 }
 /// <summary>
 /// Stops the current operation if one exists.
 /// </summary>
 /// 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>
 public void Dispose() {
 IPromise pending;
 lock (m_stateMachine) {
 if (m_stateMachine.State == ExecutionState.Disposed)
 return;
+pending = Move(Commands.Dispose, null, null);
-Move(Commands.Dispose);
+}
 GC.SuppressFinalize(this);
-pending = m_pending;
-m_pending = null;
-}
 if (pending != null) {
 pending.Cancel();
 pending.Timeout(DisposeTimeout).On(
 () => Dispose(true, null),
 err => Dispose(true, err),
 reason => Dispose(true, new OperationCanceledException("The operation is cancelled", reason))
 );
 } else {
-Dispose(true, m_lastError);
+Dispose(true, null);
 }
 }
 ~RunnableComponent() {
 Dispose(false, null);
 }
 #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="lastError">The last error which occured during the component stop.</param>
 protected virtual void Dispose(bool disposing, Exception lastError) {
 }
 }

Mercurial > pub > ImplabNet

comparison Implab/Components/RunnableComponent.cs @ 205:8200ab154c8a v2