protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
CleanUp(executionContext);
Debug.Assert(executionContext.Activity == this);
bool canCloseNow = true;
ActivityExecutionContextManager contextManager = executionContext.ExecutionContextManager;
foreach (ActivityExecutionContext existingContext in contextManager.ExecutionContexts)
{
if (existingContext.Activity.Parent == this)
{
canCloseNow = false;
if (existingContext.Activity.ExecutionStatus == ActivityExecutionStatus.Executing)
{
existingContext.CancelActivity(existingContext.Activity);
}
}
}
return(canCloseNow ? ActivityExecutionStatus.Closed : this.ExecutionStatus);
}
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (sender == null)
{
throw new ArgumentNullException("sender");
}
ActivityExecutionContext context = sender as ActivityExecutionContext;
if (context == null)
{
throw new ArgumentException(SR.Error_SenderMustBeActivityExecutionContext, "sender");
}
e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this);
ActivityExecutionContextManager executionContextManager = context.ExecutionContextManager;
executionContextManager.CompleteExecutionContext(executionContextManager.GetExecutionContext(e.Activity));
if (!this.TryNextIteration(context))
{
context.CloseActivity();
}
}
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (this.EnabledActivities.Count == 0)
{
return(ActivityExecutionStatus.Closed);
}
Activity childActivity = this.EnabledActivities[0];
ActivityExecutionContextManager contextManager = executionContext.ExecutionContextManager;
ActivityExecutionContext childContext = contextManager.GetExecutionContext(childActivity);
if (childContext != null)
{
if (childContext.Activity.ExecutionStatus == ActivityExecutionStatus.Executing)
{
childContext.CancelActivity(childContext.Activity);
}
return(ActivityExecutionStatus.Canceling);
}
return(ActivityExecutionStatus.Closed);
}
private bool TryCancelChild(ActivityExecutionContext outerProvider, ChildExecutionStateInfo childStateInfo)
{
bool flag = false;
ActivityExecutionContextManager executionContextManager = outerProvider.ExecutionContextManager;
ActivityExecutionContext executionContext = this.GetExecutionContext(executionContextManager, childStateInfo.RunId);
if (executionContext != null)
{
switch (executionContext.Activity.ExecutionStatus)
{
case ActivityExecutionStatus.Executing:
executionContext.CancelActivity(executionContext.Activity);
return(true);
case ActivityExecutionStatus.Canceling:
case ActivityExecutionStatus.Faulting:
return(true);
case ActivityExecutionStatus.Closed:
case ActivityExecutionStatus.Compensating:
return(flag);
}
return(flag);
}
if ((base.ExecutionStatus != ActivityExecutionStatus.Executing) && (childStateInfo.Status == ChildRunStatus.PendingExecute))
{
childStateInfo.Status = ChildRunStatus.Completed;
}
return(flag);
}
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (this.ActivityState == null)
{
return(ActivityExecutionStatus.Closed);
}
bool scopeCompleted = this.IsScopeCompleted;
bool canCloseNow = true;
for (int i = 0; i < this.EnabledActivities.Count; ++i)
{
EventDrivenActivity childActivity = this.EnabledActivities[i] as EventDrivenActivity;
EventHandlerEventActivitySubscriber eventActivitySubscriber = this.ActivityState[i] as EventHandlerEventActivitySubscriber;
eventActivitySubscriber.PendingExecutionCount = 0;
ActivityExecutionContextManager contextManager = executionContext.ExecutionContextManager;
ActivityExecutionContext childContext = contextManager.GetExecutionContext(childActivity);
if (childContext != null)
{
switch (childContext.Activity.ExecutionStatus)
{
case ActivityExecutionStatus.Canceling:
case ActivityExecutionStatus.Faulting:
canCloseNow = false;
break;
case ActivityExecutionStatus.Executing:
childContext.CancelActivity(childContext.Activity);
canCloseNow = false;
break;
}
}
if (!scopeCompleted) //UnSubscribe from event.
{
childActivity.EventActivity.Unsubscribe(executionContext, eventActivitySubscriber);
}
}
if (canCloseNow)
{
this.ActivityState = null;
return(ActivityExecutionStatus.Closed);
}
else
{
return(this.ExecutionStatus);
}
}
private static ActivityExecutionContext GetChildExecutionContext(ActivityExecutionContext context, Activity childActivity, bool createIfNotExists)
{
ActivityExecutionContextManager executionContextManager = context.ExecutionContextManager;
ActivityExecutionContext executionContext = executionContextManager.GetExecutionContext(childActivity);
if ((executionContext == null) && createIfNotExists)
{
executionContext = executionContextManager.CreateExecutionContext(childActivity);
}
return(executionContext);
}
private ActivityExecutionContext GetExecutionContext(ActivityExecutionContextManager contextManager, Guid contextIdGuid)
{
foreach (ActivityExecutionContext context in contextManager.ExecutionContexts)
{
if (context.ContextGuid == contextIdGuid)
{
return(context);
}
}
return(null);
}
private bool AllHandlersAreQuiet(EventHandlersActivity handlers, ActivityExecutionContext context)
{
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
for (int i = 0; i < handlers.EnabledActivities.Count; ++i)
{
EventDrivenActivity eventDriven = handlers.EnabledActivities[i] as EventDrivenActivity;
if (contextManager.GetExecutionContext(eventDriven) != null || (handlers.ActivityState != null && handlers.ActivityState[i].PendingExecutionCount > 0))
{
return(false);
}
}
return(true);
}
private bool AllHandlersAreQuiet(EventHandlersActivity handlers, ActivityExecutionContext context)
{
ActivityExecutionContextManager executionContextManager = context.ExecutionContextManager;
for (int i = 0; i < handlers.EnabledActivities.Count; i++)
{
EventDrivenActivity activity = handlers.EnabledActivities[i] as EventDrivenActivity;
if ((executionContextManager.GetExecutionContext(activity) != null) || ((handlers.ActivityState != null) && (handlers.ActivityState[i].PendingExecutionCount > 0)))
{
return(false);
}
}
return(true);
}
private void OnUnsubscribeAndClose(object sender, EventArgs args)
{
if (sender == null)
{
throw new ArgumentNullException("sender");
}
if (args == null)
{
throw new ArgumentNullException("args");
}
ActivityExecutionContext context = (ActivityExecutionContext)sender;
if (context == null)
{
throw new ArgumentException("sender");
}
EventHandlersActivity handlers = context.Activity as EventHandlersActivity;
if (context.Activity.ExecutionStatus != ActivityExecutionStatus.Executing)
{
return;
}
Debug.Assert(!handlers.IsScopeCompleted, "Only notified of scope body completion once");
handlers.IsScopeCompleted = true;
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
bool readyToClose = true;
for (int i = 0; i < handlers.EnabledActivities.Count; ++i)
{
EventDrivenActivity evtDriven = handlers.EnabledActivities[i] as EventDrivenActivity;
EventHandlerEventActivitySubscriber eventSubscriber = handlers.ActivityState[i];
evtDriven.EventActivity.Unsubscribe(context, eventSubscriber);
if (contextManager.GetExecutionContext(evtDriven) != null || handlers.ActivityState[i].PendingExecutionCount != 0)
{
readyToClose = false;
}
}
if (readyToClose)
{
handlers.ActivityState = null;
context.CloseActivity();
}
}
private void CleanupChildAtClosure(ActivityExecutionContext context, Activity childActivity)
{
Debug.Assert(context != null);
Debug.Assert(childActivity != null);
Debug.Assert(childActivity.ExecutionStatus == ActivityExecutionStatus.Closed);
//UnSubsribe child closure of completed activity.
childActivity.UnregisterForStatusChange(Activity.ClosedEvent, this);
//Dispose the execution context;
ActivityExecutionContext childContext = GetChildExecutionContext(context, childActivity, false);
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
contextManager.CompleteExecutionContext(childContext);
}
public void Start()
{
WorkflowSchedulerService sheduler;
// init all activities
ActivityExecutionContextManager manager = new ActivityExecutionContextManager(this);
ActivityExecutionContext context = manager.CreateExecutionContext(GetWorkflowDefinition());
GetWorkflowDefinition().InitializeInternal(context);
sheduler = (WorkflowSchedulerService)runtime.GetService(typeof(WorkflowSchedulerService));
//sheduler.Schedule (new WaitCallback (WorkflowProcessor.RunWorkflow), guid);
WorkflowProcessor.RunWorkflow(guid);
}
private static ActivityExecutionContext GetChildExecutionContext(ActivityExecutionContext context, Activity childActivity, bool createIfNotExists)
{
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
ActivityExecutionContext childContext = contextManager.GetExecutionContext(childActivity);
if (childContext != null)
{
return(childContext);
}
if (createIfNotExists)
{
childContext = contextManager.CreateExecutionContext(childActivity);
}
return(childContext);
}
private static void CleanupChildAtClosure(ActivityExecutionContext context, Activity childActivity)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (childActivity == null)
{
throw new ArgumentNullException("childActivity");
}
StateActivity state = (StateActivity)context.Activity;
GetExecutionState(state);
childActivity.Closed -= new EventHandler <ActivityExecutionStatusChangedEventArgs>(state.HandleChildActivityClosed);
ActivityExecutionContextManager executionContextManager = context.ExecutionContextManager;
ActivityExecutionContext executionContext = executionContextManager.GetExecutionContext(childActivity);
executionContextManager.CompleteExecutionContext(executionContext);
}
bool TryCancelChild(ActivityExecutionContext outerProvider, ChildExecutionStateInfo childStateInfo)
{
// schedule cancellation of the child in the inner execution context
bool fScheduledCancel = false;
// returns true iff scheduled cancel on one execution of the template
// false if execution already closed
// get the execution context for this run
ActivityExecutionContextManager contextManager = outerProvider.ExecutionContextManager;
ActivityExecutionContext innerProvider = GetExecutionContext(contextManager, childStateInfo.RunId);
if (innerProvider != null)
{
switch (innerProvider.Activity.ExecutionStatus)
{
case ActivityExecutionStatus.Executing:
// schedule cancellation on child
innerProvider.CancelActivity(innerProvider.Activity);
fScheduledCancel = true;
break;
case ActivityExecutionStatus.Canceling:
case ActivityExecutionStatus.Faulting:
fScheduledCancel = true;
break;
default:
// do nothing
break;
}
}
else
{
//Finish the run if it is pending for execution.
if (this.ExecutionStatus != ActivityExecutionStatus.Executing && childStateInfo.Status == ChildRunStatus.PendingExecute)
{
childStateInfo.Status = ChildRunStatus.Completed;
}
}
return(fScheduledCancel);
}
private static void CleanupChildAtClosure(ActivityExecutionContext context, Activity childActivity)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (childActivity == null)
{
throw new ArgumentNullException("childActivity");
}
StateActivity state = (StateActivity)context.Activity;
StateMachineExecutionState executionState = GetExecutionState(state);
childActivity.Closed -= state.HandleChildActivityClosed;
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
ActivityExecutionContext childContext = contextManager.GetExecutionContext(childActivity);
contextManager.CompleteExecutionContext(childContext);
}
void IActivityEventListener <QueueEventArgs> .OnEvent(object sender, QueueEventArgs e)
{
if (sender == null)
{
throw new ArgumentNullException("sender");
}
if (e == null)
{
throw new ArgumentNullException("e");
}
ActivityExecutionContext context = sender as ActivityExecutionContext;
if (context == null)
{
throw new ArgumentException("sender");
}
EventHandlersActivity handlers = context.Activity as EventHandlersActivity;
if (handlers.ExecutionStatus != ActivityExecutionStatus.Executing)
{
return;
}
if (!handlers.EnabledActivities.Contains(eventDrivenActivity))
{
return; //Activity is dynamically removed.
}
if (IsBlocked)
{
IsBlocked = false;
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
ActivityExecutionContext childContext = contextManager.CreateExecutionContext(eventDrivenActivity);
childContext.Activity.RegisterForStatusChange(Activity.ClosedEvent, handlers);
childContext.ExecuteActivity(childContext.Activity);
}
else
{
PendingExecutionCount++;
}
}
protected sealed override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
ActivityExecutionStatus status;
ActivityExecutionContextManager manager = executionContext.ExecutionContextManager;
ReadOnlyCollection <ActivityExecutionContext> contexts = manager.ExecutionContexts;
Console.WriteLine("***ourCodeActivity.Execute {0}", contexts.Count);
IComparable queue_name = "our_queue";
WorkflowQueuingService qService = executionContext.GetService <WorkflowQueuingService> ();
if (!qService.Exists(queue_name))
{
Console.WriteLine("CreatingQue");
qService.CreateWorkflowQueue(queue_name, true);
}
status = base.Execute(executionContext);
return(status);
}
private void ExecuteTemplate(ActivityExecutionContext executionContext, ChildExecutionStateInfo childStateInfo)
{
ActivityExecutionContextManager executionContextManager = executionContext.ExecutionContextManager;
ActivityExecutionContext childContext = executionContextManager.CreateExecutionContext(base.EnabledActivities[0]);
childStateInfo.RunId = childContext.ContextGuid;
childStateInfo.Status = ChildRunStatus.Running;
try
{
base.RaiseGenericEvent <ReplicatorChildEventArgs>(ChildInitializedEvent, this, new ReplicatorChildEventArgs(childStateInfo.InstanceData, childContext.Activity));
}
catch
{
childStateInfo.RunId = Guid.Empty;
childStateInfo.Status = ChildRunStatus.Completed;
executionContextManager.CompleteExecutionContext(childContext);
throw;
}
childContext.ExecuteActivity(childContext.Activity);
childContext.Activity.RegisterForStatusChange(Activity.ClosedEvent, new ReplicatorSubscriber(this, childContext.ContextGuid));
}
private void OnUnsubscribeAndClose(object sender, EventArgs args)
{
if (sender == null)
{
throw new ArgumentNullException("sender");
}
if (args == null)
{
throw new ArgumentNullException("args");
}
ActivityExecutionContext parentContext = (ActivityExecutionContext)sender;
if (parentContext == null)
{
throw new ArgumentException("sender");
}
EventHandlersActivity activity = parentContext.Activity as EventHandlersActivity;
if (parentContext.Activity.ExecutionStatus == ActivityExecutionStatus.Executing)
{
activity.IsScopeCompleted = true;
ActivityExecutionContextManager executionContextManager = parentContext.ExecutionContextManager;
bool flag = true;
for (int i = 0; i < activity.EnabledActivities.Count; i++)
{
EventDrivenActivity activity2 = activity.EnabledActivities[i] as EventDrivenActivity;
EventHandlerEventActivitySubscriber parentEventHandler = activity.ActivityState[i];
activity2.EventActivity.Unsubscribe(parentContext, parentEventHandler);
if ((executionContextManager.GetExecutionContext(activity2) != null) || (activity.ActivityState[i].PendingExecutionCount != 0))
{
flag = false;
}
}
if (flag)
{
activity.ActivityState = null;
parentContext.CloseActivity();
}
}
}
private static void ExecuteChild(ActivityExecutionContext context, Activity childActivity)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (childActivity == null)
{
throw new ArgumentNullException("childActivity");
}
StateActivity state = (StateActivity)context.Activity;
StateMachineExecutionState executionState = GetExecutionState(state);
Debug.Assert(!executionState.SchedulerBusy);
executionState.SchedulerBusy = true;
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
ActivityExecutionContext childContext = contextManager.CreateExecutionContext(childActivity);
childContext.Activity.Closed += state.HandleChildActivityClosed;
childContext.ExecuteActivity(childContext.Activity);
}
private bool TryNextIteration(ActivityExecutionContext context)
{
if (this.ExecutionStatus == ActivityExecutionStatus.Canceling || this.ExecutionStatus == ActivityExecutionStatus.Faulting || !this.Condition.Evaluate(this, context))
{
return(false);
}
else
{
if (this.EnabledActivities.Count > 0)
{
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
ActivityExecutionContext innerContext = contextManager.CreateExecutionContext(this.EnabledActivities[0]);
innerContext.Activity.RegisterForStatusChange(Activity.ClosedEvent, this);
innerContext.ExecuteActivity(innerContext.Activity);
}
else
{
System.Diagnostics.Debug.Assert(false);
}
return(true);
}
}
private void ExecuteTemplate(ActivityExecutionContext executionContext, ChildExecutionStateInfo childStateInfo)
{
System.Diagnostics.Debug.Assert(childStateInfo.Status != ChildRunStatus.Running);
ActivityExecutionContextManager contextManager = executionContext.ExecutionContextManager;
ActivityExecutionContext templateExecutionContext = contextManager.CreateExecutionContext(this.EnabledActivities[0]);
childStateInfo.RunId = templateExecutionContext.ContextGuid;
childStateInfo.Status = ChildRunStatus.Running;
try
{
base.RaiseGenericEvent(ReplicatorActivity.ChildInitializedEvent, this, new ReplicatorChildEventArgs(childStateInfo.InstanceData, templateExecutionContext.Activity));
}
catch
{
childStateInfo.RunId = Guid.Empty;
childStateInfo.Status = ChildRunStatus.Completed;
contextManager.CompleteExecutionContext(templateExecutionContext);
throw;
}
templateExecutionContext.ExecuteActivity(templateExecutionContext.Activity);
templateExecutionContext.Activity.RegisterForStatusChange(Activity.ClosedEvent, new ReplicatorSubscriber(this, templateExecutionContext.ContextGuid));
}
// Workflow processor
internal static void RunWorkflow(Object stateInfo)
{
Stack <Activity> stack = new Stack <Activity> ();
WorkflowInstance wi = WorkflowRuntime.GetInstanceFromGuid((Guid)stateInfo);
wi.timer_subscriptions = new Timer(TimerSubscriptionsCallback, wi, 0, 1000);
Activity activity = wi.GetWorkflowDefinition();
Activity next_activity;
ActivityExecutionContextManager manager = new ActivityExecutionContextManager(wi);
ActivityExecutionContext context;
List <DelayActivity> waiting = new List <DelayActivity> ();
bool wait = false;
StateMachineWorkflowActivity state_machine = null;
#if DEBUG_EXECUTIONLOOP
Console.WriteLine("Initiating thread for activity {0}", wi.GetWorkflowDefinition());
#endif
context = manager.CreateExecutionContext(activity);
// Main Workflow execution loop
while (activity != null)
{
next_activity = null;
if (activity.NeedsExecution)
{
#if DEBUG_EXECUTIONLOOP
Console.WriteLine("*** Executing {0}, parallel {1}", activity, activity.ParallelParent);
#endif
context.ExecuteActivity(activity);
}
// If this a state machine changing its statge update StateMachineWorkflowActivity
if (state_machine != null && IsBasedOnType(activity, typeof(SetStateActivity)))
{
state_machine.SetCurrentStateName(((SetStateActivity)activity).TargetStateName);
}
#if DEBUG_EXECUTIONLOOP
Console.WriteLine(" ActivitiesToExecute.Count {0}, stack {1}, waiting {2}",
activity.ActivitiesToExecute.Count, stack.Count, waiting.Count);
#endif
wait = false;
// State machine workflow, first activity is InitialStateName
if (IsBasedOnType(activity, typeof(StateMachineWorkflowActivity)))
{
state_machine = (StateMachineWorkflowActivity)activity;
stack.Push(activity.GetActivityByName(state_machine.InitialStateName));
state_machine.SetCurrentStateName(state_machine.InitialStateName);
#if DEBUG_EXECUTIONLOOP
Console.WriteLine(" StateMachineWorkflowActivity, pushing {0}",
activity.GetActivityByName(sm.InitialStateName));
#endif
}
// TODO: if (IsBasedOnType (current, typeof (CompositeActivity))) {
if (activity.GetType() == typeof(DelayActivity))
{
if (activity.ParallelParent == null)
{
wi.WorkflowRuntime.OnWorkflowIdled(wi);
waiting.Add((DelayActivity)activity);
wait = true;
}
else
{
// Continue from parent activities
// TODO: This can be moved to the Execute method
// of the paralell activity
if (activity.ParallelParent.ActivitiesToExecute.Count > 0)
{
stack.Push(activity.ParallelParent);
#if DEBUG_EXECUTIONLOOP
Console.WriteLine("Pushing parent {0}", activity.ParallelParent);
#endif
waiting.Add((DelayActivity)activity);
}
else // If not possible, wait for the delay
{
#if DEBUG_EXECUTIONLOOP
Console.WriteLine("Schedule Waiting");
#endif
waiting.Add((DelayActivity)activity);
wait = true;
}
}
}
if (activity.NeedsExecution) // ex. While
{
stack.Push(activity);
}
if (activity.ActivitiesToExecute.Count == 0 && stack.Count == 0 && waiting.Count == 0)
{
#if DEBUG_EXECUTIONLOOP
Console.WriteLine("Exiting...");
#endif
break;
}
// Does it have sub-activities to run?
// Delay is not composite, cannot have children activities
if (wait == false)
{
if (activity.ActivitiesToExecute.Count > 0)
{
next_activity = activity.ActivitiesToExecute.Dequeue();
#if DEBUG_EXECUTIONLOOP
Console.WriteLine("Next Activity A {0}", next_activity);
#endif
if (activity.ActivitiesToExecute.Count > 0)
{
stack.Push(activity);
}
}
else
{
if (stack.Count > 0)
{
next_activity = stack.Pop();
}
if (next_activity != null && next_activity.NeedsExecution == false)
{
if (next_activity.ActivitiesToExecute.Count > 0)
{
next_activity = next_activity.ActivitiesToExecute.Dequeue();
}
}
#if DEBUG_EXECUTIONLOOP
Console.WriteLine("Next Activity B {0}", next_activity);
#endif
}
}
if (next_activity == null)
{
if (waiting.Count > 0)
{
#if DEBUG_EXECUTIONLOOP
Console.WriteLine("Waiting for {0} handles...", waiting.Count);
#endif
wi.WorkflowRuntime.OnWorkflowIdled(wi);
DelayActivity.WaitEvent.WaitOne();
}
}
// Do we have delay activities no longer waiting?
foreach (DelayActivity delay in waiting)
{
if (delay.Delayed == false)
{
bool flag = false;
// Continue with the list of activities pending in the parent
next_activity = delay.Parent;
waiting.Remove(delay);
#if DEBUG_EXECUTIONLOOP
Console.WriteLine("Delayed Parent {0}", next_activity);
#endif
if (next_activity.ActivitiesToExecute.Count > 0)
{
if (next_activity.ActivitiesToExecute.Count > 1)
{
flag = true;
}
if (next_activity != null)
{
next_activity = next_activity.ActivitiesToExecute.Dequeue();
if (flag == true)
{
stack.Push(delay.Parent);
}
}
}
break;
}
}
#if DEBUG_EXECUTIONLOOP
Console.WriteLine("Next activity to process {0}", next_activity);
#endif
activity = next_activity;
}
wi.WorkflowRuntime.OnWorkflowCompleted(wi);
}
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e)
{
if (sender == null)
{
throw new ArgumentNullException("sender");
}
if (e == null)
{
throw new ArgumentNullException("e");
}
ActivityExecutionContext context = sender as ActivityExecutionContext;
if (context == null)
{
throw new ArgumentException(SR.Error_SenderMustBeActivityExecutionContext, "sender");
}
EventDrivenActivity activity = e.Activity as EventDrivenActivity;
EventHandlersActivity handlers = context.Activity as EventHandlersActivity;
e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this);
ActivityExecutionContextManager executionContextManager = context.ExecutionContextManager;
executionContextManager.CompleteExecutionContext(executionContextManager.GetExecutionContext(activity));
switch (handlers.ExecutionStatus)
{
case ActivityExecutionStatus.Executing:
for (int i = 0; i < handlers.EnabledActivities.Count; i++)
{
if (handlers.EnabledActivities[i].QualifiedName.Equals(activity.QualifiedName))
{
EventHandlerEventActivitySubscriber subscriber = handlers.ActivityState[i];
if (subscriber.PendingExecutionCount > 0)
{
subscriber.PendingExecutionCount--;
subscriber.IsBlocked = false;
ActivityExecutionContext context2 = executionContextManager.CreateExecutionContext(handlers.EnabledActivities[i]);
context2.Activity.RegisterForStatusChange(Activity.ClosedEvent, this);
context2.ExecuteActivity(context2.Activity);
return;
}
subscriber.IsBlocked = true;
if (handlers.IsScopeCompleted && this.AllHandlersAreQuiet(handlers, context))
{
context.CloseActivity();
return;
}
break;
}
}
return;
case ActivityExecutionStatus.Canceling:
case ActivityExecutionStatus.Faulting:
if (this.AllHandlersAreQuiet(handlers, context))
{
context.CloseActivity();
}
break;
case ActivityExecutionStatus.Closed:
case ActivityExecutionStatus.Compensating:
break;
default:
return;
}
}
private void HandleStatusChange(ActivityExecutionContext executionContext, ActivityExecutionStatusChangedEventArgs e, ReplicatorSubscriber subscriber)
{
//System.Diagnostics.Debug.Assert(this.ExecutionStatus != ActivityExecutionStatus.Closed, "Stale notification should not have reache here");
//System.Diagnostics.Debug.Assert(e.Activity.QualifiedName.Equals(this.EnabledActivities[0].QualifiedName), "Got status change notification of non existing child");
//System.Diagnostics.Debug.Assert(subscriber.RunIdentifier != Guid.Empty, "Got notification from non-running template instance");
//Perform cleanup on completed run.
int runIndex = this.ActivityState.FindIndexOfChildStateInfo(subscriber.RunIdentifier);
if (runIndex == -1)
{
//This will happen when CancelChild is issued after Child Closed
//but before StatusChange Event raised on parent.
return;
}
ChildExecutionStateInfo childStateInfo = this.ActivityState[runIndex];
bool isMarkedForRemoval = childStateInfo.MarkedForRemoval;
try
{
try
{
base.RaiseGenericEvent(ReplicatorActivity.ChildCompletedEvent, this, new ReplicatorChildEventArgs(childStateInfo.InstanceData, e.Activity));
e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, subscriber);
}
finally
{
ActivityExecutionContextManager contextManager = executionContext.ExecutionContextManager;
ActivityExecutionContext templateExecutionContext = contextManager.GetExecutionContext(e.Activity);
contextManager.CompleteExecutionContext(templateExecutionContext);
}
//Reevaluate CompletionCondition
if (!this.ActivityState.CompletionConditionTrueAlready)
{
this.ActivityState.CompletionConditionTrueAlready = (this.UntilCondition != null && this.UntilCondition.Evaluate(this, executionContext));
}
}
finally //Always perform cleanup of just completed child.
{
//This will mark child as passive.
childStateInfo.RunId = Guid.Empty;
childStateInfo.Status = ChildRunStatus.Completed;
if (isMarkedForRemoval)
{
//This is the case, when user issued CancelChild request on running template instance.
//We flush out execution state of that run when it becomes passive.
this.ActivityState.Remove(childStateInfo);
runIndex = runIndex - 1; //Needed for sequence execution type.
}
}
//Next Step.
if (!this.ActivityState.IsChildActive) //Everything is passive now.
{
if (this.ExecutionStatus == ActivityExecutionStatus.Canceling || this.ExecutionStatus == ActivityExecutionStatus.Faulting || this.ActivityState.CompletionConditionTrueAlready)
{
base.RaiseEvent(ReplicatorActivity.CompletedEvent, this, EventArgs.Empty);
executionContext.CloseActivity();
return;
}
}
else //Template is active; Valid only for parallel
{
System.Diagnostics.Debug.Assert(this.ExecutionType == ExecutionType.Parallel);
if (this.ExecutionStatus != ActivityExecutionStatus.Canceling && this.ExecutionStatus != ActivityExecutionStatus.Faulting)
{
if (this.ActivityState.CompletionConditionTrueAlready)
{
//Try cool down child.
TryCancelChildren(executionContext);
return;
}
}
}
switch (this.ExecutionType)
{
case ExecutionType.Sequence:
if (runIndex < this.ActivityState.Count - 1)
{
ExecuteTemplate(executionContext, this.ActivityState[runIndex + 1]);
return;
}
else if (this.UntilCondition == null || this.UntilCondition.Evaluate(this, executionContext))
{
base.RaiseEvent(ReplicatorActivity.CompletedEvent, this, EventArgs.Empty);
executionContext.CloseActivity();
return;
}
break;
case ExecutionType.Parallel:
if (!this.ActivityState.IsChildActive && (this.UntilCondition == null || (this.UntilCondition.Evaluate(this, executionContext))))
{
base.RaiseEvent(ReplicatorActivity.CompletedEvent, this, EventArgs.Empty);
executionContext.CloseActivity();
return;
}
break;
default:
throw new InvalidOperationException(SR.GetString(SR.Error_ReplicatorInvalidExecutionType));
}
}
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e)
{
if (sender == null)
{
throw new ArgumentNullException("sender");
}
if (e == null)
{
throw new ArgumentNullException("e");
}
ActivityExecutionContext context = sender as ActivityExecutionContext;
if (context == null)
{
throw new ArgumentException(SR.Error_SenderMustBeActivityExecutionContext, "sender");
}
EventDrivenActivity eda = e.Activity as EventDrivenActivity;
EventHandlersActivity eventHandlers = context.Activity as EventHandlersActivity;
e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this);
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
contextManager.CompleteExecutionContext(contextManager.GetExecutionContext(eda));
switch (eventHandlers.ExecutionStatus)
{
case ActivityExecutionStatus.Executing:
for (int i = 0; i < eventHandlers.EnabledActivities.Count; ++i)
{
if (eventHandlers.EnabledActivities[i].QualifiedName.Equals(eda.QualifiedName))
{
EventHandlerEventActivitySubscriber eventActivitySubscriber = eventHandlers.ActivityState[i];
if (eventActivitySubscriber.PendingExecutionCount > 0)
{
eventActivitySubscriber.PendingExecutionCount--;
eventActivitySubscriber.IsBlocked = false;
ActivityExecutionContext childContext = contextManager.CreateExecutionContext(eventHandlers.EnabledActivities[i]);
childContext.Activity.RegisterForStatusChange(Activity.ClosedEvent, this);
childContext.ExecuteActivity(childContext.Activity);
}
else
{
eventActivitySubscriber.IsBlocked = true;
if (eventHandlers.IsScopeCompleted && AllHandlersAreQuiet(eventHandlers, context))
{
context.CloseActivity();
}
}
break;
}
}
break;
case ActivityExecutionStatus.Canceling:
case ActivityExecutionStatus.Faulting:
if (AllHandlersAreQuiet(eventHandlers, context))
{
context.CloseActivity();
}
break;
}
}
private void HandleStatusChange(ActivityExecutionContext executionContext, ActivityExecutionStatusChangedEventArgs e, ReplicatorSubscriber subscriber)
{
int num = this.ActivityState.FindIndexOfChildStateInfo(subscriber.RunIdentifier);
if (num != -1)
{
ChildExecutionStateInfo item = this.ActivityState[num];
bool markedForRemoval = item.MarkedForRemoval;
try
{
try
{
base.RaiseGenericEvent <ReplicatorChildEventArgs>(ChildCompletedEvent, this, new ReplicatorChildEventArgs(item.InstanceData, e.Activity));
e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, subscriber);
}
finally
{
ActivityExecutionContextManager executionContextManager = executionContext.ExecutionContextManager;
ActivityExecutionContext childContext = executionContextManager.GetExecutionContext(e.Activity);
executionContextManager.CompleteExecutionContext(childContext);
}
if (!this.ActivityState.CompletionConditionTrueAlready)
{
this.ActivityState.CompletionConditionTrueAlready = (this.UntilCondition != null) && this.UntilCondition.Evaluate(this, executionContext);
}
}
finally
{
item.RunId = Guid.Empty;
item.Status = ChildRunStatus.Completed;
if (markedForRemoval)
{
this.ActivityState.Remove(item);
num--;
}
}
if (!this.ActivityState.IsChildActive)
{
if (((base.ExecutionStatus == ActivityExecutionStatus.Canceling) || (base.ExecutionStatus == ActivityExecutionStatus.Faulting)) || this.ActivityState.CompletionConditionTrueAlready)
{
base.RaiseEvent(CompletedEvent, this, EventArgs.Empty);
executionContext.CloseActivity();
return;
}
}
else if (((base.ExecutionStatus != ActivityExecutionStatus.Canceling) && (base.ExecutionStatus != ActivityExecutionStatus.Faulting)) && this.ActivityState.CompletionConditionTrueAlready)
{
this.TryCancelChildren(executionContext);
return;
}
switch (this.ExecutionType)
{
case System.Workflow.Activities.ExecutionType.Sequence:
if (num >= (this.ActivityState.Count - 1))
{
if ((this.UntilCondition == null) || this.UntilCondition.Evaluate(this, executionContext))
{
base.RaiseEvent(CompletedEvent, this, EventArgs.Empty);
executionContext.CloseActivity();
return;
}
break;
}
this.ExecuteTemplate(executionContext, this.ActivityState[num + 1]);
return;
case System.Workflow.Activities.ExecutionType.Parallel:
if (this.ActivityState.IsChildActive || ((this.UntilCondition != null) && !this.UntilCondition.Evaluate(this, executionContext)))
{
break;
}
base.RaiseEvent(CompletedEvent, this, EventArgs.Empty);
executionContext.CloseActivity();
return;
default:
throw new InvalidOperationException(SR.GetString("Error_ReplicatorInvalidExecutionType"));
}
}
}
