internal Exception ExecuteStep(IExecutionStep step, ref bool completedSynchronously)
{
Exception exception = null;
//try
//{
//try
//{
if (step.IsCancellable)
{
_context.WorkerRequest.BeginCancellablePeriod();
try { step.Execute(); }
finally { _context.WorkerRequest.EndCancellablePeriod(); }
_context.WorkerRequest.WaitForExceptionIfCancelled();
}
else
{
step.Execute();
}
if (!step.CompletedSynchronously)
{
completedSynchronously = false;
return(null);
}
//}
//catch (Exception ex)
//{
// exception = ex;
// if ((ex is ThreadAbortException) && ((Thread.CurrentThread.ThreadState & ThreadState.AbortRequested) == ThreadState.Running))
// {
// exception = null;
// _stepManager.CompleteRequest();
// }
//}
//catch { }
//}
//catch (ThreadAbortException ex)
//{
// if ((ex.ExceptionState != null) && (ex.ExceptionState is CancelModuleException))
// {
// var exceptionState = (CancelModuleException)ex.ExceptionState;
// if (exceptionState.Timeout)
// exception = new HttpException("Request_timed_out", null, 0xbb9);
// else
// {
// exception = null;
// _stepManager.CompleteRequest();
// }
// Thread.ResetAbort();
// }
//}
completedSynchronously = true;
return(exception);
}
/*
* Execute single step catching exceptions in a fancy way (see below)
*/
internal Exception ExecuteStep(IExecutionStep step, ref bool completedSynchronously) {
Exception error = null;
try {
try {
if (step.IsCancellable) {
_context.BeginCancellablePeriod(); // request can be cancelled from this point
try {
step.Execute();
}
finally {
_context.EndCancellablePeriod(); // request can be cancelled until this point
}
_context.WaitForExceptionIfCancelled(); // wait outside of finally
}
else {
step.Execute();
}
if (!step.CompletedSynchronously) {
completedSynchronously = false;
return null;
}
}
catch (Exception e) {
error = e;
// Since we will leave the context later, we need to remember if we are impersonating
// before we lose that info - VSWhidbey 494476
if (ImpersonationContext.CurrentThreadTokenExists) {
e.Data[System.Web.Management.WebThreadInformation.IsImpersonatingKey] = String.Empty;
}
// This might force ThreadAbortException to be thrown
// automatically, because we consumed an exception that was
// hiding ThreadAbortException behind it
if (e is ThreadAbortException &&
((Thread.CurrentThread.ThreadState & ThreadState.AbortRequested) == 0)) {
// Response.End from a COM+ component that re-throws ThreadAbortException
// It is not a real ThreadAbort
// VSWhidbey 178556
error = null;
_stepManager.CompleteRequest();
}
}
#pragma warning disable 1058
catch {
// ignore non-Exception objects that could be thrown
}
#pragma warning restore 1058
}
catch (ThreadAbortException e) {
// ThreadAbortException could be masked as another one
// the try-catch above consumes all exceptions, only
// ThreadAbortException can filter up here because it gets
// auto rethrown if no other exception is thrown on catch
if (e.ExceptionState != null && e.ExceptionState is CancelModuleException) {
// one of ours (Response.End or timeout) -- cancel abort
CancelModuleException cancelException = (CancelModuleException)e.ExceptionState;
if (cancelException.Timeout) {
// Timed out
error = new HttpException(SR.GetString(SR.Request_timed_out),
null, WebEventCodes.RuntimeErrorRequestAbort);
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_TIMED_OUT);
}
else {
// Response.End
error = null;
_stepManager.CompleteRequest();
}
Thread.ResetAbort();
}
}
completedSynchronously = true;
return error;
}
public bool Execute(IFreeformEntity_Msg request)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "Execute"))
{
bool result = default(bool);
string key = string.Empty;
try
{
key = request.IpAddress;
ExecutionStepDictionary steps = _executionSteps;
_isExecuting = true;
//_gmuExecutionStepsExecuting.AddOrUpdate(key, true, (k, b) => { return true; });
//if (!_gmuExecutionSteps.ContainsKey(key))
//{
// steps = new ExecutionStepDictionary();
// steps.Entity.GmuIpAddress = key;
// steps.CreateExecutionSteps(ExecutionStepFactory.Current.DeviceType, _messageWiseSteps, _groupedSteps);
// _gmuExecutionSteps.Add(key, steps);
// _entities.Add(steps.Entity);
//}
//else
//{
// steps = _gmuExecutionSteps[key];
//}
if (steps != null)
{
// has clients
bool hasClients = false;
ExCommsExecutionStepEntity entity = steps.Entity;
IExecutionStep execStepCurrent = null;
IExecutionStep execStepLatest = null;
entity.Steps.Clear();
if (ExCommsServerImpl.Current != null)
{
hasClients = ExCommsServerImpl.Current.HasStepChangedClients;
}
#if !OLD_CODE
// 1. find the execution step by message
string messageKey = request.EntityUniqueKeyDirection;
if (_messageWiseSteps.ContainsKey(messageKey))
{
var stepList = _messageWiseSteps[messageKey];
if (stepList.Count == 1)
{
execStepCurrent = stepList[0];
}
}
// execute the step
if (execStepCurrent != null)
{
// last step
IExecutionStep execStepLast = (steps.Current ?? steps.Start);
if (hasClients && execStepLast != null)
{
entity.Steps.Add(execStepLast.GetType().Name);
}
// execute the current step
execStepLatest = execStepCurrent.Execute(request);
//// move to or set to next step
//if (execStepLatest != null &&
// execStepLatest.ExecutionResult == ExecutionStepResult.Success)
//{
// if (execStepLatest.NextStep != null)
// {
// if (execStepLatest.MoveToNextStep)
// {
// if (hasClients && execStepLatest.NextStep != null)
// entity.Steps.Add(execStepLatest.NextStep.GetType().Name);
// execStepLatest = execStepLatest.NextStep.Execute(request);
// }
// //if (execStepLatest.SetNextStep)
// //{
// // if (hasClients)
// // entity.Steps.Add(execStepLatest.GetType().Name);
// // execStepLatest = execStepLatest.NextStep;
// // execStepLatest.ExecutionResult = ExecutionStepResult.Success;
// //}
// }
//}
if (execStepLatest != null &&
execStepLatest.ExecutionResult == ExecutionStepResult.Success &&
!Object.ReferenceEquals(steps.Current, execStepLatest))
{
steps.Current = execStepLatest;
}
}
#else
// last step
IExecutionStep step = (steps.Current ?? steps.Start);
if (hasClients && step != null)
{
entity.Steps.Add(step.GetType().Name);
}
// previous step
if (step.ExecutionResult == ExecutionStepResult.Failed &&
step.PrevStep != null)
{
step = step.PrevStep;
}
// execute the current step
if (hasClients && step != null)
{
entity.Steps.Add(step.GetType().Name);
}
IExecutionStep step2 = step.Execute(request);
// move to or set to next step
if (step2 != null &&
step2.ExecutionResult == ExecutionStepResult.Success)
{
if (step2.NextStep != null)
{
if (step2.MoveToNextStep)
{
if (hasClients && step2.NextStep != null)
{
entity.Steps.Add(step2.NextStep.GetType().Name);
}
step2 = step2.NextStep.Execute(request);
}
if (step2.SetNextStep)
{
if (hasClients)
{
entity.Steps.Add(step2.GetType().Name);
}
step2 = step2.NextStep;
step2.ExecutionResult = ExecutionStepResult.Success;
}
}
}
if (step2 != null &&
step2.ExecutionResult == ExecutionStepResult.Success &&
!Object.ReferenceEquals(steps.Current, step2))
{
steps.Current = step2;
}
#endif
if (hasClients)
{
if (execStepLatest != null)
{
entity.Steps.Add(execStepLatest.UniqueKey);
}
ExCommsServerImpl.Current.OnNotifyExecutionStepChanged(entity);
}
}
}
catch (Exception ex)
{
method.Exception(ex);
}
finally
{
//_gmuExecutionStepsExecuting.AddOrUpdate(key, false, (k, b) => { return false; });
_isExecuting = false;
}
return(result);
}
}
internal Exception ExecuteStep(IExecutionStep step, ref bool completedSynchronously)
{
Exception exception = null;
try
{
try
{
if (step.IsCancellable)
{
this._context.BeginCancellablePeriod();
try
{
step.Execute();
}
finally
{
this._context.EndCancellablePeriod();
}
this._context.WaitForExceptionIfCancelled();
}
else
{
step.Execute();
}
if (!step.CompletedSynchronously)
{
completedSynchronously = false;
return null;
}
}
catch (Exception exception2)
{
exception = exception2;
if (ImpersonationContext.CurrentThreadTokenExists)
{
exception2.Data["ASPIMPERSONATING"] = string.Empty;
}
if ((exception2 is ThreadAbortException) && ((Thread.CurrentThread.ThreadState & System.Threading.ThreadState.AbortRequested) == System.Threading.ThreadState.Running))
{
exception = null;
this._stepManager.CompleteRequest();
}
}
catch
{
}
}
catch (ThreadAbortException exception3)
{
if ((exception3.ExceptionState != null) && (exception3.ExceptionState is CancelModuleException))
{
CancelModuleException exceptionState = (CancelModuleException) exception3.ExceptionState;
if (exceptionState.Timeout)
{
exception = new HttpException(System.Web.SR.GetString("Request_timed_out"), null, 0xbb9);
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_TIMED_OUT);
}
else
{
exception = null;
this._stepManager.CompleteRequest();
}
Thread.ResetAbort();
}
}
completedSynchronously = true;
return exception;
}