private void OnExceptionFromHandler(NativeActivityFaultContext context, Exception propagatedException, ActivityInstance propagatedFrom) { CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); CompensationTokenData compensationToken = compensationExtension.Get(this.compensationId.Get(context)); Fx.Assert(compensationToken != null, "CompensationTokenData must be valid"); InvalidOperationException exception = null; switch (compensationToken.CompensationState) { case CompensationState.Confirming: exception = new InvalidOperationException(SR.ConfirmationHandlerFatalException(compensationToken.DisplayName), propagatedException); break; case CompensationState.Compensating: exception = new InvalidOperationException(SR.CompensationHandlerFatalException(compensationToken.DisplayName), propagatedException); break; case CompensationState.Canceling: exception = new InvalidOperationException(SR.CancellationHandlerFatalException(compensationToken.DisplayName), propagatedException); break; default: Fx.Assert(false, "CompensationState is in unexpected state!"); break; } context.Abort(exception); }
private void OnCancellationHandlerComplete(NativeActivityContext context, ActivityInstance completedInstance) { CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); CompensationTokenData compensationToken = compensationExtension.Get(this.compensationId.Get(context)); Fx.Assert(compensationToken != null, "CompensationTokenData must be valid"); if (completedInstance.State == ActivityInstanceState.Closed) { Fx.Assert(compensationToken.CompensationState == CompensationState.Canceling, "CompensationParticipant should be in Canceling State"); this.currentCompensationToken.Set(context, new CompensationToken(compensationToken)); if (compensationToken.ExecutionTracker.Count > 0) { context.ScheduleActivity(DefaultConfirmation, new CompletionCallback(this.OnCompensationComplete)); } else { this.InternalOnCompensationComplete(context, compensationExtension, compensationToken); } } }
private void AppCompletionCleanup(NativeActivityContext context, CompensationExtension compensationExtension, CompensationTokenData compensationToken) { Fx.Assert(compensationToken != null, "CompensationTokenData must be valid"); // Remove the token from the parent! if (compensationToken.ParentCompensationId != CompensationToken.RootCompensationId) { CompensationTokenData parentToken = compensationExtension.Get(compensationToken.ParentCompensationId); Fx.Assert(parentToken != null, "parentToken must be valid"); parentToken.ExecutionTracker.Remove(compensationToken); } else { // remove from workflow root... CompensationTokenData parentToken = compensationExtension.Get(CompensationToken.RootCompensationId); Fx.Assert(parentToken != null, "parentToken must be valid"); parentToken.ExecutionTracker.Remove(compensationToken); } compensationToken.RemoveBookmark(context, CompensationBookmarkName.Canceled); compensationToken.RemoveBookmark(context, CompensationBookmarkName.Compensated); // Remove the token from the extension... compensationExtension.Remove(compensationToken.CompensationId); }
private void OnSecondaryRootScheduled(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"); if (compensationToken.CompensationState == CompensationState.Canceling) { Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.Canceled] == null, "Bookmark should not be already initialized in the bookmark table."); compensationToken.BookmarkTable[CompensationBookmarkName.Canceled] = context.CreateBookmark(new BookmarkCallback(OnCanceledOrCompensated)); compensationExtension.NotifyMessage(context, compensationToken.CompensationId, CompensationBookmarkName.OnCancellation); } else if (compensationToken.CompensationState == CompensationState.Compensating) { Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.Compensated] == null, "Bookmark should not be already initialized in the bookmark table."); compensationToken.BookmarkTable[CompensationBookmarkName.Compensated] = context.CreateBookmark(new BookmarkCallback(OnCanceledOrCompensated)); compensationExtension.NotifyMessage(context, compensationToken.CompensationId, CompensationBookmarkName.OnCompensation); } }
private void ScheduleSecondaryRoot(NativeActivityContext context, CompensationExtension compensationExtension, CompensationTokenData token) { if (token.ParentCompensationId != CompensationToken.RootCompensationId) { CompensationTokenData parentToken = compensationExtension.Get(token.ParentCompensationId); Fx.Assert(parentToken != null, "parentToken must be valid"); parentToken.ExecutionTracker.Add(token); } else { CompensationTokenData parentToken = compensationExtension.Get(CompensationToken.RootCompensationId); Fx.Assert(parentToken != null, "parentToken must be valid"); parentToken.ExecutionTracker.Add(token); } // If we are going to Cancel, don't set the out arg... if (Result != null && token.CompensationState == CompensationState.Completed) { Result.Set(context, this.currentCompensationToken.Get(context)); } Fx.Assert(token.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled] == null, "Bookmark should not be already initialized in the bookmark table."); token.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled] = context.CreateBookmark(new BookmarkCallback(OnSecondaryRootScheduled)); this.compensationId.Set(context, token.CompensationId); context.ScheduleSecondaryRoot(CompensationParticipant, context.Environment); }
internal CompensationTokenData Get(long compensationId) { CompensationTokenData compensationToken = null; this.CompensationTokenTable.TryGetValue(compensationId, out compensationToken); return(compensationToken); }
void InternalExecute(NativeActivityContext context, ActivityInstance completedInstance) { CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); if (compensationExtension == null) { throw SA.FxTrace.Exception.AsError(new InvalidOperationException(SA.SR.CompensateWithoutCompensableActivity(this.DisplayName))); } CompensationToken token = Target.Get(context); CompensationTokenData tokenData = token == null ? null : compensationExtension.Get(token.CompensationId); Fx.Assert(tokenData != null, "CompensationTokenData must be valid"); if (tokenData.ExecutionTracker.Count > 0) { if (this.onChildCompensated == null) { this.onChildCompensated = new CompletionCallback(InternalExecute); } this.toCompensateToken.Set(context, new CompensationToken(tokenData.ExecutionTracker.Get())); Fx.Assert(Body != null, "Body must be valid"); context.ScheduleActivity(Body, this.onChildCompensated); } }
private void OnCompensationComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance) { CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); CompensationTokenData compensationToken = compensationExtension.Get(this.compensationId.Get(context)); this.InternalOnCompensationComplete(context, compensationExtension, compensationToken); }
public CompensationToken(CompensationTokenData tokenData) { if (tokenData != null) { this.CompensationId = tokenData.CompensationId; } }
void OnMainRootComplete(NativeActivityContext context, Bookmark bookmark, object value) { CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); CompensationTokenData rootHandle = compensationExtension.Get(CompensationToken.RootCompensationId); Fx.Assert(rootHandle != null, "rootToken must be valid"); ActivityInstanceState completionState = (ActivityInstanceState)value; if (completionState == ActivityInstanceState.Closed) { context.ResumeBookmark(compensationExtension.WorkflowConfirmation, new CompensationToken(rootHandle)); } else if (completionState == ActivityInstanceState.Canceled) { context.ResumeBookmark(compensationExtension.WorkflowCompensation, new CompensationToken(rootHandle)); } else if (completionState == ActivityInstanceState.Faulted) { // Do nothing. Neither Compensate nor Confirm. // Remove the bookmark to complete the WorkflowCompensationBehavior execution. context.RemoveBookmark(compensationExtension.WorkflowConfirmation); context.RemoveBookmark(compensationExtension.WorkflowCompensation); } }
private void OnBodyExecutionComplete(NativeActivityContext context, ActivityInstance completedInstance) { CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); CompensationTokenData token = compensationExtension.Get(this.currentCompensationId.Get(context)); Fx.Assert(token != null, "CompensationTokenData must be valid"); if (completedInstance.State == ActivityInstanceState.Closed) { token.CompensationState = CompensationState.Completed; if (TD.CompensationStateIsEnabled()) { TD.CompensationState(token.DisplayName, token.CompensationState.ToString()); } if (context.IsCancellationRequested) { token.CompensationState = CompensationState.Compensating; } } else if (completedInstance.State == ActivityInstanceState.Canceled || completedInstance.State == ActivityInstanceState.Faulted) { // we check for faulted as well for one odd case where an exception can be thrown from the body activity itself. token.CompensationState = CompensationState.Canceling; } else { Fx.Assert(false, "completedInstance in unexpected state"); } ScheduleSecondaryRoot(context, compensationExtension, token); }
private void OnCancellation(NativeActivityContext context, Bookmark bookmark, object value) { CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); long compensationId = (long)value; CompensationTokenData tokenData = compensationExtension.Get(compensationId); if (TD.CompensationStateIsEnabled()) { TD.CompensationState(tokenData.DisplayName, tokenData.CompensationState.ToString()); } tokenData.RemoveBookmark(context, CompensationBookmarkName.OnCompensation); tokenData.RemoveBookmark(context, CompensationBookmarkName.OnConfirmation); this.currentCompensationToken.Set(context, new CompensationToken(tokenData)); if (this.CancellationHandler != null) { context.ScheduleActivity(this.CancellationHandler, new CompletionCallback(this.OnCancellationHandlerComplete), new FaultCallback(this.OnExceptionFromHandler)); } else if (tokenData.ExecutionTracker.Count > 0) { context.ScheduleActivity(this.DefaultCompensation, new CompletionCallback(this.OnCompensationComplete)); } else { this.InternalOnCompensationComplete(context, compensationExtension, tokenData); } }
protected override void Execute(NativeActivityContext context) { CompensationExtension extension = context.GetExtension <CompensationExtension>(); CompensationToken token = this.Target.Get(context); CompensationTokenData data = extension.Get(token.CompensationId); data.BookmarkTable[CompensationBookmarkName.Compensated] = context.CreateBookmark(new BookmarkCallback(this.OnCompensated)); data.CompensationState = CompensationState.Compensating; extension.NotifyMessage(context, data.CompensationId, CompensationBookmarkName.OnCompensation); }
private void OnConfirmationComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance) { CompensationExtension extension = context.GetExtension <CompensationExtension>(); CompensationTokenData data = extension.Get(this.compensationId.Get(context)); if (completedInstance.State == ActivityInstanceState.Closed) { extension.NotifyMessage(context, data.CompensationId, CompensationBookmarkName.Confirmed); } }
protected override void Execute(NativeActivityContext context) { CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); if (compensationExtension == null) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.ConfirmWithoutCompensableActivity(this.DisplayName))); } if (Target.IsEmpty) { CompensationToken ambientCompensationToken = (CompensationToken)context.Properties.Find(CompensationToken.PropertyName); CompensationTokenData ambientTokenData = ambientCompensationToken == null ? null : compensationExtension.Get(ambientCompensationToken.CompensationId); if (ambientTokenData != null && ambientTokenData.IsTokenValidInSecondaryRoot) { this.currentCompensationToken.Set(context, ambientCompensationToken); if (ambientTokenData.ExecutionTracker.Count > 0) { context.ScheduleActivity(DefaultConfirmation); } } else { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.InvalidConfirmActivityUsage(this.DisplayName))); } } else { CompensationToken compensationToken = Target.Get(context); CompensationTokenData tokenData = compensationToken == null ? null : compensationExtension.Get(compensationToken.CompensationId); if (compensationToken == null) { throw FxTrace.Exception.Argument("Target", SR.InvalidCompensationToken(this.DisplayName)); } if (compensationToken.ConfirmCalled) { // No-Op return; } if (tokenData == null || tokenData.CompensationState != CompensationState.Completed) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.CompensableActivityAlreadyConfirmedOrCompensated)); } // A valid in-arg was passed... tokenData.CompensationState = CompensationState.Confirming; compensationToken.ConfirmCalled = true; context.ScheduleActivity(InternalConfirm); } }
private void ScheduleBody(NativeActivityContext context, CompensationExtension compensationExtension) { Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); CompensationToken parentToken = null; long parentCompensationId = CompensationToken.RootCompensationId; parentToken = (CompensationToken)context.Properties.Find(CompensationToken.PropertyName); if (parentToken != null) { if (compensationExtension.Get(parentToken.CompensationId).IsTokenValidInSecondaryRoot) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.NoCAInSecondaryRoot)); } parentCompensationId = parentToken.CompensationId; } CompensationTokenData tokenData = new CompensationTokenData(compensationExtension.GetNextId(), parentCompensationId) { CompensationState = CompensationState.Active, DisplayName = this.DisplayName, }; CompensationToken token = new CompensationToken(tokenData); context.Properties.Add(CompensationToken.PropertyName, token); this.currentCompensationId.Set(context, token.CompensationId); this.currentCompensationToken.Set(context, token); compensationExtension.Add(token.CompensationId, tokenData); if (TD.CompensationStateIsEnabled()) { TD.CompensationState(tokenData.DisplayName, tokenData.CompensationState.ToString()); } if (this.Body != null) { context.ScheduleActivity(this.Body, new CompletionCallback(OnBodyExecutionComplete)); } else { //empty body case. Assume the body has completed successfully tokenData.CompensationState = CompensationState.Completed; if (TD.CompensationStateIsEnabled()) { TD.CompensationState(tokenData.DisplayName, tokenData.CompensationState.ToString()); } ScheduleSecondaryRoot(context, compensationExtension, tokenData); } }
internal Bookmark FindBookmark(long compensationId, CompensationBookmarkName bookmarkName) { CompensationTokenData data = null; Bookmark bookmark = null; if (this.CompensationTokenTable.TryGetValue(compensationId, out data)) { bookmark = data.BookmarkTable[bookmarkName]; } return(bookmark); }
internal Bookmark FindBookmark(long compensationId, CompensationBookmarkName bookmarkName) { CompensationTokenData compensationToken = null; Bookmark bookmark = null; if (this.CompensationTokenTable.TryGetValue(compensationId, out compensationToken)) { bookmark = compensationToken.BookmarkTable[bookmarkName]; } return bookmark; }
private void OnCompensationComplete(NativeActivityContext context, ActivityInstance completedInstance) { CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); CompensationTokenData compensationToken = compensationExtension.Get(this.compensationId.Get(context)); Fx.Assert(compensationToken != null, "CompensationTokenData must be valid"); InternalOnCompensationComplete(context, compensationExtension, compensationToken); }
private void OnSecondaryRootScheduled(NativeActivityContext context, Bookmark bookmark, object value) { CompensationExtension extension = context.GetExtension <CompensationExtension>(); long compensationId = (long)value; CompensationTokenData data = extension.Get(compensationId); if (data.CompensationState == CompensationState.Canceling) { data.BookmarkTable[CompensationBookmarkName.Canceled] = context.CreateBookmark(new BookmarkCallback(this.OnCanceledOrCompensated)); extension.NotifyMessage(context, data.CompensationId, CompensationBookmarkName.OnCancellation); } else if (data.CompensationState == CompensationState.Compensating) { data.BookmarkTable[CompensationBookmarkName.Compensated] = context.CreateBookmark(new BookmarkCallback(this.OnCanceledOrCompensated)); extension.NotifyMessage(context, data.CompensationId, CompensationBookmarkName.OnCompensation); } }
private void OnConfirmationHandlerComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance) { CompensationExtension extension = context.GetExtension <CompensationExtension>(); CompensationTokenData tokenData = extension.Get(this.compensationId.Get(context)); if (completedInstance.State == ActivityInstanceState.Closed) { this.currentCompensationToken.Set(context, new CompensationToken(tokenData)); if (tokenData.ExecutionTracker.Count > 0) { context.ScheduleActivity(this.DefaultConfirmation, new CompletionCallback(this.OnConfirmationComplete)); } else { extension.NotifyMessage(context, tokenData.CompensationId, CompensationBookmarkName.Confirmed); } } }
private void OnConfirmationComplete(NativeActivityContext context, ActivityInstance completedInstance) { Fx.Assert(context != null, "context must be valid"); Fx.Assert(completedInstance != null, "completedInstance must be valid"); CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); CompensationTokenData compensationToken = compensationExtension.Get(this.compensationId.Get(context)); Fx.Assert(compensationToken != null, "CompensationTokenData must be valid"); if (completedInstance.State == ActivityInstanceState.Closed) { compensationExtension.NotifyMessage(context, compensationToken.CompensationId, CompensationBookmarkName.Confirmed); } }
protected override void Execute(NativeActivityContext context) { CompensationExtension extension = context.GetExtension <CompensationExtension>(); long compensationId = this.compensationId.Get(context); CompensationTokenData tokenData = extension.Get(compensationId); CompensationToken token = new CompensationToken(tokenData); this.currentCompensationToken.Set(context, token); tokenData.IsTokenValidInSecondaryRoot = true; context.Properties.Add("System.Compensation.CompensationToken", token); tokenData.BookmarkTable[CompensationBookmarkName.OnConfirmation] = context.CreateBookmark(new BookmarkCallback(this.OnConfirmation)); tokenData.BookmarkTable[CompensationBookmarkName.OnCompensation] = context.CreateBookmark(new BookmarkCallback(this.OnCompensation)); tokenData.BookmarkTable[CompensationBookmarkName.OnCancellation] = context.CreateBookmark(new BookmarkCallback(this.OnCancellation)); Bookmark bookmark = tokenData.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled]; tokenData.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled] = null; context.ResumeBookmark(bookmark, compensationId); }
// Successfully received Confirmed response. void OnConfirmed(NativeActivityContext context, Bookmark bookmark, object value) { CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); CompensationToken compensationToken = Target.Get(context); Fx.Assert(compensationToken != null, "compensationToken must be valid"); // The compensationToken should be a valid one at this point. Ensure its validated in Confirm activity. CompensationTokenData tokenData = compensationExtension.Get(compensationToken.CompensationId); Fx.Assert(tokenData != null, "The compensationToken should be a valid one at this point. Ensure its validated in Confirm activity."); tokenData.CompensationState = CompensationState.Confirmed; if (TD.CompensationStateIsEnabled()) { TD.CompensationState(tokenData.DisplayName, tokenData.CompensationState.ToString()); } // Remove the token from the parent! if (tokenData.ParentCompensationId != CompensationToken.RootCompensationId) { CompensationTokenData parentToken = compensationExtension.Get(tokenData.ParentCompensationId); Fx.Assert(parentToken != null, "parentToken must be valid"); parentToken.ExecutionTracker.Remove(tokenData); } else { // remove from workflow root... CompensationTokenData parentToken = compensationExtension.Get(CompensationToken.RootCompensationId); Fx.Assert(parentToken != null, "parentToken must be valid"); parentToken.ExecutionTracker.Remove(tokenData); } tokenData.RemoveBookmark(context, CompensationBookmarkName.Confirmed); // Remove the token from the extension... compensationExtension.Remove(compensationToken.CompensationId); }
private void ScheduleBody(NativeActivityContext context, CompensationExtension compensationExtension) { CompensationToken token = null; long parentCompensationId = 0L; token = (CompensationToken)context.Properties.Find("System.Compensation.CompensationToken"); if (token != null) { if (compensationExtension.Get(token.CompensationId).IsTokenValidInSecondaryRoot) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.NoCAInSecondaryRoot)); } parentCompensationId = token.CompensationId; } CompensationTokenData tokenData = new CompensationTokenData(compensationExtension.GetNextId(), parentCompensationId) { CompensationState = CompensationState.Active, DisplayName = base.DisplayName }; CompensationToken property = new CompensationToken(tokenData); context.Properties.Add("System.Compensation.CompensationToken", property); this.currentCompensationId.Set(context, property.CompensationId); this.currentCompensationToken.Set(context, property); compensationExtension.Add(property.CompensationId, tokenData); if (TD.CompensationStateIsEnabled()) { TD.CompensationState(tokenData.DisplayName, tokenData.CompensationState.ToString()); } if (this.Body != null) { context.ScheduleActivity(this.Body, new CompletionCallback(this.OnBodyExecutionComplete)); } else { tokenData.CompensationState = CompensationState.Completed; if (TD.CompensationStateIsEnabled()) { TD.CompensationState(tokenData.DisplayName, tokenData.CompensationState.ToString()); } this.ScheduleSecondaryRoot(context, compensationExtension, tokenData); } }
private void OnCancellation(NativeActivityContext context, Bookmark bookmark, object value) { CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); long compensationId = (long)value; Fx.Assert(compensationId != CompensationToken.RootCompensationId, "CompensationId must be passed when resuming the Completed bookmark"); CompensationTokenData compensationToken = compensationExtension.Get(compensationId); Fx.Assert(compensationToken != null, "CompensationTokenData must be valid"); Fx.Assert(compensationToken.CompensationState == CompensationState.Canceling, "CompensationState should be in Canceling state"); if (TD.CompensationStateIsEnabled()) { TD.CompensationState(compensationToken.DisplayName, compensationToken.CompensationState.ToString()); } // remove bookmarks. compensationToken.RemoveBookmark(context, CompensationBookmarkName.OnCompensation); compensationToken.RemoveBookmark(context, CompensationBookmarkName.OnConfirmation); this.currentCompensationToken.Set(context, new CompensationToken(compensationToken)); if (CancellationHandler != null) { context.ScheduleActivity(CancellationHandler, new CompletionCallback(this.OnCancellationHandlerComplete), new FaultCallback(OnExceptionFromHandler)); } else { if (compensationToken.ExecutionTracker.Count > 0) { context.ScheduleActivity(DefaultCompensation, new CompletionCallback(this.OnCompensationComplete)); } else { this.InternalOnCompensationComplete(context, compensationExtension, compensationToken); } } }
protected override void Execute(NativeActivityContext context) { CompensationExtension extension = context.GetExtension <CompensationExtension>(); if (extension == null) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.ConfirmWithoutCompensableActivity(base.DisplayName))); } if (this.Target.IsEmpty) { CompensationToken token = (CompensationToken)context.Properties.Find("System.Compensation.CompensationToken"); CompensationTokenData data = (token == null) ? null : extension.Get(token.CompensationId); if ((data == null) || !data.IsTokenValidInSecondaryRoot) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.InvalidConfirmActivityUsage(base.DisplayName))); } this.currentCompensationToken.Set(context, token); if (data.ExecutionTracker.Count > 0) { context.ScheduleActivity(this.DefaultConfirmation); } } else { CompensationToken token2 = this.Target.Get(context); CompensationTokenData data2 = (token2 == null) ? null : extension.Get(token2.CompensationId); if (token2 == null) { throw FxTrace.Exception.Argument("Target", System.Activities.SR.InvalidCompensationToken(base.DisplayName)); } if (!token2.ConfirmCalled) { if ((data2 == null) || (data2.CompensationState != CompensationState.Completed)) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.CompensableActivityAlreadyConfirmedOrCompensated)); } data2.CompensationState = CompensationState.Confirming; token2.ConfirmCalled = true; context.ScheduleActivity(this.InternalConfirm); } } }
private void InternalExecute(NativeActivityContext context, System.Activities.ActivityInstance completedInstance) { CompensationExtension extension = context.GetExtension <CompensationExtension>(); if (extension == null) { throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.ConfirmWithoutCompensableActivity(base.DisplayName))); } CompensationToken token = this.Target.Get(context); CompensationTokenData data = (token == null) ? null : extension.Get(token.CompensationId); if (data.ExecutionTracker.Count > 0) { if (this.onChildConfirmed == null) { this.onChildConfirmed = new CompletionCallback(this.InternalExecute); } this.toConfirmToken.Set(context, new CompensationToken(data.ExecutionTracker.Get())); context.ScheduleActivity(this.Body, this.onChildConfirmed); } }
protected override void Execute(NativeActivityContext context) { CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>(); Fx.Assert(compensationExtension != null, "CompensationExtension must be valid"); CompensationToken compensationToken = Target.Get(context); Fx.Assert(compensationToken != null, "CompensationToken must be valid"); // The compensationToken should be a valid one at this point. Ensure its validated in Compensate activity. CompensationTokenData tokenData = compensationExtension.Get(compensationToken.CompensationId); Fx.Assert(tokenData != null, "The compensationToken should be a valid one at this point. Ensure its validated in Compensate activity."); Fx.Assert(tokenData.BookmarkTable[CompensationBookmarkName.Compensated] == null, "Bookmark should not be already initialized in the bookmark table."); tokenData.BookmarkTable[CompensationBookmarkName.Compensated] = context.CreateBookmark(new BookmarkCallback(OnCompensated)); tokenData.CompensationState = CompensationState.Compensating; compensationExtension.NotifyMessage(context, tokenData.CompensationId, CompensationBookmarkName.OnCompensation); }
private void OnExceptionFromHandler(NativeActivityFaultContext context, Exception propagatedException, System.Activities.ActivityInstance propagatedFrom) { CompensationTokenData data = context.GetExtension <CompensationExtension>().Get(this.compensationId.Get(context)); InvalidOperationException reason = null; switch (data.CompensationState) { case CompensationState.Confirming: reason = new InvalidOperationException(System.Activities.SR.ConfirmationHandlerFatalException(data.DisplayName), propagatedException); break; case CompensationState.Compensating: reason = new InvalidOperationException(System.Activities.SR.CompensationHandlerFatalException(data.DisplayName), propagatedException); break; case CompensationState.Canceling: reason = new InvalidOperationException(System.Activities.SR.CancellationHandlerFatalException(data.DisplayName), propagatedException); break; } context.Abort(reason); }
public void Remove(CompensationTokenData compensationToken) { this.executionOrderedList.Remove(compensationToken); }
public void Add(CompensationTokenData compensationToken) { this.executionOrderedList.Insert(0, compensationToken); }
internal void Add(long compensationId, CompensationTokenData compensationToken) { this.CompensationTokenTable[compensationId] = compensationToken; }
internal void Add(long compensationId, CompensationTokenData compensationToken) { Fx.Assert(compensationToken != null, "compensationToken must be valid"); this.CompensationTokenTable[compensationId] = compensationToken; }
internal CompensationToken(CompensationTokenData tokenData) { this.CompensationId = tokenData.CompensationId; }
void InternalOnCompensationComplete(NativeActivityContext context, CompensationExtension compensationExtension, CompensationTokenData compensationToken) { switch (compensationToken.CompensationState) { case CompensationState.Canceling: compensationExtension.NotifyMessage(context, compensationToken.CompensationId, CompensationBookmarkName.Canceled); break; case CompensationState.Compensating: compensationExtension.NotifyMessage(context, compensationToken.CompensationId, CompensationBookmarkName.Compensated); break; default: Fx.Assert(false, "CompensationState is in unexpected state!"); break; } }