private void OnTryFaulted(NativeActivityFaultContext faultContext, Exception propagatedException, ActivityInstance propagatedFrom)
{
// TODO: delete
// Write event into the log
// This is necessary here because the trace log won't be available later
/*var record = new CustomTrackingRecord("OnTryFaulted", System.Diagnostics.TraceLevel.Error)
* {
* Data =
* {
* { "Exception", propagatedException },
* { "JobGuid", JobGuid.Get(faultContext) },
* { "UserGuid", UserGuid.Get(faultContext) },
* }
* };
* faultContext.Track(record);
*/
// Handle exception
int r = retries.Get(faultContext);
retries.Set(faultContext, ++r);
faultContext.CancelChild(propagatedFrom);
faultContext.HandleFault();
// Run the finally block before doing anything else
if (Finally != null)
{
faultContext.ScheduleActivity(this.Finally, OnFinallyComplete, OnFinallyFaulted);
}
else
{
OnFinallyComplete(faultContext, null);
}
// If retry is possible,
if (r < MaxRetries.Get(faultContext))
{
// absorb error
faultContext.HandleFault();
faultContext.ScheduleActivity(this.Try, OnTryComplete, OnTryFaulted);
}
else
{
// fault
throw propagatedException;
}
}
protected void BodyFaulted(NativeActivityFaultContext faultContext, Exception propagatedException, ActivityInstance propagatedFrom)
{
this.DisposeMonitor(faultContext);
this.HandleException(propagatedException, this.ContinueOnError.Get(faultContext));
faultContext.CancelChildren();
faultContext.HandleFault();
}
private void onWorkItemFaulted(NativeActivityFaultContext faultcontext,
Exception propagatedexception, ActivityInstance propagatedfrom)
{
faultcontext.HandleFault();
faultcontext.CancelChildren();
_childFault.Set(faultcontext, propagatedexception);
}
private void OnFaultedCallback(NativeActivityFaultContext faultContext, Exception exception, ActivityInstance source)
{
faultContext.CancelChildren();
DatabaseConnection conn = DBConnection.Get(faultContext);
if (conn != null)
{
try
{
if (UseTransaction)
{
conn.Rollback();
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
conn.Dispose();
}
}
HandleException(exception, ContinueOnError.Get(faultContext));
faultContext.HandleFault();
}
protected override void OnFaulted(NativeActivityFaultContext faultContext,
Exception propagatedException, ActivityInstance propagatedFrom)
{
Console.WriteLine("OnFaulted: {0}", propagatedException.Message);
faultContext.HandleFault();
faultContext.CancelChild(propagatedFrom);
Console.WriteLine("OnFaulted: Exception was handled");
}
void OnExceptionFromTry(NativeActivityFaultContext context, Exception propagatedException, ActivityInstance propagatedFrom)
{
if (propagatedFrom.IsCancellationRequested)
{
if (TD.TryCatchExceptionDuringCancelationIsEnabled())
{
TD.TryCatchExceptionDuringCancelation(this.DisplayName);
}
// The Try activity threw an exception during Cancel; abort the workflow
context.Abort(propagatedException);
context.HandleFault();
}
else
{
Catch catchHandler = FindCatch(propagatedException);
if (catchHandler != null)
{
if (TD.TryCatchExceptionFromTryIsEnabled())
{
TD.TryCatchExceptionFromTry(this.DisplayName, propagatedException.GetType().ToString());
}
context.CancelChild(propagatedFrom);
TryCatchState state = this.state.Get(context);
// If we are not supposed to persist exceptions, enter our noPersistScope
ExceptionPersistenceExtension extension = context.GetExtension <ExceptionPersistenceExtension>();
if ((extension != null) && !extension.PersistExceptions)
{
NoPersistProperty noPersistProperty = (NoPersistProperty)context.Properties.FindAtCurrentScope(NoPersistProperty.Name);
if (noPersistProperty != null)
{
// The property will be exited when the activity completes or aborts.
noPersistProperty.Enter();
}
}
state.CaughtException = context.CreateFaultContext();
context.HandleFault();
}
}
}
private void OnExceptionFromTry(NativeActivityFaultContext context, Exception propagatedException, System.Activities.ActivityInstance propagatedFrom)
{
if (propagatedFrom.IsCancellationRequested)
{
if (TD.TryCatchExceptionDuringCancelationIsEnabled())
{
TD.TryCatchExceptionDuringCancelation(base.DisplayName);
}
context.Abort(propagatedException);
context.HandleFault();
}
else if (this.FindCatch(propagatedException) != null)
{
if (TD.TryCatchExceptionFromTryIsEnabled())
{
TD.TryCatchExceptionFromTry(base.DisplayName, propagatedException.GetType().ToString());
}
context.CancelChild(propagatedFrom);
this.state.Get(context).CaughtException = context.CreateFaultContext();
context.HandleFault();
}
}
/// <summary>
/// Invoked when an error occurs in the body.
/// </summary>
/// <param name="context"></param>
/// <param name="propagatedException"></param>
/// <param name="propagatedFrom"></param>
void OnBodyFaulted(NativeActivityFaultContext context, Exception propagatedException, ActivityInstance propagatedFrom)
{
var state = this.state.Get(context);
// discover if exception is handled, if so cancel children and record
var c = FindCatch(propagatedException);
if (c != null)
{
context.CancelChild(propagatedFrom);
state.CaughtException = propagatedException;
context.HandleFault();
}
}
// TODO: we propagate an unhandled exception during an operation back to the task, should we handle it differently?
private void BodyFaultCallback(NativeActivityFaultContext context, Exception propagatedException, ActivityInstance propagatedFrom)
{
if (!context.GetReceiveRequestSendResponseScopeExecutionProperty().TrySetTaskCompletionSourceException(propagatedException))
{
// this will add a WorkflowInstanceAbortedRecord with the reason
context.Abort(propagatedException);
}
else
{
// this won't add any WorkflowInstanceAbortedRecord at all
context.Abort();
}
context.HandleFault();
}
/// <summary>
/// Respond to the fault callback, used for all scheduled activities.
/// </summary>
/// <param name="context">The activity context.</param>
/// <param name="exception">An exception which was thrown by the activity.</param>
/// <param name="instance">The current instance of the activity.</param>
private void OnOperationFault(NativeActivityFaultContext context, Exception exception, ActivityInstance instance)
{
// Mark the fault handled, or else this activity will throw and will not contine after this method returns.
context.HandleFault();
// TODO: Make this logging dependent on the operation configuration
LogBuildError(context, string.Format("AzureAsyncOperation Fault {0} during execution of {1}\r\n{2}", exception.GetType().Name, instance.Activity.GetType().Name, exception.Message));
LogBuildMessage(context, exception.StackTrace, BuildMessageImportance.High);
// Cancel the running activity
context.CancelChild(instance);
// Notify that an exception has been caught
// The CompletionCallback will be called because we handled the exception.
// This makes a better design choice to do any scheduling or further logic there.
this.AzureActivityExceptionCaught.Set(context, true);
}
private void BodyFaulted(NativeActivityFaultContext faultContext, Exception propagatedException, ActivityInstance propagatedFrom)
{
if (ContinueOnError.Get(faultContext))
{
// Cancel all remaining actions for the current event.
faultContext.CancelChildren();
// ... but continue monitoring and triggering new events.
faultContext.HandleFault();
Trace.TraceError(propagatedException.ToString());
}
else
{
CleanUp(faultContext);
throw propagatedException;
}
}
private void ActionFailed(NativeActivityFaultContext faultContext, Exception propagatedexception, ActivityInstance propagatedfrom)
{
Int32 currentAttemptCount = _attemptCount.Get(faultContext);
Int32 maxAttempts = MaxAttempts.Get(faultContext);
Type[] exceptionType = ExceptionType.Get(faultContext);
//Increment and track the count
currentAttemptCount++;
_attemptCount.Set(faultContext, currentAttemptCount);
if (currentAttemptCount >= maxAttempts)
{
// There are no further attempts to make
return;
}
if (ShouldRetryAction(exceptionType, propagatedexception) == false)
{
_log.Error("Will only retry exception of type '" + exceptionType.ToCSV() + "'. Unhandled type of '" + propagatedexception.GetType().FullName + "' was found.", propagatedexception);
return;
}
faultContext.CancelChild(propagatedfrom);
faultContext.HandleFault();
TimeSpan retryInterval = _delayOverrideForUnitTests == null?RetryInterval.Get(faultContext) : _delayOverrideForUnitTests.Value;
_log.Debug("Retrying in " + retryInterval.TotalSeconds + " seconds due to " + propagatedexception.GetType().FullName + ". " + currentAttemptCount + " of " + maxAttempts);
if (retryInterval == TimeSpan.Zero)
{
ExecuteAttempt(faultContext);
}
else
{
// We are going to wait before trying again
_delayDuration.Set(faultContext, retryInterval);
faultContext.ScheduleActivity(
_internalDelay,
DelayCompleted);
}
}
private void ActionFailed(NativeActivityFaultContext faultcontext, Exception propagatedexception, ActivityInstance propagatedfrom)
{
Int32 currentAttemptCount = _attemptCount.Get(faultcontext);
currentAttemptCount++;
_attemptCount.Set(faultcontext, currentAttemptCount);
Int32 maxAttempts = MaxAttempts.Get(faultcontext);
if (currentAttemptCount >= maxAttempts)
{
// There are no further attempts to make
return;
}
if (ShouldRetryAction(ExceptionType, propagatedexception) == false)
{
return;
}
faultcontext.CancelChild(propagatedfrom);
faultcontext.HandleFault();
TimeSpan retryInterval = RetryInterval.Get(faultcontext);
if (retryInterval == TimeSpan.Zero)
{
ExecuteAttempt(faultcontext);
}
else
{
// We are going to wait before trying again
_delayDuration.Set(faultcontext, retryInterval);
faultcontext.ScheduleActivity(_internalDelay, DelayCompleted);
}
}