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)));
}
