internal InstanceLockGuard(InstanceLock theLock)
{
this.m_lock = theLock;
EnforceGuard(theLock);
try
{
}
finally
{
bool flag = false;
Monitor.Enter(this.m_lock);
try
{
InstanceLock.HeldLocks.Add(this.m_lock);
flag = true;
}
finally
{
if (!flag)
{
Monitor.Exit(this.m_lock);
}
}
}
}
internal static void Exit(InstanceLock il, WorkflowExecutor w)
{
List<SchedulerLockGuardInfo> eventList = new List<SchedulerLockGuardInfo>(w.EventsToFireList);
w.EventsToFireList.Clear();
il.Exit();
FireEvents(eventList, w);
}
internal static void EnforceGuard(InstanceLock theLock)
{
foreach (InstanceLock heldLock in HeldLocks)
{
switch (theLock.Operator)
{
case LockPriorityOperator.GreaterThan:
if (heldLock.InstanceId == theLock.InstanceId && heldLock.Priority <= theLock.Priority)
{
throw new InvalidOperationException(ExecutionStringManager.InstanceOperationNotValidinWorkflowThread);
}
break;
case LockPriorityOperator.GreaterThanOrReentrant:
// the checks here assume that locks have unique priorities
if (heldLock.InstanceId == theLock.InstanceId && heldLock.Priority < theLock.Priority)
{
throw new InvalidOperationException(ExecutionStringManager.InstanceOperationNotValidinWorkflowThread);
}
break;
default:
System.Diagnostics.Debug.Assert(false, "Unrecognized lock operator");
break;
}
}
}
internal InstanceLockGuard(InstanceLock theLock)
{
this.m_lock = theLock;
// Note: the following operations are logically atomic, but since the
// list we are using is thread local there is no need to take a lock.
EnforceGuard(theLock);
try
{
}
finally
{
bool success = false;
#pragma warning disable 0618
//@
Monitor.Enter(this.m_lock);
#pragma warning restore 0618
try
{
HeldLocks.Add(this.m_lock);
success = true;
}
finally
{
if (!success)
{
Monitor.Exit(this.m_lock);
}
}
}
}
internal static void Exit(InstanceLock il, WorkflowExecutor w)
{
List <SchedulerLockGuardInfo> eventList = new List <SchedulerLockGuardInfo>(w.EventsToFireList);
w.EventsToFireList.Clear();
il.Exit();
FireEvents(eventList, w);
}
internal static void EnforceGuard(InstanceLock theLock)
{
foreach (InstanceLock @lock in InstanceLock.HeldLocks)
{
switch (theLock.Operator)
{
case LockPriorityOperator.GreaterThan:
if ((@lock.InstanceId == theLock.InstanceId) && (@lock.Priority <= theLock.Priority))
{
throw new InvalidOperationException(ExecutionStringManager.InstanceOperationNotValidinWorkflowThread);
}
break;
case LockPriorityOperator.GreaterThanOrReentrant:
if ((@lock.InstanceId == theLock.InstanceId) && (@lock.Priority < theLock.Priority))
{
throw new InvalidOperationException(ExecutionStringManager.InstanceOperationNotValidinWorkflowThread);
}
break;
}
}
}
internal SchedulerLockGuard(InstanceLock il, WorkflowExecutor w)
{
lg = il.Enter();
workflowExec = w;
}
// Used to recreate the root schedule executor from its persisted state
private void ReloadHelper(Activity rootActivity)
{
// assign activity state
this.rootActivity = rootActivity;
this.InstanceId = (Guid)rootActivity.GetValue(WorkflowInstanceIdProperty);
// set workflow executor
this.rootActivity.SetValue(WorkflowExecutor.WorkflowExecutorProperty, this);
this._schedulerLock = LockFactory.CreateWorkflowSchedulerLock(this.InstanceId);
this.schedulingContext = new Scheduler(this, false);
this.qService = new WorkflowQueuingService(this);
WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "Workflow Runtime: WorkflowExecutor: Loading instance {0}", this.InstanceIdString);
DiagnosticStackTrace("load request");
using (new ServiceEnvironment(this.rootActivity))
{
// check if this instance can be loaded
switch (this.WorkflowStatus)
{
case WorkflowStatus.Completed:
case WorkflowStatus.Terminated:
WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 0, "Workflow Runtime: WorkflowExecutor: attempt to load a completed/terminated instance: {0}", this.InstanceIdString);
throw new InvalidOperationException(
ExecutionStringManager.InvalidAttemptToLoad);
default:
break;
}
// new nonSerialized members
_resourceManager = new VolatileResourceManager();
_runtime = _workflowInstance.WorkflowRuntime;
// register all dynamic activities for loading
Queue<Activity> dynamicActivitiesQueue = new Queue<Activity>();
dynamicActivitiesQueue.Enqueue(this.rootActivity);
while (dynamicActivitiesQueue.Count > 0)
{
Activity dynamicActivity = dynamicActivitiesQueue.Dequeue();
((IDependencyObjectAccessor)dynamicActivity).InitializeInstanceForRuntime(this);
this.RegisterDynamicActivity(dynamicActivity, true);
IList<Activity> nestedDynamicActivities = (IList<Activity>)dynamicActivity.GetValue(Activity.ActiveExecutionContextsProperty);
if (nestedDynamicActivities != null)
{
foreach (Activity nestedDynamicActivity in nestedDynamicActivities)
dynamicActivitiesQueue.Enqueue(nestedDynamicActivity);
}
}
}
this.isInstanceIdle = (bool)this.rootActivity.GetValue(IsIdleProperty);
RefreshWorkflowDefinition();
}
// Used when replacing a workflow executor. Basically we move
// the locks from the previous executor so we guarantee that
// everything stays locks as it is supposed to be.
internal void Initialize(Activity rootActivity, WorkflowRuntime runtime, WorkflowExecutor previousWorkflowExecutor)
{
_workflowInstance = previousWorkflowExecutor.WorkflowInstance;
ReloadHelper(rootActivity);
// mark instance as valid now
IsInstanceValid = true;
_runtime = runtime;
this._runtime.WorkflowExecutorCreated(this, true);
TimerQueue.Executor = this;
TimerQueue.ResumeDelivery();
_executorLock = previousWorkflowExecutor._executorLock;
_msgDeliveryLock = previousWorkflowExecutor._msgDeliveryLock;
_schedulerLock = previousWorkflowExecutor._schedulerLock;
ScheduleWork.Executor = this;
}
internal static void EnforceGuard(InstanceLock theLock)
{
foreach (InstanceLock @lock in InstanceLock.HeldLocks)
{
switch (theLock.Operator)
{
case LockPriorityOperator.GreaterThan:
if ((@lock.InstanceId == theLock.InstanceId) && (@lock.Priority <= theLock.Priority))
{
throw new InvalidOperationException(ExecutionStringManager.InstanceOperationNotValidinWorkflowThread);
}
break;
case LockPriorityOperator.GreaterThanOrReentrant:
if ((@lock.InstanceId == theLock.InstanceId) && (@lock.Priority < theLock.Priority))
{
throw new InvalidOperationException(ExecutionStringManager.InstanceOperationNotValidinWorkflowThread);
}
break;
}
}
}
internal SchedulerLockGuard(InstanceLock il, WorkflowExecutor w)
{
lg = il.Enter();
workflowExec = w;
}
internal static void EnforceGuard(InstanceLock theLock)
{
foreach (InstanceLock heldLock in HeldLocks)
{
switch (theLock.Operator)
{
case LockPriorityOperator.GreaterThan:
if (heldLock.InstanceId == theLock.InstanceId && heldLock.Priority <= theLock.Priority)
throw new InvalidOperationException(ExecutionStringManager.InstanceOperationNotValidinWorkflowThread);
break;
case LockPriorityOperator.GreaterThanOrReentrant:
// the checks here assume that locks have unique priorities
if (heldLock.InstanceId == theLock.InstanceId && heldLock.Priority < theLock.Priority)
throw new InvalidOperationException(ExecutionStringManager.InstanceOperationNotValidinWorkflowThread);
break;
default:
System.Diagnostics.Debug.Assert(false, "Unrecognized lock operator");
break;
}
}
}
private void ReloadHelper(Activity rootActivity)
{
this.rootActivity = rootActivity;
this.InstanceId = (Guid) rootActivity.GetValue(WorkflowInstanceIdProperty);
this.rootActivity.SetValue(WorkflowExecutorProperty, this);
this._schedulerLock = LockFactory.CreateWorkflowSchedulerLock(this.InstanceId);
this.schedulingContext = new System.Workflow.Runtime.Scheduler(this, false);
this.qService = new WorkflowQueuingService(this);
WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "Workflow Runtime: WorkflowExecutor: Loading instance {0}", new object[] { this.InstanceIdString });
using (new ServiceEnvironment(this.rootActivity))
{
switch (this.WorkflowStatus)
{
case System.Workflow.Runtime.WorkflowStatus.Completed:
case System.Workflow.Runtime.WorkflowStatus.Terminated:
WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 0, "Workflow Runtime: WorkflowExecutor: attempt to load a completed/terminated instance: {0}", new object[] { this.InstanceIdString });
throw new InvalidOperationException(ExecutionStringManager.InvalidAttemptToLoad);
}
this._resourceManager = new VolatileResourceManager();
this._runtime = this._workflowInstance.WorkflowRuntime;
Queue<Activity> queue = new Queue<Activity>();
queue.Enqueue(this.rootActivity);
while (queue.Count > 0)
{
Activity dynamicActivity = queue.Dequeue();
((IDependencyObjectAccessor) dynamicActivity).InitializeInstanceForRuntime(this);
this.RegisterDynamicActivity(dynamicActivity, true);
IList<Activity> list = (IList<Activity>) dynamicActivity.GetValue(Activity.ActiveExecutionContextsProperty);
if (list != null)
{
foreach (Activity activity2 in list)
{
queue.Enqueue(activity2);
}
}
}
}
this.isInstanceIdle = (bool) this.rootActivity.GetValue(IsIdleProperty);
this.RefreshWorkflowDefinition();
}
internal void Initialize(Activity rootActivity, WorkflowExecutor invokerExec, string invokeActivityID, Guid instanceId, IDictionary<string, object> namedArguments, System.Workflow.Runtime.WorkflowInstance workflowInstance)
{
this.rootActivity = rootActivity;
this.InstanceId = instanceId;
this.rootActivity.SetValue(ContextIdProperty, 0);
this.rootActivity.SetValue(WorkflowInstanceIdProperty, instanceId);
this.WorkflowStatus = System.Workflow.Runtime.WorkflowStatus.Created;
this.rootActivity.SetValue(Activity.ActivityExecutionContextInfoProperty, new ActivityExecutionContextInfo(this.rootActivity.QualifiedName, this.GetNewContextId(), instanceId, -1));
this.rootActivity.SetValue(Activity.ActivityContextGuidProperty, instanceId);
this.rootActivity.SetValue(IsIdleProperty, true);
this.isInstanceIdle = true;
this.rootActivity.SetValue(WorkflowExecutorProperty, this);
this.RefreshWorkflowDefinition();
Activity workflowDefinition = this.WorkflowDefinition;
if (workflowDefinition == null)
{
throw new InvalidOperationException("workflowDefinition");
}
((IDependencyObjectAccessor) this.rootActivity).InitializeActivatingInstanceForRuntime(null, this);
this.rootActivity.FixUpMetaProperties(workflowDefinition);
this._runtime = workflowInstance.WorkflowRuntime;
if (invokerExec != null)
{
List<string> list = new List<string>();
System.Workflow.Runtime.TrackingCallingState state = (System.Workflow.Runtime.TrackingCallingState) invokerExec.rootActivity.GetValue(TrackingCallingStateProperty);
if ((state != null) && (state.CallerActivityPathProxy != null))
{
foreach (string str in state.CallerActivityPathProxy)
{
list.Add(str);
}
}
list.Add(invokeActivityID);
System.Workflow.Runtime.TrackingCallingState state2 = new System.Workflow.Runtime.TrackingCallingState {
CallerActivityPathProxy = list,
CallerWorkflowInstanceId = invokerExec.InstanceId,
CallerContextGuid = ((ActivityExecutionContextInfo) ContextActivityUtils.ContextActivity(invokerExec.CurrentActivity).GetValue(Activity.ActivityExecutionContextInfoProperty)).ContextGuid
};
if (invokerExec.CurrentActivity.Parent == null)
{
state2.CallerParentContextGuid = state2.CallerContextGuid;
}
else
{
state2.CallerParentContextGuid = ((ActivityExecutionContextInfo) ContextActivityUtils.ContextActivity(invokerExec.CurrentActivity.Parent).GetValue(Activity.ActivityExecutionContextInfoProperty)).ContextGuid;
}
this.rootActivity.SetValue(TrackingCallingStateProperty, state2);
}
this._setInArgsOnCompanion(namedArguments);
this.schedulingContext = new System.Workflow.Runtime.Scheduler(this, true);
this._schedulerLock = LockFactory.CreateWorkflowSchedulerLock(this.InstanceId);
this.qService = new WorkflowQueuingService(this);
this._workflowInstance = workflowInstance;
this.TimerQueue = new TimerEventSubscriptionCollection(this, this.InstanceId);
using (new ServiceEnvironment(this.rootActivity))
{
using (this.SetCurrentActivity(this.rootActivity))
{
this.RegisterDynamicActivity(this.rootActivity, false);
}
}
}
internal WorkflowExecutor(Guid instanceId)
{
this._executorLock = LockFactory.CreateWorkflowExecutorLock(instanceId);
this._msgDeliveryLock = LockFactory.CreateWorkflowMessageDeliveryLock(instanceId);
this.stateChangedSincePersistence = true;
if (!workflowDebuggingDisabled)
{
this._workflowDebuggerService = new WorkflowDebuggerService(this);
}
}
internal void Initialize(Activity rootActivity, System.Workflow.Runtime.WorkflowRuntime runtime, WorkflowExecutor previousWorkflowExecutor)
{
this._workflowInstance = previousWorkflowExecutor.WorkflowInstance;
this.ReloadHelper(rootActivity);
this.IsInstanceValid = true;
this._runtime = runtime;
this._runtime.WorkflowExecutorCreated(this, true);
this.TimerQueue.Executor = this;
this.TimerQueue.ResumeDelivery();
this._executorLock = previousWorkflowExecutor._executorLock;
this._msgDeliveryLock = previousWorkflowExecutor._msgDeliveryLock;
this._schedulerLock = previousWorkflowExecutor._schedulerLock;
ScheduleWork.Executor = this;
}
internal static void AssertIsLocked(InstanceLock theLock)
{
}
internal InstanceLockGuard(InstanceLock theLock)
{
this.m_lock = theLock;
EnforceGuard(theLock);
try
{
}
finally
{
bool flag = false;
Monitor.Enter(this.m_lock);
try
{
InstanceLock.HeldLocks.Add(this.m_lock);
flag = true;
}
finally
{
if (!flag)
{
Monitor.Exit(this.m_lock);
}
}
}
}
internal static void AssertIsLocked(InstanceLock theLock)
{
#if DEBUG
System.Diagnostics.Debug.Assert(HeldLocks.Contains(theLock), "Lock should be held.");
#endif
}
internal static void AssertIsLocked(InstanceLock theLock)
{
}
internal InstanceLockGuard(InstanceLock theLock)
{
this.m_lock = theLock;
// Note: the following operations are logically atomic, but since the
// list we are using is thread local there is no need to take a lock.
EnforceGuard(theLock);
try
{
}
finally
{
bool success = false;
#pragma warning disable 0618
//@
Monitor.Enter(this.m_lock);
#pragma warning restore 0618
try
{
HeldLocks.Add(this.m_lock);
success = true;
}
finally
{
if (!success)
{
Monitor.Exit(this.m_lock);
}
}
}
}
internal WorkflowExecutor(Guid instanceId)
{
this._isInstanceValid = false;
this._executorLock = LockFactory.CreateWorkflowExecutorLock(instanceId);
this._msgDeliveryLock = LockFactory.CreateWorkflowMessageDeliveryLock(instanceId);
this.stateChangedSincePersistence = true;
// If DisableWorkflowDebugging switch is turned off create WorkflowDebuggerService
if (!workflowDebuggingDisabled)
this._workflowDebuggerService = new WorkflowDebuggerService(this);
}
internal static void AssertIsLocked(InstanceLock theLock)
{
#if DEBUG
System.Diagnostics.Debug.Assert(HeldLocks.Contains(theLock), "Lock should be held.");
#endif
}
// Initialize for the root schedule
internal void Initialize(Activity rootActivity, WorkflowExecutor invokerExec, string invokeActivityID, Guid instanceId, IDictionary<string, object> namedArguments, WorkflowInstance workflowInstance)
{
this.rootActivity = rootActivity;
this.InstanceId = instanceId;
// Set the persisted State properties
this.rootActivity.SetValue(WorkflowExecutor.ContextIdProperty, 0);
this.rootActivity.SetValue(WorkflowInstanceIdProperty, instanceId);
this.WorkflowStatus = WorkflowStatus.Created;
this.rootActivity.SetValue(Activity.ActivityExecutionContextInfoProperty, new ActivityExecutionContextInfo(this.rootActivity.QualifiedName, GetNewContextId(), instanceId, -1));
this.rootActivity.SetValue(Activity.ActivityContextGuidProperty, instanceId);
this.rootActivity.SetValue(WorkflowExecutor.IsIdleProperty, true);
this.isInstanceIdle = true;
// set workflow executor
this.rootActivity.SetValue(WorkflowExecutor.WorkflowExecutorProperty, this);
// initialize the root activity
RefreshWorkflowDefinition();
Activity workflowDefinition = this.WorkflowDefinition;
if (workflowDefinition == null)
throw new InvalidOperationException("workflowDefinition");
((IDependencyObjectAccessor)this.rootActivity).InitializeActivatingInstanceForRuntime(null, this);
this.rootActivity.FixUpMetaProperties(workflowDefinition);
_runtime = workflowInstance.WorkflowRuntime;
if (invokerExec != null)
{
List<string> calleeBase = new List<string>();
TrackingCallingState parentTCS = (TrackingCallingState)invokerExec.rootActivity.GetValue(WorkflowExecutor.TrackingCallingStateProperty);
if ((parentTCS != null) && (parentTCS.CallerActivityPathProxy != null))
{
foreach (string qualifiedID in parentTCS.CallerActivityPathProxy)
calleeBase.Add(qualifiedID);
}
calleeBase.Add(invokeActivityID);
//
// This has been exec'd by another instance
// Set up tracking info to allow linking instances
Debug.Assert(invokeActivityID != null && invokeActivityID.Length > 0);
TrackingCallingState trackingCallingState = new TrackingCallingState();
trackingCallingState.CallerActivityPathProxy = calleeBase;
trackingCallingState.CallerWorkflowInstanceId = invokerExec.InstanceId;
trackingCallingState.CallerContextGuid = ((ActivityExecutionContextInfo)ContextActivityUtils.ContextActivity(invokerExec.CurrentActivity).GetValue(Activity.ActivityExecutionContextInfoProperty)).ContextGuid;
if (null == invokerExec.CurrentActivity.Parent)
trackingCallingState.CallerParentContextGuid = trackingCallingState.CallerContextGuid;
else
trackingCallingState.CallerParentContextGuid = ((ActivityExecutionContextInfo)ContextActivityUtils.ContextActivity(invokerExec.CurrentActivity.Parent).GetValue(Activity.ActivityExecutionContextInfoProperty)).ContextGuid;
this.rootActivity.SetValue(WorkflowExecutor.TrackingCallingStateProperty, trackingCallingState);
}
_setInArgsOnCompanion(namedArguments);
this.schedulingContext = new Scheduler(this, true);
this._schedulerLock = LockFactory.CreateWorkflowSchedulerLock(this.InstanceId);
qService = new WorkflowQueuingService(this);
_workflowInstance = workflowInstance;
TimerQueue = new TimerEventSubscriptionCollection(this, this.InstanceId);
// register the dynamic activity
using (new ServiceEnvironment(this.rootActivity))
{
using (SetCurrentActivity(this.rootActivity))
{
this.RegisterDynamicActivity(this.rootActivity, false);
}
}
}
