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 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);
}
private void AppCompletionCleanup(NativeActivityContext context, CompensationExtension compensationExtension, CompensationTokenData compensationToken)
{
if (compensationToken.ParentCompensationId != 0L)
{
compensationExtension.Get(compensationToken.ParentCompensationId).ExecutionTracker.Remove(compensationToken);
}
else
{
compensationExtension.Get(0L).ExecutionTracker.Remove(compensationToken);
}
compensationToken.RemoveBookmark(context, CompensationBookmarkName.Canceled);
compensationToken.RemoveBookmark(context, CompensationBookmarkName.Compensated);
compensationExtension.Remove(compensationToken.CompensationId);
}
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 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 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 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);
}
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 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);
}
}
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);
}
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 ScheduleSecondaryRoot(NativeActivityContext context, CompensationExtension compensationExtension, CompensationTokenData token)
{
if (token.ParentCompensationId != 0L)
{
compensationExtension.Get(token.ParentCompensationId).ExecutionTracker.Add(token);
}
else
{
compensationExtension.Get(0L).ExecutionTracker.Add(token);
}
if ((base.Result != null) && (token.CompensationState == CompensationState.Completed))
{
base.Result.Set(context, this.currentCompensationToken.Get(context));
}
token.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled] = context.CreateBookmark(new BookmarkCallback(this.OnSecondaryRootScheduled));
this.compensationId.Set(context, token.CompensationId);
context.ScheduleSecondaryRoot(this.CompensationParticipant, context.Environment);
}
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);
}
// 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 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 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 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);
}
}
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 OnCompensated(NativeActivityContext context, Bookmark bookmark, object value)
{
CompensationExtension extension = context.GetExtension <CompensationExtension>();
CompensationToken token = this.Target.Get(context);
CompensationTokenData compensationToken = extension.Get(token.CompensationId);
compensationToken.CompensationState = CompensationState.Compensated;
if (TD.CompensationStateIsEnabled())
{
TD.CompensationState(compensationToken.DisplayName, compensationToken.CompensationState.ToString());
}
if (compensationToken.ParentCompensationId != 0L)
{
extension.Get(compensationToken.ParentCompensationId).ExecutionTracker.Remove(compensationToken);
}
else
{
extension.Get(0L).ExecutionTracker.Remove(compensationToken);
}
compensationToken.RemoveBookmark(context, CompensationBookmarkName.Compensated);
extension.Remove(token.CompensationId);
}
private void OnConfirm(NativeActivityContext context, Bookmark bookmark, object value)
{
CompensationExtension extension = context.GetExtension <CompensationExtension>();
CompensationToken token = (CompensationToken)value;
this.currentCompensationToken.Set(context, token);
if (extension.Get(token.CompensationId).ExecutionTracker.Count > 0)
{
context.ScheduleActivity(this.DefaultConfirmation, new CompletionCallback(this.OnConfirmationComplete));
}
else
{
this.OnConfirmationComplete(context, null);
}
}
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);
}
}
}
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);
}
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);
}
}
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 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 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);
}
}
private void OnMainRootComplete(NativeActivityContext context, Bookmark bookmark, object value)
{
CompensationExtension extension = context.GetExtension <CompensationExtension>();
CompensationTokenData tokenData = extension.Get(0L);
switch (((ActivityInstanceState)value))
{
case ActivityInstanceState.Closed:
context.ResumeBookmark(extension.WorkflowConfirmation, new CompensationToken(tokenData));
return;
case ActivityInstanceState.Canceled:
context.ResumeBookmark(extension.WorkflowCompensation, new CompensationToken(tokenData));
return;
case ActivityInstanceState.Faulted:
context.RemoveBookmark(extension.WorkflowConfirmation);
context.RemoveBookmark(extension.WorkflowCompensation);
break;
}
}
protected override void Execute(NativeActivityContext context)
{
CompensationExtension compensationExtension = context.GetExtension <CompensationExtension>();
Fx.Assert(compensationExtension != null, "CompensationExtension must be valid");
long compensationId = this.compensationId.Get(context);
Fx.Assert(compensationId != CompensationToken.RootCompensationId, "CompensationId passed to the SecondaryRoot must be valid");
CompensationTokenData compensationToken = compensationExtension.Get(compensationId);
Fx.Assert(compensationToken != null, "CompensationTokenData must be valid");
CompensationToken token = new CompensationToken(compensationToken);
this.currentCompensationToken.Set(context, token);
compensationToken.IsTokenValidInSecondaryRoot = true;
context.Properties.Add(CompensationToken.PropertyName, token);
Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.OnConfirmation] == null, "Bookmark should not be already initialized in the bookmark table.");
compensationToken.BookmarkTable[CompensationBookmarkName.OnConfirmation] = context.CreateBookmark(new BookmarkCallback(OnConfirmation));
Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.OnCompensation] == null, "Bookmark should not be already initialized in the bookmark table.");
compensationToken.BookmarkTable[CompensationBookmarkName.OnCompensation] = context.CreateBookmark(new BookmarkCallback(OnCompensation));
Fx.Assert(compensationToken.BookmarkTable[CompensationBookmarkName.OnCancellation] == null, "Bookmark should not be already initialized in the bookmark table.");
compensationToken.BookmarkTable[CompensationBookmarkName.OnCancellation] = context.CreateBookmark(new BookmarkCallback(OnCancellation));
Bookmark onSecondaryRootScheduled = compensationToken.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled];
Fx.Assert(onSecondaryRootScheduled != null, "onSecondaryRootScheduled bookmark must be already registered.");
compensationToken.BookmarkTable[CompensationBookmarkName.OnSecondaryRootScheduled] = null;
context.ResumeBookmark(onSecondaryRootScheduled, compensationId);
}
