public override void Start(CancellationToken cancellationToken) { base.Start(cancellationToken); cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); stopPending = false; try { Run(cancellationTokenSource.Token); } catch (OperationCanceledException) { } catch (AggregateException ae) { ae.FlattenAndHandle(new[] { typeof(OperationCanceledException) }, e => OnExceptionOccurred(e)); } catch (Exception e) { OnExceptionOccurred(e); } cancellationTokenSource.Dispose(); cancellationTokenSource = null; if (stopPending) { ExecutionStack.Clear(); } if (stopPending || !CanContinue) { OnStopped(); } else { OnPaused(); } }
/// <summary> /// Deals with the next operation, if it is an <see cref="AtomicOperation"/> it is executed, /// if it is a <see cref="CompositeOperation"/> its single operations are pushed on the execution stack. /// </summary> /// <remarks>If an error occurs during the execution the operation is aborted and the operation /// is pushed on the stack again.<br/> /// If the execution was successful <see cref="EngineBase.OnOperationExecuted"/> is called.</remarks> protected virtual void ProcessNextOperation(bool logOperations, CancellationToken cancellationToken) { IAtomicOperation atomicOperation = CurrentOperation as IAtomicOperation; OperationCollection operations = CurrentOperation as OperationCollection; if (atomicOperation != null && operations != null) throw new InvalidOperationException("Current operation is both atomic and an operation collection"); if (atomicOperation != null) { if (logOperations) Log.LogMessage(string.Format("Performing atomic operation {0}", Utils.Name(atomicOperation))); PerformAtomicOperation(atomicOperation, cancellationToken); } else if (operations != null) { if (logOperations) Log.LogMessage("Expanding operation collection"); ExecutionStack.AddRange(operations.Reverse()); CurrentOperation = null; } else if (ExecutionStack.Count > 0) { if (logOperations) Log.LogMessage("Popping execution stack"); CurrentOperation = ExecutionStack.Last(); ExecutionStack.RemoveAt(ExecutionStack.Count - 1); } else { if (logOperations) Log.LogMessage("Nothing to do"); } OperatorTrace.Regenerate(CurrentAtomicOperation); }
public virtual void Step(bool skipStackOperations) { OnStarted(); cancellationTokenSource = new CancellationTokenSource(); stopPending = false; lastUpdateTime = DateTime.UtcNow; timer.Start(); try { ProcessNextOperation(true, cancellationTokenSource.Token); while (skipStackOperations && !(CurrentOperation is IAtomicOperation) && CanContinue) { ProcessNextOperation(true, cancellationTokenSource.Token); } } catch (Exception ex) { OnExceptionOccurred(ex); } timer.Stop(); ExecutionTime += DateTime.UtcNow - lastUpdateTime; cancellationTokenSource.Dispose(); cancellationTokenSource = null; if (stopPending) { ExecutionStack.Clear(); } if (stopPending || !CanContinue) { OnStopped(); } else { OnPaused(); } }
protected virtual void PerformAtomicOperation(IAtomicOperation operation, CancellationToken cancellationToken) { if (operation != null) { try { IOperation successor = operation.Operator.Execute((IExecutionContext)operation, cancellationToken); if (successor != null) { OperatorTrace.RegisterParenthood(operation, successor); ExecutionStack.Add(successor); } CurrentOperation = null; } catch (Exception ex) { if (ex is OperationCanceledException) { throw ex; } else { throw new OperatorExecutionException(operation.Operator, ex); } } } }
public DebugEngine() : base() { Log = new Log(); ExecutionStack = new ExecutionStack(); OperatorTrace = new OperatorTrace(); InitializeTimer(); }
public sealed override void Prepare() { base.Prepare(); ExecutionStack.Clear(); CurrentOperation = null; OperatorTrace.Reset(); OnPrepared(); }
public void Prepare(IOperation initialOperation) { base.Prepare(); ExecutionStack.Clear(); if (initialOperation != null) ExecutionStack.Add(initialOperation); CurrentOperation = null; OperatorTrace.Reset(); OnPrepared(); }
public override void Stop() { CurrentOperation = null; base.Stop(); if (ExecutionState == ExecutionState.Paused) { ExecutionStack.Clear(); OnStopped(); } else { stopPending = true; cancellationTokenSource.Cancel(); } }
public override void Start() { base.Start(); cancellationTokenSource = new CancellationTokenSource(); stopPending = false; Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token); task.ContinueWith(t => { try { t.Wait(); } catch (AggregateException ex) { try { ex.Flatten().Handle(x => x is OperationCanceledException); } catch (AggregateException remaining) { if (remaining.InnerExceptions.Count == 1) { OnExceptionOccurred(remaining.InnerExceptions[0]); } else { OnExceptionOccurred(remaining); } } } cancellationTokenSource.Dispose(); cancellationTokenSource = null; if (stopPending) { ExecutionStack.Clear(); } if (stopPending || !CanContinue) { OnStopped(); } else { OnPaused(); } }); }
protected ExecutionStack(ExecutionStack original, Cloner cloner) { cloner.RegisterClonedObject(original, this); AddRange(original.Select(op => cloner.Clone(op))); }