private static void ArrangeExecutionSteps(this ExecutionStepDictionary execSteps,
IDictionary <string, ExecutionStepCollection> messageWiseSteps,
IDictionary <int, ExecutionStepCollection> groupedSteps)
{
using (ILogMethod method = Log.LogMethod(DYN_MODULE_NAME, "ArrangeExecutionSteps"))
{
try
{
Stack <IExecutionStep> st = new Stack <IExecutionStep>();
st.Push(execSteps.Start);
IDictionary <string, IExecutionStep> steps = new StringDictionary <IExecutionStep>();
while (st.Count != 0)
{
IExecutionStep step = st.Pop();
int level = Math.Max(0, (from p in step.PrevSteps
select p.Level).DefaultIfEmpty().Max()) + 1;
if (!steps.ContainsKey(step.UniqueKey))
{
step.Level = level;
steps.Add(step.UniqueKey, step);
}
foreach (var step2 in step.NextSteps)
{
if (!steps.ContainsKey(step2.UniqueKey))
{
st.Push(step2);
}
}
}
// last step
execSteps.End.Level = Math.Max(0, (from p in steps.Values
select p.Level).DefaultIfEmpty().Max()) + 1;
// Ordered projects
groupedSteps.Clear();
var orderedSteps = (from p in execSteps.Values
orderby p.Level
group p by p.Level);
foreach (var orderedStep in orderedSteps)
{
ExecutionStepCollection stepsList = new ExecutionStepCollection();
groupedSteps.Add(orderedStep.Key, stepsList);
foreach (var step in orderedStep)
{
stepsList.Add(step);
}
}
}
catch (Exception ex)
{
method.Exception(ex);
}
}
}
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);
}
public void ExecuteStep(IExecutionStep step)
{
// this position does not take the area dimensions into account
var position = step.GetNextPosition(Position, Direction);
// the final position takes the area dimensions into account
Position = new Vector(
_ComputeSlidingValue(position.X, AreaDimensions.X),
_ComputeSlidingValue(position.Y, AreaDimensions.Y)
);
Direction = step.GetNextDirection(Direction);
}
private static IExecutionStep AddOrUpdate(this _ExecutionStepFactory factory, Type dependency, string dependencyName)
{
IExecutionStep result = null;
if (!factory.ExecutionSteps.ContainsKey(dependencyName))
{
factory.ExecutionSteps.Add(dependencyName, (result = Activator.CreateInstance(dependency) as IExecutionStep));
result.Factory = factory;
result.Level = 1;
}
else
{
result = factory.ExecutionSteps[dependencyName];
}
return(result);
}
internal static void CreateExecutionSteps(this _ExecutionStepFactory factory)
{
using (ILogMethod method = Log.LogMethod(DYN_MODULE_NAME, "CreateExecutionSteps"))
{
try
{
ExecutionStepDictionary execSteps = factory.ExecutionSteps;
ExecutionStepDeviceTypes deviceType = ExecutionStepFactory.Current.DeviceType;
IDictionary <string, ExecutionStepCollection> messageWiseSteps = factory.MessageWiseSteps;
IDictionary <int, ExecutionStepCollection> groupedSteps = factory.GroupedSteps;
var mappings = (from m in _mappings
from j in m.Attributes
where j.DeviceType == deviceType
select m).ToArray();
foreach (var mapping in mappings)//.AsParallel())
{
Type classType = mapping.Type;
IExecutionStep step = factory.AddOrUpdate(classType, classType.Name);
foreach (var mappingAttribute in mapping.Attributes
.Where(d => d.DeviceType == deviceType))
{
if (mappingAttribute.IsStart && (execSteps.Start == null))
{
execSteps.Start = step;
}
if (mappingAttribute.IsEnd && (execSteps.End == null))
{
execSteps.End = step;
}
step.PostTypeG2H = mappingAttribute.PostTypeG2H;
step.PostTypeH2G = mappingAttribute.PostTypeH2G;
step.MoveToNextStep = mappingAttribute.MoveToNextStep;
//if (mappingAttribute.Dependencies != null)
//{
// foreach (var dependency in mappingAttribute.Dependencies)
// {
// IExecutionStep parentStep = execSteps.AddOrUpdate(dependency, dependency.Name);
// if (!parentStep.NextSteps.Contains(step))
// parentStep.NextSteps.Add(step);
// }
//}
//if (mappingAttribute.NextDependency != null)
//{
// var dependency = mappingAttribute.NextDependency;
// IExecutionStep nextStep = execSteps.AddOrUpdate(dependency, dependency.Name);
// if (!step.NextSteps.Contains(nextStep))
// step.NextSteps.Add(nextStep);
// step.NextStep = nextStep;
// step.SetNextStep = mappingAttribute.SetNextStep;
// nextStep.PrevStep = step;
//}
if (mappingAttribute.NextSteps != null)
{
foreach (var dependency in mappingAttribute.NextSteps)
{
IExecutionStep nextStep = factory.AddOrUpdate(dependency, dependency.Name);
//nextStep.Level = step.Level + 1;
bool resetNextStep = false;
if (!step.NextSteps.Contains(nextStep))
{
step.NextSteps.Add(nextStep);
resetNextStep = (step.NextSteps.Count > 1);
}
step.NextStep = (resetNextStep ? null : nextStep);
if (!nextStep.PrevSteps.Contains(step))
{
nextStep.PrevSteps.Add(step);
}
//step.SetNextStep = mappingAttribute.SetNextStep;
//nextStep.PrevStep = step;
}
}
if (messageWiseSteps != null &&
mappingAttribute.AllowedMessages != null)
{
var direction = mappingAttribute.AllowedMessageDirectionAll;
int length = mappingAttribute.AllowedMessages.Length;
for (int i = 0; i < mappingAttribute.AllowedMessages.Length; i++)
{
if (mappingAttribute.AllowedMessageDirections != null)
{
direction = mappingAttribute.AllowedMessageDirections[i];
}
ExecutionStepKeyValue pair = new ExecutionStepKeyValue(mappingAttribute.AllowedMessages[i].Name, direction);
string pairKey = pair.FullKey;
if (!step.AllowedMessages.ContainsKey(pair))
{
step.AllowedMessages.Add(pair, 1);
}
ExecutionStepCollection execSteps2 = null;
if (messageWiseSteps.ContainsKey(pairKey))
{
execSteps2 = messageWiseSteps[pairKey];
}
else
{
messageWiseSteps.Add(pairKey, (execSteps2 = new ExecutionStepCollection()));
}
execSteps2.Add(step);
}
if (mappingAttribute.AllowedReplyMessages != null &&
mappingAttribute.AllowedReplyMessages.Length == length)
{
for (int j = 0; j < length; j++)
{
Type type1 = mappingAttribute.AllowedMessages[j];
Type type2 = mappingAttribute.AllowedReplyMessages[j];
if (type1 != null && type2 != null)
{
factory.RequestResponseMappings.Add(type1.Name, type2.Name, new RequestResponseMapItem());
}
}
}
}
}
}
// execution step grouping
if (messageWiseSteps != null &&
groupedSteps != null)
{
execSteps.ArrangeExecutionSteps(messageWiseSteps, groupedSteps);
}
}
catch (Exception ex)
{
method.Exception(ex);
}
}
}
private void AddEventMapping(string moduleName,
RequestNotification requestNotification,
bool isPostNotification,
IExecutionStep step) {
ThrowIfEventBindingDisallowed();
// Add events to the IExecutionStep containers only if
// InitSpecial has completed and InitInternal has not completed.
if (!IsContainerInitalizationAllowed) {
return;
}
Debug.Assert(!String.IsNullOrEmpty(moduleName), "!String.IsNullOrEmpty(moduleName)");
Debug.Trace("PipelineRuntime", "AddEventMapping: for " + moduleName +
" for " + requestNotification + "\r\n" );
PipelineModuleStepContainer container = GetModuleContainer(moduleName);
//WOS 1985878: HttpModule unsubscribing an event handler causes AV in Integrated Mode
if (container != null) {
#if DBG
container.DebugModuleName = moduleName;
#endif
container.AddEvent(requestNotification, isPostNotification, step);
}
}
/*
* 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);
}
}
public ImportedExecutionStep(Fixture innerFixture, IExecutionStep inner)
{
_innerFixture = innerFixture;
_inner = inner;
}
public ImportedExecutionStep(Fixture innerFixture, IExecutionStep inner)
{
_innerFixture = innerFixture;
_inner = inner;
}
private void AddEventMapping(string moduleName, RequestNotification requestNotification, bool isPostNotification, IExecutionStep step)
{
ThrowIfEventBindingDisallowed();
//if (IsContainerInitalizationAllowed)
//{
// var moduleContainer = GetModuleContainer(moduleName);
// if (moduleContainer != null)
// moduleContainer.AddEvent(requestNotification, isPostNotification, step);
//}
}
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;
}
private void AddEventMapping(string moduleName, RequestNotification requestNotification, bool isPostNotification, IExecutionStep step)
{
this.ThrowIfEventBindingDisallowed();
if (this.IsContainerInitalizationAllowed)
{
PipelineModuleStepContainer moduleContainer = this.GetModuleContainer(moduleName);
if (moduleContainer != null)
{
moduleContainer.AddEvent(requestNotification, isPostNotification, step);
}
}
}