private void InternalExecute(NativeActivityContext context, ActivityInstance completedInstance, IEnumerator <T> valueEnumerator)
{
Fx.Assert(this.Body != null && this.Body.Handler != null, "Body and Body.Handler should not be null");
if (!valueEnumerator.MoveNext())
{
if (completedInstance != null)
{
if (completedInstance.State == ActivityInstanceState.Canceled ||
(context.IsCancellationRequested && completedInstance.State == ActivityInstanceState.Faulted))
{
context.MarkCanceled();
}
}
valueEnumerator.Dispose();
return;
}
// After making sure there is another value, let's check for cancelation
if (context.IsCancellationRequested)
{
context.MarkCanceled();
valueEnumerator.Dispose();
return;
}
context.ScheduleAction(this.Body, valueEnumerator.Current, this.OnChildComplete);
}
private void ExecuteNodeChain(NativeActivityContext context, FlowNode node, System.Activities.ActivityInstance completedInstance)
{
if (node == null)
{
if (context.IsCancellationRequested && (completedInstance.State != ActivityInstanceState.Closed))
{
context.MarkCanceled();
}
}
else if (context.IsCancellationRequested)
{
context.MarkCanceled();
}
else
{
FlowNode node2 = node;
do
{
FlowNode node3;
if (this.ExecuteSingleNode(context, node2, out node3))
{
node2 = node3;
}
else
{
this.currentNode.Set(context, node2.Index);
node2 = null;
}
}while (node2 != null);
}
}
protected override void Cancel(NativeActivityContext context)
{
Bookmark bookmark = this.timerBookmark.Get(context);
this.GetTimerExtension(context).CancelTimer(bookmark);
context.RemoveBookmark(bookmark);
context.MarkCanceled();
}
private void OnBranchComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance)
{
PickState pickState = this.pickStateVariable.Get(context);
ReadOnlyCollection <System.Activities.ActivityInstance> children = context.GetChildren();
switch (completedInstance.State)
{
case ActivityInstanceState.Closed:
pickState.HasBranchCompletedSuccessfully = true;
break;
case ActivityInstanceState.Canceled:
case ActivityInstanceState.Faulted:
if ((context.IsCancellationRequested && (children.Count == 0)) && !pickState.HasBranchCompletedSuccessfully)
{
context.MarkCanceled();
context.RemoveAllBookmarks();
}
break;
}
if ((children.Count == 1) && (pickState.ExecuteActionBookmark != null))
{
this.ResumeExecutionActionBookmark(pickState, context);
}
}
void PerformStopWorkflow(NativeActivityContext context, IDSFDataObject dataObject)
{
var service = ExecutableServiceRepository.Instance.Get(dataObject.WorkspaceID, dataObject.ResourceID);
if (service != null)
{
Guid parentInstanceID;
Guid.TryParse(dataObject.ParentInstanceID, out parentInstanceID);
var debugState = new DebugState
{
ID = dataObject.DataListID,
ParentID = parentInstanceID,
WorkspaceID = dataObject.WorkspaceID,
StateType = StateType.End,
StartTime = DateTime.Now,
EndTime = DateTime.Now,
ActivityType = ActivityType.Workflow,
DisplayName = dataObject.ServiceName,
IsSimulation = dataObject.IsOnDemandSimulation,
ServerID = dataObject.ServerID,
ClientID = dataObject.ClientID,
OriginatingResourceID = dataObject.ResourceID,
OriginalInstanceID = dataObject.OriginalInstanceID,
Server = string.Empty,
Version = string.Empty,
SessionID = dataObject.DebugSessionID,
EnvironmentID = dataObject.EnvironmentID,
Name = GetType().Name,
ErrorMessage = "Termination due to error in activity",
HasError = true
};
DebugDispatcher.Instance.Write(debugState);
context.MarkCanceled();
}
}
private void OnBranchComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
PickState pickState = this.pickStateVariable.Get(context);
ReadOnlyCollection <ActivityInstance> executingChildren = context.GetChildren();
switch (completedInstance.State)
{
case ActivityInstanceState.Closed:
pickState.HasBranchCompletedSuccessfully = true;
break;
case ActivityInstanceState.Canceled:
case ActivityInstanceState.Faulted:
if (context.IsCancellationRequested)
{
if (executingChildren.Count == 0 && !pickState.HasBranchCompletedSuccessfully)
{
// All of the branches are complete and we haven't had a single
// one complete successfully and we've been asked to cancel.
context.MarkCanceled();
context.RemoveAllBookmarks();
}
}
break;
}
//the last branch should always resume action bookmark if it's still there
if (executingChildren.Count == 1 && pickState.ExecuteActionBookmark != null)
{
ResumeExecutionActionBookmark(pickState, context);
}
}
protected override void Cancel(NativeActivityContext context)
{
Bookmark bookmark = this.timerBookmark.Get(context);
this.GetTimerExtension(context).CancelTimer(bookmark);
context.RemoveBookmark(bookmark);
context.MarkCanceled();
}
protected override void Cancel(NativeActivityContext context)
{
var subscriptionHandle = this.SubscriptionHandle.Get(context);
subscriptionHandle.ReleaseSubscription(context.GetExtension <Hosting.FolderWatcherExtension>());
context.RemoveAllBookmarks();
context.MarkCanceled();
}
void OnFinallyComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
TryCatchState state = this.state.Get(context);
if (context.IsCancellationRequested && !state.ExceptionHandled)
{
context.MarkCanceled();
}
}
protected override void Cancel(NativeActivityContext context)
{
Bookmark timerBookmark = _timerBookmark.Get(context);
TimerExtension timerExtension = GetTimerExtension(context);
timerExtension.CancelTimer(timerBookmark);
context.RemoveBookmark(timerBookmark);
context.MarkCanceled();
}
protected override void Cancel(NativeActivityContext context)
{
Bookmark bookmark = timerExpiredBookmark.Get(context);
if (bookmark != null)
{
context.GetTimerExtension().CancelTimer(bookmark);
context.RemoveBookmark(bookmark);
}
context.MarkCanceled();
}
private void ExecuteNodeChain(NativeActivityContext context, FlowNode node, ActivityInstance completedInstance)
{
if (node == null)
{
if (context.IsCancellationRequested)
{
Fx.Assert(completedInstance != null, "cannot request cancel if we never scheduled any children");
// we are done but the last child didn't complete successfully
if (completedInstance.State != ActivityInstanceState.Closed)
{
context.MarkCanceled();
}
}
return;
}
if (context.IsCancellationRequested)
{
// we're not done and cancel has been requested
context.MarkCanceled();
return;
}
Fx.Assert(node != null, "caller should validate");
FlowNode current = node;
do
{
FlowNode next;
if (this.ExecuteSingleNode(context, current, out next))
{
current = next;
}
else
{
_currentNode.Set(context, current.Index);
current = null;
}
}while (current != null);
}
private void InternalExecute(NativeActivityContext context, System.Activities.ActivityInstance completedInstance, IEnumerator <T> valueEnumerator)
{
if (!valueEnumerator.MoveNext())
{
if ((completedInstance != null) && ((completedInstance.State == ActivityInstanceState.Canceled) || (context.IsCancellationRequested && (completedInstance.State == ActivityInstanceState.Faulted))))
{
context.MarkCanceled();
}
valueEnumerator.Dispose();
}
else if (context.IsCancellationRequested)
{
context.MarkCanceled();
valueEnumerator.Dispose();
}
else
{
context.ScheduleAction <T>(this.Body, valueEnumerator.Current, this.OnChildComplete, null);
}
}
protected override void Cancel(NativeActivityContext context)
{
var bookmark = this.timerExpiredBookmark.Get(context);
if (bookmark != null)
{
context.GetTimerExtension().CancelTimer(bookmark);
context.RemoveBookmark(bookmark);
}
context.MarkCanceled();
}
protected override void Cancel(NativeActivityContext context)
{
context.CancelChildren();
var bookmark = bookmarkProgress.Get(context);
var extension = context.GetExtension <Hosting.FileCopyExtension>();
extension.Cancel(bookmark.Name);
this.noPersistHandle.Get(context).Exit(context);
context.RemoveBookmark(bookmark);
context.MarkCanceled();
}
private void OnBodyComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance)
{
if ((completedInstance.State == ActivityInstanceState.Canceled) || (context.IsCancellationRequested && (completedInstance.State == ActivityInstanceState.Faulted)))
{
this.suppressCancel.Set(context, true);
context.MarkCanceled();
if (this.CancellationHandler != null)
{
FaultCallback onFaulted = new FaultCallback(this.OnExceptionFromCancelHandler);
context.ScheduleActivity(this.CancellationHandler, onFaulted);
}
}
}
private void OnBodyComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance)
{
if ((completedInstance.State == ActivityInstanceState.Canceled) || (context.IsCancellationRequested && (completedInstance.State == ActivityInstanceState.Faulted)))
{
this.suppressCancel.Set(context, true);
context.MarkCanceled();
if (this.CancellationHandler != null)
{
FaultCallback onFaulted = new FaultCallback(this.OnExceptionFromCancelHandler);
context.ScheduleActivity(this.CancellationHandler, onFaulted);
}
}
}
private void OnIterateCompleted(NativeActivityContext context, ActivityInstance completedInstance)
{
if (context.IsCancellationRequested)
{
context.MarkCanceled();
_break = true;
}
if (++_currentIteration < _totalIterations && !_break)
{
ExecuteNext(context);
}
}
private void OnIterateCompleted(NativeActivityContext context, ActivityInstance completedInstance)
{
if (context.IsCancellationRequested)
{
context.MarkCanceled();
_break = true;
}
if (!_break && ++_index < _iterations)
{
ExecuteNext(context);
}
}
void InternalExecute(NativeActivityContext context, IEnumerator valueEnumerator)
{
if (!valueEnumerator.MoveNext())
{
OnForEachComplete(valueEnumerator);
return;
}
// After making sure there is another value, let's check for cancelation
if (context.IsCancellationRequested)
{
context.MarkCanceled();
OnForEachComplete(valueEnumerator);
return;
}
context.ScheduleAction(this.Body, valueEnumerator.Current, this.OnChildComplete);
}
private void OnBodyComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
// Determine whether to run the Cancel based on whether the body
// canceled rather than whether cancel had been requested.
if (completedInstance.State == ActivityInstanceState.Canceled ||
(context.IsCancellationRequested && completedInstance.State == ActivityInstanceState.Faulted))
{
// We don't cancel the cancel handler
this.suppressCancel.Set(context, true);
context.MarkCanceled();
if (this.CancellationHandler != null)
{
context.ScheduleActivity(this.CancellationHandler, onFaulted: new FaultCallback(OnExceptionFromCancelHandler));
}
}
}
private void OnBodyComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance)
{
if ((this.CompletionCondition != null) && !this.hasCompleted.Get(context))
{
if ((completedInstance.State != ActivityInstanceState.Closed) && context.IsCancellationRequested)
{
context.MarkCanceled();
this.hasCompleted.Set(context, true);
}
else
{
if (this.onConditionComplete == null)
{
this.onConditionComplete = new CompletionCallback <bool>(this.OnConditionComplete);
}
context.ScheduleActivity <bool>(this.CompletionCondition, this.onConditionComplete, null);
}
}
}
private void OnBranchComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance)
{
if ((this.CompletionCondition != null) && !this.hasCompleted.Get(context))
{
if ((completedInstance.State != ActivityInstanceState.Closed) && context.IsCancellationRequested)
{
context.MarkCanceled();
this.hasCompleted.Set(context, true);
}
else
{
if (this.onConditionComplete == null)
{
this.onConditionComplete = new CompletionCallback<bool>(this.OnConditionComplete);
}
context.ScheduleActivity<bool>(this.CompletionCondition, this.onConditionComplete, null);
}
}
}
//</Snippet2>
void OnBodyComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
// for the completion condition, we handle cancelation ourselves
if (this.CompletionCondition != null && !this.hasCompleted.Get(context))
{
if (completedInstance.State != ActivityInstanceState.Closed && context.IsCancellationRequested)
{
// If we hadn't completed before getting canceled
// or one of our iteration of body cancels then we'll consider
// ourself canceled.
context.MarkCanceled();
this.hasCompleted.Set(context, true);
}
else
{
this.onConditionComplete ??= new CompletionCallback <bool>(OnConditionComplete);
context.ScheduleActivity(CompletionCondition, this.onConditionComplete);
}
}
}
private void OnBranchComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
if (this.CompletionCondition != null && !this.hasCompleted.Get(context))
{
// If we haven't completed, we've been requested to cancel, and we've had a child
// end in a non-Closed state then we should cancel ourselves.
if (completedInstance.State != ActivityInstanceState.Closed && context.IsCancellationRequested)
{
context.MarkCanceled();
this.hasCompleted.Set(context, true);
return;
}
if (this.onConditionComplete == null)
{
this.onConditionComplete = new CompletionCallback <bool>(OnConditionComplete);
}
context.ScheduleActivity(this.CompletionCondition, this.onConditionComplete);
}
}
public void Cancel(NativeActivityContext context)
{
bool bookmarkResumed = _bookmarkResumed.Get(context);
if (!bookmarkResumed)
{
CancellationTokenSource cancellationTokenSource = _cancellationTokenSource.Get(context);
cancellationTokenSource.Cancel();
cancellationTokenSource.Dispose();
}
context.MarkCanceled();
// Overriding the Cancel method inhibits the propagation of cancellation requests to children.
context.CancelChildren();
if (!bookmarkResumed)
{
_noPersistHandle.Get(context).Exit(context);
}
}
void OnBodyComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
// for the completion condition, we handle cancelation ourselves
if (this.CompletionCondition != null && !this.hasCompleted.Get(context))
{
if (completedInstance.State != ActivityInstanceState.Closed && context.IsCancellationRequested)
{
// If we hadn't completed before getting canceled
// or one of our iteration of body cancels then we'll consider
// ourself canceled.
context.MarkCanceled();
this.hasCompleted.Set(context, true);
}
else
{
if (this.CompletionCondition != null)
{
if (this.onConditionComplete == null)
{
this.onConditionComplete = new CompletionCallback <bool>(OnConditionComplete);
}
context.ScheduleActivity(CompletionCondition, this.onConditionComplete);
}
}
}
else
{
if (!this.hasCompleted.Get(context))
{
// get the next child and schedule it!
IEnumerator <T> enumerator = this.valueEnumerator.Get(context);
if (this.valueEnumerator.Get(context).MoveNext())
{
context.ScheduleAction(this.Body, this.valueEnumerator.Get(context).Current, onBodyComplete);
}
}
}
}
private void OnCanceledOrCompensated(NativeActivityContext context, Bookmark bookmark, object value)
{
CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>();
long compensationId = (long)value;
CompensationTokenData compensationToken = compensationExtension.Get(compensationId);
switch (compensationToken.CompensationState)
{
case CompensationState.Compensating:
compensationToken.CompensationState = CompensationState.Compensated;
break;
case CompensationState.Canceling:
compensationToken.CompensationState = CompensationState.Canceled;
break;
}
if (TD.CompensationStateIsEnabled())
{
TD.CompensationState(compensationToken.DisplayName, compensationToken.CompensationState.ToString());
}
this.AppCompletionCleanup(context, compensationExtension, compensationToken);
context.MarkCanceled();
}
private void OnCanceledOrCompensated(NativeActivityContext context, Bookmark bookmark, object value)
{
CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>();
Fx.Assert(compensationExtension != null, "CompensationExtension must be valid");
long compensationId = (long)value;
CompensationTokenData compensationToken = compensationExtension.Get(compensationId);
Fx.Assert(compensationToken != null, "CompensationTokenData must be valid");
switch (compensationToken.CompensationState)
{
case CompensationState.Canceling:
compensationToken.CompensationState = CompensationState.Canceled;
break;
case CompensationState.Compensating:
compensationToken.CompensationState = CompensationState.Compensated;
break;
default:
break;
}
if (TD.CompensationStateIsEnabled())
{
TD.CompensationState(compensationToken.DisplayName, compensationToken.CompensationState.ToString());
}
AppCompletionCleanup(context, compensationExtension, compensationToken);
// Mark the activity as canceled.
context.MarkCanceled();
}
private void OnBranchComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance)
{
PickState pickState = this.pickStateVariable.Get(context);
ReadOnlyCollection<System.Activities.ActivityInstance> children = context.GetChildren();
switch (completedInstance.State)
{
case ActivityInstanceState.Closed:
pickState.HasBranchCompletedSuccessfully = true;
break;
case ActivityInstanceState.Canceled:
case ActivityInstanceState.Faulted:
if ((context.IsCancellationRequested && (children.Count == 0)) && !pickState.HasBranchCompletedSuccessfully)
{
context.MarkCanceled();
context.RemoveAllBookmarks();
}
break;
}
if ((children.Count == 1) && (pickState.ExecuteActionBookmark != null))
{
this.ResumeExecutionActionBookmark(pickState, context);
}
}
protected override void Cancel(NativeActivityContext context)
{
CancelInternal(context);
context.MarkCanceled();
}
protected override void Cancel(NativeActivityContext context)
{
var subscriptionHandle = this.SubscriptionHandle.Get(context);
subscriptionHandle.ReleaseSubscription(context.GetExtension<Hosting.FolderWatcherExtension>());
context.RemoveAllBookmarks();
context.MarkCanceled();
}
protected override void Execute(NativeActivityContext context)
{
context.MarkCanceled();
}
void OnBranchComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
PickState pickState = this.pickStateVariable.Get(context);
ReadOnlyCollection<ActivityInstance> executingChildren = context.GetChildren();
switch (completedInstance.State)
{
case ActivityInstanceState.Closed:
pickState.HasBranchCompletedSuccessfully = true;
break;
case ActivityInstanceState.Canceled:
case ActivityInstanceState.Faulted:
if (context.IsCancellationRequested)
{
if (executingChildren.Count == 0 && !pickState.HasBranchCompletedSuccessfully)
{
// All of the branches are complete and we haven't had a single
// one complete successfully and we've been asked to cancel.
context.MarkCanceled();
context.RemoveAllBookmarks();
}
}
break;
}
//the last branch should always resume action bookmark if it's still there
if (executingChildren.Count == 1 && pickState.ExecuteActionBookmark != null)
{
ResumeExecutionActionBookmark(pickState, context);
}
}
protected override void Cancel(NativeActivityContext context)
{
context.CancelChildren();
var bookmark = bookmarkProgress.Get(context);
var extension = context.GetExtension<Hosting.FileCopyExtension>();
extension.Cancel(bookmark.Name);
this.noPersistHandle.Get(context).Exit(context);
context.RemoveBookmark(bookmark);
context.MarkCanceled();
}
protected override void Cancel(NativeActivityContext context)
{
UnregisterReceiveNotification(context);
context.MarkCanceled();
}
void InternalExecute(NativeActivityContext context, IEnumerator valueEnumerator)
{
if (!valueEnumerator.MoveNext())
{
OnForEachComplete(valueEnumerator);
return;
}
// After making sure there is another value, let's check for cancelation
if (context.IsCancellationRequested)
{
context.MarkCanceled();
OnForEachComplete(valueEnumerator);
return;
}
context.ScheduleAction(this.Body, valueEnumerator.Current, this.OnChildComplete);
}
void OnBodyComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
// for the completion condition, we handle cancelation ourselves
if (this.CompletionCondition != null && !this.hasCompleted.Get(context))
{
if (completedInstance.State != ActivityInstanceState.Closed && context.IsCancellationRequested)
{
// If we hadn't completed before getting canceled
// or one of our iteration of body cancels then we'll consider
// ourself canceled.
context.MarkCanceled();
this.hasCompleted.Set(context, true);
}
else
{
if (this.onConditionComplete == null)
{
this.onConditionComplete = new CompletionCallback<bool>(OnConditionComplete);
}
context.ScheduleActivity(CompletionCondition, this.onConditionComplete);
}
}
}
void OnBranchComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
if (this.CompletionCondition != null && !this.hasCompleted.Get(context))
{
// If we haven't completed, we've been requested to cancel, and we've had a child
// end in a non-Closed state then we should cancel ourselves.
if (completedInstance.State != ActivityInstanceState.Closed && context.IsCancellationRequested)
{
context.MarkCanceled();
this.hasCompleted.Set(context, true);
return;
}
if (this.onConditionComplete == null)
{
this.onConditionComplete = new CompletionCallback<bool>(OnConditionComplete);
}
context.ScheduleActivity(this.CompletionCondition, this.onConditionComplete);
}
}
void OnBodyComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
// Determine whether to run the Cancel based on whether the body
// canceled rather than whether cancel had been requested.
if (completedInstance.State == ActivityInstanceState.Canceled ||
(context.IsCancellationRequested && completedInstance.State == ActivityInstanceState.Faulted))
{
// We don't cancel the cancel handler
this.suppressCancel.Set(context, true);
context.MarkCanceled();
if (this.CancellationHandler != null)
{
context.ScheduleActivity(this.CancellationHandler, onFaulted: new FaultCallback(OnExceptionFromCancelHandler));
}
}
}
protected override void Cancel(NativeActivityContext context)
{
try
{
if (this.bookmarking.Get(context))
{
NoPersistHandle noPersistHandle = this.noPersistHandle.Get(context);
noPersistHandle.Enter(context);
}
PSActivityContext item = null;
HostParameterDefaults extension = context.GetExtension<HostParameterDefaults>();
if (extension != null && extension.AsyncExecutionCollection != null)
{
Dictionary<string, PSActivityContext> asyncExecutionCollection = extension.AsyncExecutionCollection;
if (asyncExecutionCollection.ContainsKey(context.ActivityInstanceId))
{
item = asyncExecutionCollection[context.ActivityInstanceId];
asyncExecutionCollection.Remove(context.ActivityInstanceId);
}
}
if (item == null)
{
item = this.psActivityContextImplementationVariable.Get(context);
}
item.IsCanceled = true;
this.psActivityContextImplementationVariable.Set(context, item);
this.Tracer.WriteMessage(string.Format(CultureInfo.InvariantCulture, "PowerShell activity: Executing cancel request.", new object[0]));
if (item.commandQueue != null && !item.commandQueue.IsEmpty)
{
ActivityImplementationContext[] array = item.commandQueue.ToArray();
for (int i = 0; i < (int)array.Length; i++)
{
ActivityImplementationContext activityImplementationContext = array[i];
RunCommandsArguments runCommandsArgument = null;
PSActivity.ArgsTable.TryGetValue(activityImplementationContext.PowerShellInstance.InstanceId, out runCommandsArgument);
if (runCommandsArgument != null)
{
PSActivity.RemoveHandlersFromStreams(activityImplementationContext.PowerShellInstance, runCommandsArgument);
}
}
}
if (item.runningCommands != null && item.runningCommands.Count > 0)
{
lock (item.runningCommands)
{
foreach (PowerShell key in item.runningCommands.Keys)
{
RunCommandsArguments runCommandsArgument1 = null;
PSActivity.ArgsTable.TryGetValue(key.InstanceId, out runCommandsArgument1);
if (runCommandsArgument1 == null)
{
continue;
}
PSActivity.RemoveHandlersFromStreams(key, runCommandsArgument1);
}
}
}
item.Cancel();
}
finally
{
context.MarkCanceled();
}
}