public void Abort()
{
using (new WorkflowTraceTransfer(this.InstanceId))
{
while (true)
{
WorkflowExecutor executor = _runtime.Load(this);
if (executor.IsInstanceValid)
{
if (executor.WorkflowStatus == WorkflowStatus.Created)
{
throw new InvalidOperationException(ExecutionStringManager.CannotAbortBeforeStart);
}
try
{
executor.Abort();
break;
}
catch (InvalidOperationException)
{
if (executor.IsInstanceValid)
{
throw;
}
}
}
}
}
}
public void EnqueueItemOnIdle(IComparable queueName, Object item, IPendingWork pendingWork, Object workItem)
{
using (new WorkflowTraceTransfer(this.InstanceId))
{
while (true)
{
WorkflowExecutor executor = _runtime.Load(this);
if (executor.IsInstanceValid)
{
try
{
executor.EnqueueItemOnIdle(queueName, item, pendingWork, workItem);
break;
}
catch (InvalidOperationException)
{
if (executor.IsInstanceValid)
{
throw;
}
}
}
}
}
}
public void ReloadTrackingProfiles()
{
using (new WorkflowTraceTransfer(this.InstanceId))
{
while (true)
{
WorkflowExecutor executor = _runtime.Load(this);
if (executor.IsInstanceValid)
{
try
{
_runtime.TrackingListenerFactory.ReloadProfiles(executor);
break;
}
catch (InvalidOperationException)
{
if (executor.IsInstanceValid)
{
throw;
}
}
}
}
}
}
public void Start()
{
using (new WorkflowTraceTransfer(this.InstanceId))
{
while (true)
{
WorkflowExecutor executor = _runtime.Load(this);
if (executor.IsInstanceValid)
{
try
{
executor.Start();
break;
}
catch (InvalidOperationException)
{
if (executor.IsInstanceValid)
{
throw;
}
}
}
}
}
}
private static void FireEvents(List <SchedulerLockGuardInfo> eventList, WorkflowExecutor workflowExec)
{
if (!workflowExec.IsInstanceValid && ((workflowExec.WorkflowStatus == WorkflowStatus.Completed) || (workflowExec.WorkflowStatus == WorkflowStatus.Terminated)))
{
workflowExec.WorkflowInstance.DeadWorkflow = workflowExec;
}
for (int i = 0; i < eventList.Count; i++)
{
SchedulerLockGuardInfo info = eventList[i];
WorkflowEventInternal eventType = info.EventType;
if (eventType != WorkflowEventInternal.Suspended)
{
if (eventType == WorkflowEventInternal.Terminated)
{
goto Label_0057;
}
goto Label_008A;
}
workflowExec.FireWorkflowSuspended((string)info.EventInfo);
continue;
Label_0057:
if (info.EventInfo is Exception)
{
workflowExec.FireWorkflowTerminated((Exception)info.EventInfo);
}
else
{
workflowExec.FireWorkflowTerminated((string)info.EventInfo);
}
continue;
Label_008A:
workflowExec.FireWorkflowExecutionEvent(info.Sender, info.EventType);
}
}
internal void DynamicUpdateCommit(object sender, WorkflowExecutor.DynamicUpdateEventArgs e)
{
if (sender == null)
{
throw new ArgumentNullException("sender");
}
if (!typeof(WorkflowExecutor).IsInstanceOfType(sender))
{
throw new ArgumentException("sender");
}
WorkflowExecutor skedExec = (WorkflowExecutor)sender;
DateTime utcNow = DateTime.UtcNow;
foreach (TrackingChannelWrapper wrapper in this._channels)
{
wrapper.GetTrackingProfile(skedExec).WorkflowChangeCommit();
}
int nextEventOrderId = this._broker.GetNextEventOrderId();
foreach (TrackingChannelWrapper wrapper2 in this._channels)
{
WorkflowTrackingRecord record = new WorkflowTrackingRecord(TrackingWorkflowEvent.Changed, utcNow, nextEventOrderId, new TrackingWorkflowChangedEventArgs(e.ChangeActions, skedExec.WorkflowDefinition));
if (wrapper2.GetTrackingProfile(skedExec).TryTrackInstanceEvent(TrackingWorkflowEvent.Changed, record))
{
wrapper2.TrackingChannel.Send(record);
}
}
}
private void LoadExistingInstance(WorkflowInstance instance, bool attaching)
{
WorkflowExecutor workflowResourceUNSAFE = instance.GetWorkflowResourceUNSAFE();
if (workflowResourceUNSAFE.IsInstanceValid)
{
IWorkflowCoreRuntime workflowCoreRuntime = workflowResourceUNSAFE;
Activity rootActivity = workflowCoreRuntime.RootActivity;
Guid scheduleTypeId = this.GetScheduleTypeId(workflowCoreRuntime);
if (attaching && workflowCoreRuntime.IsDynamicallyUpdated)
{
this.LoadExistingScheduleType(scheduleTypeId, rootActivity.GetType(), true, rootActivity);
}
this.instanceTable.AddInstance(instance.InstanceId, rootActivity);
this.controllerConduit.InstanceCreated(this.programId, instance.InstanceId, scheduleTypeId);
lock (this.eventLock)
{
workflowResourceUNSAFE.WorkflowExecutionEvent += new EventHandler <WorkflowExecutor.WorkflowExecutionEventArgs>(this.OnInstanceEvent);
foreach (Activity activity2 in WalkActivityTree(rootActivity))
{
this.UpdateActivityStatus(scheduleTypeId, instance.InstanceId, activity2);
}
ActivityExecutionContext rootContext = new ActivityExecutionContext(rootActivity);
foreach (ActivityExecutionContext context2 in WalkExecutionContextTree(rootContext))
{
foreach (Activity activity4 in WalkActivityTree(context2.Activity))
{
this.UpdateActivityStatus(scheduleTypeId, instance.InstanceId, activity4);
}
}
}
}
}
public ReadOnlyCollection <WorkflowQueueInfo> GetWorkflowQueueData()
{
if (_deadWorkflow != null)
{
return(_deadWorkflow.GetWorkflowQueueInfos());
}
while (true)
{
WorkflowExecutor executor = _runtime.Load(this);
if (executor.IsInstanceValid)
{
try
{
return(executor.GetWorkflowQueueInfos());
}
catch (InvalidOperationException)
{
if (executor.IsInstanceValid)
{
throw;
}
}
}
}
}
public bool TryUnload()
{
using (new WorkflowTraceTransfer(this.InstanceId))
{
WorkflowExecutor executor = this._runtime.Load(this);
using (executor.ExecutorLock.Enter())
{
if (executor.IsInstanceValid)
{
try
{
return(executor.TryUnload());
}
catch (InvalidOperationException)
{
if (executor.IsInstanceValid)
{
throw;
}
}
}
}
return(false);
}
}
internal void ReloadProfiles(WorkflowExecutor exec)
{
using (new ServiceEnvironment(exec.RootActivity))
{
using (exec.ExecutorLock.Enter())
{
if (!exec.IsInstanceValid)
{
throw new InvalidOperationException(ExecutionStringManager.WorkflowNotValid);
}
bool flag = exec.Suspend(ExecutionStringManager.TrackingProfileUpdate);
try
{
this.GetListenerFromWRCache(exec.InstanceId).ReloadProfiles(exec, exec.InstanceId);
}
finally
{
if (flag)
{
exec.Resume();
}
}
}
}
}
public void Run()
{
this.pause = false;
while (!this.pause)
{
SchedulableItem item;
// atomicActivityQueue has higher priority
if (this.atomicActivityQueue.Count > 0)
{
item = this.atomicActivityQueue.Dequeue();
}
// The execution of the items in the scheduler queue is deferred until the atomic activity completes.
else if (owner.CurrentAtomicActivity == null &&
this.schedulerQueue.Count > 0)
{
item = schedulerQueue.Dequeue();
}
else
{
break;
}
Activity itemActivity = owner.GetContextActivityForId(item.ContextId).GetActivityByName(item.ActivityId);
Activity atomicActivity;
TransactionalProperties transactionalProperties = null;
if (owner.IsActivityInAtomicContext(itemActivity, out atomicActivity))
{
transactionalProperties = (TransactionalProperties)atomicActivity.GetValue(WorkflowExecutor.TransactionalPropertiesProperty);
// If we've aborted for any reason stop now!
if (owner.CheckAndProcessTransactionAborted(transactionalProperties))
{
return;
}
}
try
{
item.Run(owner);
}
catch (Exception e)
{
if (WorkflowExecutor.IsIrrecoverableException(e))
{
throw;
}
if (transactionalProperties != null)
{
transactionalProperties.TransactionState = TransactionProcessState.AbortProcessed;
owner.lastExceptionThrown = e;
}
owner.RaiseException(e, itemActivity, null);
}
}
}
internal void ProcessTimers()
{
using (new WorkflowTraceTransfer(this.InstanceId))
{
while (true)
{
WorkflowExecutor executor = null;
try
{
executor = _runtime.Load(this);
}
catch (InvalidOperationException)
{
break;
}
if (executor != null && executor.IsInstanceValid)
{
try
{
executor.DeliverTimerSubscriptions();
break;
}
catch (InvalidOperationException)
{
if (executor.IsInstanceValid)
{
throw;
}
}
}
}
}
}
private void MakeProfilesPrivate(WorkflowExecutor exec)
{
foreach (TrackingChannelWrapper wrapper in this._channels)
{
wrapper.MakeProfilePrivate(exec);
this._broker.MakeProfilePrivate(wrapper.TrackingServiceType);
}
}
internal RTTrackingProfile GetTrackingProfile(WorkflowExecutor skedExec)
{
if (this._profile == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, ExecutionStringManager.NullProfileForChannel, new object[] { this._scheduleType.AssemblyQualifiedName }));
}
return(this._profile);
}
internal TrackingListener GetTrackingListener(Activity sked, WorkflowExecutor skedExec)
{
if (!this._initialized)
{
this.Initialize(skedExec.WorkflowRuntime);
}
return(this.GetListener(sked, skedExec, null));
}
internal CreationContext(Type type, WorkflowExecutor invokerExec, string invokeActivityID, Dictionary <string, object> args)
{
Type = type;
InvokerExecutor = invokerExec;
InvokeActivityID = invokeActivityID;
Args = args;
IsActivation = true;
}
internal CreationContext(System.Type type, WorkflowExecutor invokerExec, string invokeActivityID, Dictionary <string, object> args)
{
this.Type = type;
this.InvokerExecutor = invokerExec;
this.InvokeActivityID = invokeActivityID;
this.Args = args;
this.IsActivation = true;
}
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 CreationContext(XmlReader xomlReader, XmlReader rulesReader, Dictionary <string, object> args)
{
this.XomlReader = xomlReader;
this.RulesReader = rulesReader;
this.InvokerExecutor = null;
this.InvokeActivityID = null;
this.Args = args;
this.IsActivation = true;
}
private void Notify(PerformanceCounterAction action, WorkflowExecutor executor)
{
List <PerformanceCounterStatement> list;
if (this.m_actionStatements.TryGetValue(action, out list))
{
foreach (PerformanceCounterStatement statement in list)
{
this.NotifyCounter(action, statement, executor);
}
}
}
private void GetContext(Activity activity, WorkflowExecutor exec, out Guid contextGuid, out Guid parentContextGuid)
{
contextGuid = this._factory.GetContext(activity);
if (activity.Parent != null)
{
parentContextGuid = this._factory.GetContext(activity.Parent);
}
else
{
parentContextGuid = contextGuid;
}
}
private void Detach()
{
using (new DebuggerThreadMarker())
{
lock (this.syncRoot)
{
AppDomain.CurrentDomain.AssemblyLoad -= new AssemblyLoadEventHandler(this.OnAssemblyLoad);
if (!this.isZombie && this.isAttached)
{
this.isAttached = false;
this.programId = Guid.Empty;
if (this.debugControllerThread != null)
{
this.debugControllerThread.StopThread();
this.debugControllerThread = null;
}
if (this.attachTimer != null)
{
this.attachTimer.Change(-1, -1);
this.attachTimer = null;
}
RemotingServices.Disconnect(this);
if (this.channel != null)
{
ChannelServices.UnregisterChannel(this.channel);
this.channel = null;
}
this.controllerConduit = null;
this.eventConduitAttached.Reset();
this.instanceTable = null;
this.typeToGuid = null;
this.xomlHashToGuid = null;
if (!this.serviceContainer.IsZombie)
{
foreach (WorkflowInstance instance in this.serviceContainer.GetLoadedWorkflows())
{
WorkflowExecutor workflowResourceUNSAFE = instance.GetWorkflowResourceUNSAFE();
using (workflowResourceUNSAFE.ExecutorLock.Enter())
{
if (workflowResourceUNSAFE.IsInstanceValid)
{
workflowResourceUNSAFE.WorkflowExecutionEvent -= new EventHandler <WorkflowExecutor.WorkflowExecutionEventArgs>(this.OnInstanceEvent);
}
}
}
this.serviceContainer.WorkflowExecutorInitializing -= new EventHandler <WorkflowRuntime.WorkflowExecutorInitializingEventArgs>(this.InstanceInitializing);
this.serviceContainer.DefinitionDispenser.WorkflowDefinitionLoaded -= new EventHandler <WorkflowDefinitionEventArgs>(this.ScheduleTypeLoaded);
}
}
}
}
}
private bool SubscriptionRequired(Activity activity, WorkflowExecutor exec)
{
bool flag = false;
foreach (TrackingChannelWrapper wrapper in this._channels)
{
if (wrapper.GetTrackingProfile(exec).ActivitySubscriptionNeeded(activity) && !flag)
{
flag = true;
}
}
return(flag);
}
internal TrackingListener GetTrackingListener(Activity sked, WorkflowExecutor skedExec, TrackingListenerBroker broker)
{
if (!this._initialized)
{
this.Initialize(skedExec.WorkflowRuntime);
}
if (broker == null)
{
WorkflowTrace.Tracking.TraceEvent(TraceEventType.Error, 0, ExecutionStringManager.NullTrackingBroker);
return(null);
}
return(this.GetListener(sked, skedExec, broker));
}
public void Run()
{
this.pause = false;
while (!this.pause)
{
SchedulableItem item;
System.Workflow.ComponentModel.Activity activity2;
if (this.atomicActivityQueue.Count > 0)
{
item = this.atomicActivityQueue.Dequeue();
}
else
{
if ((this.owner.CurrentAtomicActivity != null) || (this.schedulerQueue.Count <= 0))
{
break;
}
item = this.schedulerQueue.Dequeue();
}
System.Workflow.ComponentModel.Activity activityByName = this.owner.GetContextActivityForId(item.ContextId).GetActivityByName(item.ActivityId);
TransactionalProperties transactionalProperties = null;
if (this.owner.IsActivityInAtomicContext(activityByName, out activity2))
{
transactionalProperties = (TransactionalProperties)activity2.GetValue(WorkflowExecutor.TransactionalPropertiesProperty);
if (this.owner.CheckAndProcessTransactionAborted(transactionalProperties))
{
return;
}
}
try
{
item.Run(this.owner);
continue;
}
catch (Exception exception)
{
if (WorkflowExecutor.IsIrrecoverableException(exception))
{
throw;
}
if (transactionalProperties != null)
{
transactionalProperties.TransactionState = TransactionProcessState.AbortProcessed;
this.owner.lastExceptionThrown = exception;
}
this.owner.RaiseException(exception, activityByName, null);
continue;
}
}
}
internal void RevertToCheckpointState()
{
Activity rootActivity = null;
this.clonedInstanceStateStream.Position = 0L;
using (new RuntimeEnvironment(this.workflowExecutor.WorkflowRuntime))
{
rootActivity = Activity.Load(this.clonedInstanceStateStream, this.workflowDefinition);
}
rootActivity.SetValue(WorkflowExecutor.TrackingListenerBrokerProperty, this.workflowExecutor.RootActivity.GetValue(WorkflowExecutor.TrackingListenerBrokerProperty));
WorkflowExecutor newWorkflowExecutor = new WorkflowExecutor(Guid.Empty);
newWorkflowExecutor.Initialize(rootActivity, this.workflowExecutor.WorkflowRuntime, this.workflowExecutor);
Activity contextActivityForId = newWorkflowExecutor.GetContextActivityForId(this.activityContextId);
Activity activityByName = contextActivityForId.GetActivityByName(this.activityQualifiedName);
using (new ServiceEnvironment(activityByName))
{
using (newWorkflowExecutor.SetCurrentActivity(activityByName))
{
using (ActivityExecutionContext context = new ActivityExecutionContext(activityByName))
{
context.Invoke <EventArgs>(this.callbackHandler, this.callbackData);
}
}
}
newWorkflowExecutor.BatchCollection.WorkItemOrderId = this.workflowExecutor.BatchCollection.WorkItemOrderId;
foreach (KeyValuePair <object, WorkBatch> pair in this.workflowExecutor.BatchCollection)
{
pair.Value.SetWorkBatchCollection(newWorkflowExecutor.BatchCollection);
Activity key = pair.Key as Activity;
if (key != null)
{
Activity activity5 = contextActivityForId.GetActivityByName(key.QualifiedName);
newWorkflowExecutor.BatchCollection.Add(activity5, pair.Value);
}
}
this.workflowExecutor.BatchCollection.Clear();
newWorkflowExecutor.CompletedContextActivities = this.completedContextActivities;
this.workflowExecutor.WorkflowRuntime.ReplaceWorkflowExecutor(this.workflowExecutor.InstanceId, this.workflowExecutor, newWorkflowExecutor);
if (!this.suspendOnRevert)
{
newWorkflowExecutor.Scheduler.Resume();
}
else
{
newWorkflowExecutor.SuspendOnIdle(this.suspendOnRevertInfo);
}
this.DisposeCheckpointState();
}
internal TrackingListener(TrackingListenerFactory factory, Activity sked, WorkflowExecutor exec, List <TrackingChannelWrapper> channels, TrackingListenerBroker broker, bool load)
{
if ((sked == null) || (broker == null))
{
WorkflowTrace.Tracking.TraceEvent(TraceEventType.Error, 0, ExecutionStringManager.NullParameters);
}
else
{
this._factory = factory;
this._channels = channels;
this._broker = broker;
this._broker.TrackingListener = this;
}
}
private void Notify(PerformanceCounterAction action, WorkflowExecutor executor)
{
System.Diagnostics.Debug.Assert(this.m_actionStatements != null);
List <PerformanceCounterStatement> lStatements;
if (this.m_actionStatements.TryGetValue(action, out lStatements))
{
foreach (PerformanceCounterStatement statement in lStatements)
{
NotifyCounter(action, statement, executor);
}
}
}
public void Invoke(WorkflowSchedulerService service)
{
try
{
WorkflowTrace.Host.TraceEvent(TraceEventType.Information, 0, "Running workflow {0}", new object[] { this.state });
this.Callback(this.state);
}
catch (Exception exception)
{
if (WorkflowExecutor.IsIrrecoverableException(exception))
{
throw;
}
service.RaiseExceptionNotHandledEvent(exception, (Guid)this.state);
}
}
internal void MakeProfilePrivate(WorkflowExecutor exec)
{
if (this._profile != null)
{
if (!this._profile.IsPrivate)
{
this._profile = this._profile.Clone();
this._profile.IsPrivate = true;
}
}
else
{
this._profile = this.GetTrackingProfile(exec).Clone();
this._profile.IsPrivate = true;
}
}
