protected internal override void OnWorkflowChangesCompleted(ActivityExecutionContext executionContext) { SequenceHelper.OnWorkflowChangesCompleted(this, executionContext); }
internal CompensationInfo(ActivityExecutionContext targetExecutionContext) { this.targetExecutionContext = targetExecutionContext; }
protected override ActivityExecutionStatus Execute(T activity, ActivityExecutionContext executionContext) { return(base.Execute(activity, executionContext)); }
protected internal override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { return(SequenceHelper.Execute(this, executionContext)); }
private static bool TryCompensateLastCompletedChildActivity(ActivityExecutionContext context, Activity targetActivity, IActivityEventListener <ActivityExecutionStatusChangedEventArgs> statusChangeHandler, bool isimmediateCompensation) { SortedDictionary <int, CompensationInfo> sortedListOfCompensatableTargets = new SortedDictionary <int, CompensationInfo>(); if (!(targetActivity is CompositeActivity)) { return(false); } //Walk through all of the direct children which are compensatable and add them in the sorted order of their completion //bail out if any of the compensatable children is currently compensating/faulting or canceling if (CollectCompensatableTargetActivities(targetActivity as CompositeActivity, sortedListOfCompensatableTargets, isimmediateCompensation)) { return(true); } // walk through active contexts that contain compensatable child, add them in the sorted order of the completion // this also, walks through the completed contexts which are compensatable and are nested directly within the active contexts and adds them in the order of their completion // bail out if any activity is currently compensating/faulting or cancelling if (CollectCompensatableActiveContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation)) { return(true); } // walk through all completed execution contexts which are compensatable and are directly nested under the target activity, //and add them to our sorted list CollectCompensatableCompletedContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation); //if there were no compensatable targets found, bail out if (sortedListOfCompensatableTargets.Count == 0) { CompleteRevokedExecutionContext(targetActivity, context); return(false); } int?lastCompletedOrderId = targetActivity.GetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty) as Nullable <int>; int nextLastCompletedOrderId = -1; //get the last compensatable target - this could be an activity, contextInfo or a Context CompensationInfo lastCompensatableTarget = null; foreach (int completedOrderId in sortedListOfCompensatableTargets.Keys) { if (lastCompletedOrderId.HasValue && lastCompletedOrderId < completedOrderId) { break; } lastCompensatableTarget = sortedListOfCompensatableTargets[completedOrderId]; nextLastCompletedOrderId = completedOrderId; } //We are done with compensation on entire branch, now complete execution contexts //recursilvely which we might have opened up. if (lastCompensatableTarget == null) { CompleteRevokedExecutionContext(targetActivity, context); return(false); } targetActivity.SetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty, nextLastCompletedOrderId); //the last compensatable target could be an activity if (lastCompensatableTarget.TargetActivity != null && lastCompensatableTarget.TargetActivity is ICompensatableActivity) { lastCompensatableTarget.TargetActivity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler); context.CompensateActivity(lastCompensatableTarget.TargetActivity); return(true); } //or get the last compensatable "completed" context else if (lastCompensatableTarget.TargetExecutionInfo != null && lastCompensatableTarget.TargetExecutionContextManager != null) { ActivityExecutionContext revokedExecutionContext = lastCompensatableTarget.TargetExecutionContextManager.DiscardPersistedExecutionContext(lastCompensatableTarget.TargetExecutionInfo); //get the "first" compensatable child and compensate it if (revokedExecutionContext.Activity is ICompensatableActivity) { revokedExecutionContext.Activity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler); revokedExecutionContext.CompensateActivity(revokedExecutionContext.Activity); return(true); } else if (revokedExecutionContext.Activity is CompositeActivity) { //get the last compensatable child of the revoked context Activity compensatableChild = GetLastCompensatableChild(revokedExecutionContext.Activity as CompositeActivity); if (compensatableChild != null) { compensatableChild.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler); revokedExecutionContext.CompensateActivity(compensatableChild); return(true); } else// recursively, walk the context tree and keep revoking the compensatable contexts { return(TryCompensateLastCompletedChildActivity(revokedExecutionContext, revokedExecutionContext.Activity, statusChangeHandler, false)); } } } else if (lastCompensatableTarget.TargetExecutionContext != null) //or get the last compensatable "active" context { if (lastCompensatableTarget.TargetExecutionContext.Activity is CompositeActivity) { //get the last compensatable child of the active context Activity compensatableChild = GetLastCompensatableChild(lastCompensatableTarget.TargetExecutionContext.Activity as CompositeActivity); if (compensatableChild != null) { compensatableChild.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler); lastCompensatableTarget.TargetExecutionContext.CompensateActivity(compensatableChild); return(true); } else // recursively, walk the context tree and keep revoking the compensatable contexts { return(TryCompensateLastCompletedChildActivity(lastCompensatableTarget.TargetExecutionContext, lastCompensatableTarget.TargetExecutionContext.Activity, statusChangeHandler, false)); } } } return(false); }
private bool MayInvokeDelegateNow(Activity currentContextActivity) { if ((this.activityQualifiedName == null) || this.wantInTransact) { return(true); } if (!ActivityExecutionContext.IsInAtomicTransaction(currentContextActivity.WorkflowCoreRuntime.CurrentActivity)) { return(true); } Activity contextActivityForId = currentContextActivity.WorkflowCoreRuntime.GetContextActivityForId(this.contextId); if (contextActivityForId == null) { return(false); } Activity activityByName = contextActivityForId.GetActivityByName(this.activityQualifiedName, true); if (activityByName == null) { return(false); } return((ActivityExecutionContext.IsInAtomicTransaction(activityByName) && ActivityExecutionContext.IsInAtomicTransaction(currentContextActivity.WorkflowCoreRuntime.CurrentActivity)) || activityByName.MetaEquals(currentContextActivity)); }
protected internal virtual ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { return(ActivityExecutionStatus.Canceling); }
public ActivityExecutionContext CreateExecutionContext(Activity activity) { if (this.ownerContext == null) { throw new ObjectDisposedException("ActivityExecutionContextManager"); } if (activity == null) { throw new ArgumentNullException("activity"); } if (!this.ownerContext.IsValidChild(activity, true)) { throw new ArgumentException(SR.GetString(SR.AEC_InvalidActivity), "activity"); } Activity copiedActivity = activity.Clone(); ((IDependencyObjectAccessor)copiedActivity).InitializeInstanceForRuntime(this.ownerContext.Activity.WorkflowCoreRuntime); //Reset the cloned tree for execution. Queue <Activity> activityQueue = new Queue <Activity>(); activityQueue.Enqueue(copiedActivity); while (activityQueue.Count != 0) { Activity clonedActivity = activityQueue.Dequeue(); if (clonedActivity.ExecutionStatus != ActivityExecutionStatus.Initialized) { clonedActivity.ResetAllKnownDependencyProperties(); CompositeActivity compositeActivity = clonedActivity as CompositeActivity; if (compositeActivity != null) { for (int i = 0; i < compositeActivity.EnabledActivities.Count; ++i) { activityQueue.Enqueue(compositeActivity.EnabledActivities[i]); } ISupportAlternateFlow alternateFlow = compositeActivity as ISupportAlternateFlow; if (alternateFlow != null) { for (int i = 0; i < alternateFlow.AlternateFlowActivities.Count; ++i) { activityQueue.Enqueue(alternateFlow.AlternateFlowActivities[i]); } } } } } // get active context activities and add it to this one IList <Activity> activeContexts = (IList <Activity>) this.ownerContext.Activity.ContextActivity.GetValue(Activity.ActiveExecutionContextsProperty); if (activeContexts == null) { activeContexts = new List <Activity>(); this.ownerContext.Activity.ContextActivity.SetValue(Activity.ActiveExecutionContextsProperty, activeContexts); } activeContexts.Add(copiedActivity); // prepare the copied activity as a context activity ActivityExecutionContextInfo contextInfo = new ActivityExecutionContextInfo(activity.QualifiedName, this.ownerContext.WorkflowCoreRuntime.GetNewContextActivityId(), Guid.NewGuid(), this.ownerContext.ContextId); copiedActivity.SetValue(Activity.ActivityExecutionContextInfoProperty, contextInfo); copiedActivity.SetValue(Activity.ActivityContextGuidProperty, contextInfo.ContextGuid); ActivityExecutionContext newExecutionContext = null; try { // inform workflow runtime this.ownerContext.Activity.WorkflowCoreRuntime.RegisterContextActivity(copiedActivity); // return the new context newExecutionContext = new ActivityExecutionContext(copiedActivity); this.executionContexts.Add(newExecutionContext); newExecutionContext.InitializeActivity(newExecutionContext.Activity); return(newExecutionContext); } catch (Exception) { if (newExecutionContext != null) { this.CompleteExecutionContext(newExecutionContext); } else { activeContexts.Remove(copiedActivity); } throw; } }
protected internal virtual void OnActivityChangeRemove(ActivityExecutionContext executionContext, Activity removedActivity) { }
protected internal virtual void OnWorkflowChangesCompleted(ActivityExecutionContext rootContext) { }
private ActivityExecutionStatus CompensateTargetActivity(ActivityExecutionContext context) { Activity targetActivity = null; Activity commonParentActivity = context.Activity; do { commonParentActivity = commonParentActivity.Parent; targetActivity = commonParentActivity.GetActivityByName(this.TargetActivityName, true); } while (targetActivity == null); if (targetActivity is ICompensatableActivity && targetActivity.ExecutionStatus == ActivityExecutionStatus.Closed && targetActivity.ExecutionResult == ActivityExecutionResult.Succeeded) { // same execution context targetActivity.RegisterForStatusChange(Activity.ClosedEvent, this); context.CompensateActivity(targetActivity); return(context.Activity.ExecutionStatus); } else if (targetActivity.ExecutionStatus == ActivityExecutionStatus.Initialized) { // Template activity // walk through active contexts ActivityExecutionContextManager contextManager = context.ExecutionContextManager; foreach (ActivityExecutionContext activeContext in contextManager.ExecutionContexts) { if (targetActivity.GetActivityByName(activeContext.Activity.QualifiedName, true) != null) { if (activeContext.Activity.ExecutionStatus == ActivityExecutionStatus.Compensating || activeContext.Activity.ExecutionStatus == ActivityExecutionStatus.Faulting || activeContext.Activity.ExecutionStatus == ActivityExecutionStatus.Canceling ) { return(context.Activity.ExecutionStatus); } } } // walk through all completed execution contexts for (int index = contextManager.CompletedExecutionContexts.Count - 1; index >= 0; index--) { //only compensate direct child during explicit compensation ActivityExecutionContextInfo completedActivityInfo = contextManager.CompletedExecutionContexts[index]; if (((completedActivityInfo.Flags & PersistFlags.NeedsCompensation) != 0)) { ActivityExecutionContext revokedExecutionContext = contextManager.DiscardPersistedExecutionContext(completedActivityInfo); if (revokedExecutionContext.Activity is ICompensatableActivity) { revokedExecutionContext.Activity.RegisterForStatusChange(Activity.ClosedEvent, this); revokedExecutionContext.CompensateActivity(revokedExecutionContext.Activity); } return(context.Activity.ExecutionStatus); } } } else { // currently faulting, canceling, or compensating if (CompensationUtils.TryCompensateLastCompletedChildActivity(context, targetActivity, this)) { return(context.Activity.ExecutionStatus); } } return(ActivityExecutionStatus.Closed); }
public sealed override ActivityExecutionStatus HandleFault(Activity activity, ActivityExecutionContext executionContext, Exception exception) { return(this.HandleFault((T)activity, executionContext, exception)); }
public sealed override ActivityExecutionStatus Cancel(Activity activity, ActivityExecutionContext executionContext) { return(this.Cancel((T)activity, executionContext)); }
public sealed override ActivityExecutionStatus Compensate(Activity activity, ActivityExecutionContext executionContext) { return(this.Compensate((T)activity, executionContext)); }
protected internal virtual ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { needs_exec = false; return(ActivityExecutionStatus.Closed); }
public void CompleteExecutionContext(ActivityExecutionContext childContext, bool forcePersist) { if (this.ownerContext == null) { throw new ObjectDisposedException("ActivityExecutionContextManager"); } if (childContext == null) { throw new ArgumentNullException("childContext"); } if (childContext.Activity == null) { throw new ArgumentException("childContext", SR.GetString(SR.Error_MissingActivityProperty)); } if (childContext.Activity.ContextActivity == null) { throw new ArgumentException("childContext", SR.GetString(SR.Error_MissingContextActivityProperty)); } if (!this.executionContexts.Contains(childContext)) { throw new ArgumentException(); } if (childContext.Activity.ContextActivity.ExecutionStatus != ActivityExecutionStatus.Closed && childContext.Activity.ContextActivity.ExecutionStatus != ActivityExecutionStatus.Initialized) { throw new InvalidOperationException(SR.GetString(System.Globalization.CultureInfo.CurrentCulture, SR.Error_CannotCompleteContext)); } // make sure that this is in the active contexts collections ActivityExecutionContextInfo childContextInfo = childContext.Activity.ContextActivity.GetValue(Activity.ActivityExecutionContextInfoProperty) as ActivityExecutionContextInfo; IList <Activity> activeContexts = (IList <Activity>) this.ownerContext.Activity.ContextActivity.GetValue(Activity.ActiveExecutionContextsProperty); if (activeContexts == null || !activeContexts.Contains(childContext.Activity.ContextActivity)) { throw new ArgumentException(); } // add it to completed contexts collection bool needsCompensation = childContext.Activity.NeedsCompensation; if (needsCompensation || forcePersist) { // add it to completed contexts List <ActivityExecutionContextInfo> completedContexts = this.ownerContext.Activity.ContextActivity.GetValue(Activity.CompletedExecutionContextsProperty) as List <ActivityExecutionContextInfo>; if (completedContexts == null) { completedContexts = new List <ActivityExecutionContextInfo>(); this.ownerContext.Activity.ContextActivity.SetValue(Activity.CompletedExecutionContextsProperty, completedContexts); } if (needsCompensation) { childContextInfo.Flags = PersistFlags.NeedsCompensation; } if (forcePersist) { childContextInfo.Flags |= PersistFlags.ForcePersist; } childContextInfo.SetCompletedOrderId(this.ownerContext.Activity.IncrementCompletedOrderId()); completedContexts.Add(childContextInfo); // ask runtime to save the context activity this.ownerContext.Activity.WorkflowCoreRuntime.SaveContextActivity(childContext.Activity); } // remove it from active contexts activeContexts.Remove(childContext.Activity.ContextActivity); this.executionContexts.Remove(childContext); //Case for those context which has compensatable child context, when those context //are completed at the end of Compensation chain we need to uninitialize the context //activity associated to them. if (childContext.Activity.ContextActivity.CanUninitializeNow && childContext.Activity.ContextActivity.ExecutionResult != ActivityExecutionResult.Uninitialized) { childContext.Activity.ContextActivity.Uninitialize(this.ownerContext.Activity.RootActivity.WorkflowCoreRuntime); childContext.Activity.ContextActivity.SetValue(Activity.ExecutionResultProperty, ActivityExecutionResult.Uninitialized); } // unregister it from runtime this.ownerContext.Activity.WorkflowCoreRuntime.UnregisterContextActivity(childContext.Activity); if (!(needsCompensation || forcePersist)) { childContext.Activity.Dispose(); } }
protected internal virtual ActivityExecutionStatus HandleFault(ActivityExecutionContext executionContext, Exception exception) { return(ActivityExecutionStatus.Closed); }
internal StartWorkflow(ActivityExecutionContext executionContext) { this.executionContext = executionContext; }
public ActivityExecutionStatus ExecuteInternal(ActivityExecutionContext executionContext) { return(Execute(executionContext)); }
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e) { ActivityExecutionContext context = sender as ActivityExecutionContext; if (context == null) { throw new ArgumentException("sender"); } if (e.Activity == context.Activity) { if (context.Activity.HasPrimaryClosed && !(bool)context.Activity.GetValue(CompensateProcessedProperty)) { context.Activity.SetValue(CompensateProcessedProperty, true); if (context.Activity.ExecutionResult == ActivityExecutionResult.Compensated) { // run compensation handler or do default compensation handling Activity compensationHandler = GetCompensationHandler(context.Activity); if (compensationHandler != null) { // subscribe for status change on compensation handler compensationHandler.RegisterForStatusChange(Activity.ClosedEvent, this); // execute compensation handler context.ExecuteActivity(compensationHandler); } else { // do default compensation if (!CompensationUtils.TryCompensateLastCompletedChildActivity(context, context.Activity, this)) { // let activity get into closed state context.Activity.ReleaseLockOnStatusChange(this); } } } else { // let activity get into closed state context.Activity.ReleaseLockOnStatusChange(this); } } } else if (e.Activity is CompensationHandlerActivity && e.ExecutionStatus == ActivityExecutionStatus.Closed) { // remove subscriber for status change on compensation handler e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this); // release lock on the primary activity context.Activity.ReleaseLockOnStatusChange(this); } else if (e.ExecutionStatus == ActivityExecutionStatus.Closed) { // remove subscriber for status change on compensated activity e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this); if (!CompensationUtils.TryCompensateLastCompletedChildActivity(context, context.Activity, this)) { // release lock on the primary activity context.Activity.ReleaseLockOnStatusChange(this); } } }
public void OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e) { ActivityExecutionContext context = sender as ActivityExecutionContext; if (context == null) { throw new ArgumentException("sender"); } // waiting for primary activity to close if (e.Activity == context.Activity) { if (context.Activity.HasPrimaryClosed && !(bool)context.Activity.GetValue(FaultAndCancellationHandlingFilter.FaultProcessedProperty)) { context.Activity.SetValue(FaultAndCancellationHandlingFilter.FaultProcessedProperty, true); if (context.Activity.WasExecuting && context.Activity.ExecutionResult == ActivityExecutionResult.Faulted && context.Activity.GetValue(ActivityExecutionContext.CurrentExceptionProperty) != null) { // execute exceptionHandlers, iff activity has transitioned from Executing to Faulting. CompositeActivity exceptionHandlersActivity = FaultAndCancellationHandlingFilter.GetFaultHandlers(context.Activity); if (exceptionHandlersActivity != null) { // listen for FaultHandler status change events exceptionHandlersActivity.RegisterForStatusChange(Activity.ClosedEvent, this); // execute exception handlers context.ExecuteActivity(exceptionHandlersActivity); } else { // compensate completed children if (!CompensationUtils.TryCompensateLastCompletedChildActivity(context, context.Activity, this)) { SafeReleaseLockOnStatusChange(context); // no children to compensate...release lock on to the close status of the activity } } } else if (context.Activity.ExecutionResult == ActivityExecutionResult.Canceled) { // if primary activity is closed and outcome is canceled, then run the cancel handler Activity cancelHandler = FaultAndCancellationHandlingFilter.GetCancellationHandler(context.Activity); if (cancelHandler != null) { // execute the cancel handler cancelHandler.RegisterForStatusChange(Activity.ClosedEvent, this); context.ExecuteActivity(cancelHandler); } else { // run default compensation if (!CompensationUtils.TryCompensateLastCompletedChildActivity(context, context.Activity, this)) { SafeReleaseLockOnStatusChange(context); // release lock on to the close status of the activity } } } else // release lock on to the close status of the activity { SafeReleaseLockOnStatusChange(context); } } } else if ((e.Activity is FaultHandlersActivity || e.Activity is CancellationHandlerActivity) && (e.ExecutionStatus == ActivityExecutionStatus.Closed) ) { // remove subscriber e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this); // fetch the exception , it would be null if it was handled if (context.Activity.GetValue(ActivityExecutionContext.CurrentExceptionProperty) != null) { // the exception was not handled by exceptionHandlers.... do default exceptionHandling // compesate completed children if (!CompensationUtils.TryCompensateLastCompletedChildActivity(context, context.Activity, this)) { SafeReleaseLockOnStatusChange(context); // no children to compensate.Release lock on to the close status of the activity } } else// the exception was handled by the exceptionHandlers. Release lock on to the close status of the parent activity { SafeReleaseLockOnStatusChange(context); } } else if (e.ExecutionStatus == ActivityExecutionStatus.Closed) { // compensation of a child was in progress. // remove subscriber for this e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this); // see if there are other children to be compensated if (!CompensationUtils.TryCompensateLastCompletedChildActivity(context, context.Activity, this)) { SafeReleaseLockOnStatusChange(context); // release lock on to the close status of the parent activity } } }
ActivityExecutionStatus ICompensatableActivity.Compensate(ActivityExecutionContext executionContext) { return(ActivityExecutionStatus.Closed); }
public ActivityExecutionContext CreateExecutionContext(Activity activity) { ActivityExecutionContext context2; if (this.ownerContext == null) { throw new ObjectDisposedException("ActivityExecutionContextManager"); } if (activity == null) { throw new ArgumentNullException("activity"); } if (!this.ownerContext.IsValidChild(activity, true)) { throw new ArgumentException(SR.GetString("AEC_InvalidActivity"), "activity"); } Activity item = activity.Clone(); ((IDependencyObjectAccessor)item).InitializeInstanceForRuntime(this.ownerContext.Activity.WorkflowCoreRuntime); Queue <Activity> queue = new Queue <Activity>(); queue.Enqueue(item); while (queue.Count != 0) { Activity activity3 = queue.Dequeue(); if (activity3.ExecutionStatus != ActivityExecutionStatus.Initialized) { activity3.ResetAllKnownDependencyProperties(); CompositeActivity activity4 = activity3 as CompositeActivity; if (activity4 != null) { for (int i = 0; i < activity4.EnabledActivities.Count; i++) { queue.Enqueue(activity4.EnabledActivities[i]); } ISupportAlternateFlow flow = activity4; if (flow != null) { for (int j = 0; j < flow.AlternateFlowActivities.Count; j++) { queue.Enqueue(flow.AlternateFlowActivities[j]); } } } } } IList <Activity> list = (IList <Activity>) this.ownerContext.Activity.ContextActivity.GetValue(Activity.ActiveExecutionContextsProperty); if (list == null) { list = new List <Activity>(); this.ownerContext.Activity.ContextActivity.SetValue(Activity.ActiveExecutionContextsProperty, list); } list.Add(item); ActivityExecutionContextInfo info = new ActivityExecutionContextInfo(activity.QualifiedName, this.ownerContext.WorkflowCoreRuntime.GetNewContextActivityId(), Guid.NewGuid(), this.ownerContext.ContextId); item.SetValue(Activity.ActivityExecutionContextInfoProperty, info); item.SetValue(Activity.ActivityContextGuidProperty, info.ContextGuid); ActivityExecutionContext context = null; try { this.ownerContext.Activity.WorkflowCoreRuntime.RegisterContextActivity(item); context = new ActivityExecutionContext(item); this.executionContexts.Add(context); context.InitializeActivity(context.Activity); context2 = context; } catch (Exception) { if (context != null) { this.CompleteExecutionContext(context); } else { list.Remove(item); } throw; } return(context2); }
protected override ActivityExecutionStatus Cancel(T activity, ActivityExecutionContext executionContext) { return(base.Cancel(activity, executionContext)); }
public void CompleteExecutionContext(ActivityExecutionContext childContext, bool forcePersist) { if (this.ownerContext == null) { throw new ObjectDisposedException("ActivityExecutionContextManager"); } if (childContext == null) { throw new ArgumentNullException("childContext"); } if (childContext.Activity == null) { throw new ArgumentException("childContext", SR.GetString("Error_MissingActivityProperty")); } if (childContext.Activity.ContextActivity == null) { throw new ArgumentException("childContext", SR.GetString("Error_MissingContextActivityProperty")); } if (!this.executionContexts.Contains(childContext)) { throw new ArgumentException(); } if ((childContext.Activity.ContextActivity.ExecutionStatus != ActivityExecutionStatus.Closed) && (childContext.Activity.ContextActivity.ExecutionStatus != ActivityExecutionStatus.Initialized)) { throw new InvalidOperationException(SR.GetString(CultureInfo.CurrentCulture, "Error_CannotCompleteContext")); } ActivityExecutionContextInfo item = childContext.Activity.ContextActivity.GetValue(Activity.ActivityExecutionContextInfoProperty) as ActivityExecutionContextInfo; IList <Activity> list = (IList <Activity>) this.ownerContext.Activity.ContextActivity.GetValue(Activity.ActiveExecutionContextsProperty); if ((list == null) || !list.Contains(childContext.Activity.ContextActivity)) { throw new ArgumentException(); } bool needsCompensation = childContext.Activity.NeedsCompensation; if (needsCompensation || forcePersist) { List <ActivityExecutionContextInfo> list2 = this.ownerContext.Activity.ContextActivity.GetValue(Activity.CompletedExecutionContextsProperty) as List <ActivityExecutionContextInfo>; if (list2 == null) { list2 = new List <ActivityExecutionContextInfo>(); this.ownerContext.Activity.ContextActivity.SetValue(Activity.CompletedExecutionContextsProperty, list2); } if (needsCompensation) { item.Flags = PersistFlags.NeedsCompensation; } if (forcePersist) { item.Flags = (PersistFlags)((byte)(item.Flags | PersistFlags.ForcePersist)); } item.SetCompletedOrderId(this.ownerContext.Activity.IncrementCompletedOrderId()); list2.Add(item); this.ownerContext.Activity.WorkflowCoreRuntime.SaveContextActivity(childContext.Activity); } list.Remove(childContext.Activity.ContextActivity); this.executionContexts.Remove(childContext); if (childContext.Activity.ContextActivity.CanUninitializeNow && (childContext.Activity.ContextActivity.ExecutionResult != ActivityExecutionResult.Uninitialized)) { childContext.Activity.ContextActivity.Uninitialize(this.ownerContext.Activity.RootActivity.WorkflowCoreRuntime); childContext.Activity.ContextActivity.SetValue(Activity.ExecutionResultProperty, ActivityExecutionResult.Uninitialized); } this.ownerContext.Activity.WorkflowCoreRuntime.UnregisterContextActivity(childContext.Activity); if (!needsCompensation && !forcePersist) { childContext.Activity.Dispose(); } }
protected internal override void OnActivityChangeRemove(ActivityExecutionContext executionContext, Activity removedActivity) { SequenceHelper.OnActivityChangeRemove(this, executionContext, removedActivity); }
private void InvokeDelegate(Activity currentContextActivity, Activity targetContextActivity, T e, bool sync, bool transacted) { ActivityExecutorDelegateOperation delegateOperation = null; if (this.delegateValue != null) { delegateOperation = new ActivityExecutorDelegateOperation(this.activityQualifiedName, this.delegateValue, e, this.ContextId); } else { delegateOperation = new ActivityExecutorDelegateOperation(this.activityQualifiedName, this.eventListener, e, this.ContextId); } bool mayInvokeDelegateNow = MayInvokeDelegateNow(currentContextActivity); if (mayInvokeDelegateNow && sync) { Activity targetActivity = targetContextActivity.GetActivityByName(this.activityQualifiedName); using (currentContextActivity.WorkflowCoreRuntime.SetCurrentActivity(targetActivity)) { delegateOperation.SynchronousInvoke = true; delegateOperation.Run(currentContextActivity.WorkflowCoreRuntime); } } else { // If in atomic and subscriber not in same scope // Queue it on the subscriber's baseExecutor Activity targetActivity = targetContextActivity.GetActivityByName(this.activityQualifiedName); currentContextActivity.WorkflowCoreRuntime.ScheduleItem(delegateOperation, ActivityExecutionContext.IsInAtomicTransaction(targetActivity), transacted, !mayInvokeDelegateNow); } }
private static bool TryCompensateLastCompletedChildActivity(ActivityExecutionContext context, Activity targetActivity, IActivityEventListener <ActivityExecutionStatusChangedEventArgs> statusChangeHandler, bool isimmediateCompensation) { SortedDictionary <int, CompensationInfo> sortedListOfCompensatableTargets = new SortedDictionary <int, CompensationInfo>(); if (targetActivity is CompositeActivity) { if (CollectCompensatableTargetActivities(targetActivity as CompositeActivity, sortedListOfCompensatableTargets, isimmediateCompensation)) { return(true); } if (CollectCompensatableActiveContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation)) { return(true); } CollectCompensatableCompletedContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation); if (sortedListOfCompensatableTargets.Count == 0) { CompleteRevokedExecutionContext(targetActivity, context); return(false); } int?nullable = targetActivity.GetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty) as int?; int num = -1; CompensationInfo info = null; foreach (int num2 in sortedListOfCompensatableTargets.Keys) { if (nullable.HasValue) { int?nullable2 = nullable; int num3 = num2; if ((nullable2.GetValueOrDefault() < num3) && nullable2.HasValue) { break; } } info = sortedListOfCompensatableTargets[num2]; num = num2; } if (info == null) { CompleteRevokedExecutionContext(targetActivity, context); return(false); } targetActivity.SetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty, num); if ((info.TargetActivity != null) && (info.TargetActivity is ICompensatableActivity)) { info.TargetActivity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler); context.CompensateActivity(info.TargetActivity); return(true); } if ((info.TargetExecutionInfo != null) && (info.TargetExecutionContextManager != null)) { ActivityExecutionContext context2 = info.TargetExecutionContextManager.DiscardPersistedExecutionContext(info.TargetExecutionInfo); if (context2.Activity is ICompensatableActivity) { context2.Activity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler); context2.CompensateActivity(context2.Activity); return(true); } if (context2.Activity is CompositeActivity) { Activity lastCompensatableChild = GetLastCompensatableChild(context2.Activity as CompositeActivity); if (lastCompensatableChild != null) { lastCompensatableChild.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler); context2.CompensateActivity(lastCompensatableChild); return(true); } return(TryCompensateLastCompletedChildActivity(context2, context2.Activity, statusChangeHandler, false)); } } else if ((info.TargetExecutionContext != null) && (info.TargetExecutionContext.Activity is CompositeActivity)) { Activity activity = GetLastCompensatableChild(info.TargetExecutionContext.Activity as CompositeActivity); if (activity != null) { activity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler); info.TargetExecutionContext.CompensateActivity(activity); return(true); } return(TryCompensateLastCompletedChildActivity(info.TargetExecutionContext, info.TargetExecutionContext.Activity, statusChangeHandler, false)); } } return(false); }
public override bool Run(IWorkflowCoreRuntime workflowCoreRuntime) { // get context activity Activity contextActivity = workflowCoreRuntime.GetContextActivityForId(this.ContextId); // Work around for ActivityExecutionStatusChangedEventArgs ActivityExecutionStatusChangedEventArgs activityStatusChangeEventArgs = this.args as ActivityExecutionStatusChangedEventArgs; if (activityStatusChangeEventArgs != null) { activityStatusChangeEventArgs.BaseExecutor = workflowCoreRuntime; if (activityStatusChangeEventArgs.Activity == null) { // status change for an activity that has been deleted dynamically since. activityStatusChangeEventArgs.BaseExecutor = null; return(false); } } // get activity, if null, or if activity has already closed or just initialized, or if primary has closed and // the target of the notification is not ActivityExecutionFilter, then Activity activity = contextActivity.GetActivityByName(this.activityQualifiedName); if (activity == null || ((activity.ExecutionStatus == ActivityExecutionStatus.Closed || activity.ExecutionStatus == ActivityExecutionStatus.Initialized) && !this.synchronousInvoke) || (activity.HasPrimaryClosed && !(this.eventListener is ActivityExecutionFilter)) ) { return(false); } // call the delegate try { using (workflowCoreRuntime.SetCurrentActivity(activity)) { using (ActivityExecutionContext activityExecutionContext = new ActivityExecutionContext(activity)) { if (this.delegateValue != null) { this.delegateValue(activityExecutionContext, this.args); } else { this.eventListener.OnEvent(activityExecutionContext, this.args); } } } } catch (Exception e) { if (activity != null) { System.Workflow.Runtime.WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 1, "Subscription handler of Activity {0} threw {1}", activity.QualifiedName, e.ToString()); } else { System.Workflow.Runtime.WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 1, "Subscription handler threw {0}", e.ToString()); } throw; } finally { // Work around for activity status change Event Args if (activityStatusChangeEventArgs != null) { activityStatusChangeEventArgs.BaseExecutor = null; } } return(true); }
public RuleExecution(RuleValidation validation, object thisObject, System.Workflow.ComponentModel.ActivityExecutionContext activityExecutionContext) : this(validation, thisObject) { this.activityExecutionContext = activityExecutionContext; }
public abstract ActivityExecutionStatus HandleFault(Activity activity, ActivityExecutionContext executionContext, Exception exception);