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 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(Type type, WorkflowExecutor invokerExec, string invokeActivityID, Dictionary<string, object> args) { Type = type; InvokerExecutor = invokerExec; InvokeActivityID = invokeActivityID; Args = args; IsActivation = true; }
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 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 CreationContext(XmlReader xomlReader, XmlReader rulesReader, Dictionary<string, object> args) { XomlReader = xomlReader; RulesReader = rulesReader; InvokerExecutor = null; InvokeActivityID = null; Args = args; 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); } } }
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; } }
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; } }
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(); }
public Scheduler(WorkflowExecutor rootExec, bool canRun) { this.rootWorkflowExecutor = rootExec; this.threadRequested = false; this.canRun = canRun; this.highPriorityEntriesQueue = (Queue<SchedulableItem>) rootExec.RootActivity.GetValue(HighPriorityEntriesQueueProperty); this.normalPriorityEntriesQueue = (Queue<SchedulableItem>) rootExec.RootActivity.GetValue(NormalPriorityEntriesQueueProperty); if (this.highPriorityEntriesQueue == null) { this.highPriorityEntriesQueue = new Queue<SchedulableItem>(); rootExec.RootActivity.SetValue(HighPriorityEntriesQueueProperty, this.highPriorityEntriesQueue); } if (this.normalPriorityEntriesQueue == null) { this.normalPriorityEntriesQueue = new Queue<SchedulableItem>(); rootExec.RootActivity.SetValue(NormalPriorityEntriesQueueProperty, this.normalPriorityEntriesQueue); } this.empty = (this.normalPriorityEntriesQueue.Count == 0) && (this.highPriorityEntriesQueue.Count == 0); }
internal void DynamicUpdateBegin(object sender, WorkflowExecutor.DynamicUpdateEventArgs e) { if (sender == null) { throw new ArgumentNullException("sender"); } if (!typeof(WorkflowExecutor).IsInstanceOfType(sender)) { throw new ArgumentException("sender"); } WorkflowExecutor exec = (WorkflowExecutor) sender; if (e.ChangeActions != null) { this.MakeProfilesPrivate(exec); foreach (TrackingChannelWrapper wrapper in this._channels) { wrapper.GetTrackingProfile(exec).WorkflowChangeBegin(e.ChangeActions); } } }
internal void ActivityStatusChange(object sender, WorkflowExecutor.ActivityStatusChangeEventArgs e) { WorkflowTrace.Tracking.TraceInformation("TrackingListener::ActivityStatusChange - Received Activity Status Change Event for activity {0}", new object[] { e.Activity.QualifiedName }); if (sender == null) { throw new ArgumentNullException("sender"); } if (!typeof(WorkflowExecutor).IsInstanceOfType(sender)) { throw new ArgumentException("sender"); } if (e == null) { throw new ArgumentNullException("e"); } WorkflowExecutor exec = (WorkflowExecutor) sender; if ((this._channels == null) || (this._channels.Count <= 0)) { WorkflowTrace.Tracking.TraceEvent(TraceEventType.Error, 0, ExecutionStringManager.NoChannels); } else { Activity activity = e.Activity; if (this.SubscriptionRequired(activity, exec)) { Guid empty = Guid.Empty; Guid contextGuid = Guid.Empty; this.GetContext(activity, exec, out contextGuid, out empty); DateTime utcNow = DateTime.UtcNow; int nextEventOrderId = this._broker.GetNextEventOrderId(); foreach (TrackingChannelWrapper wrapper in this._channels) { ActivityTrackingRecord record = new ActivityTrackingRecord(activity.GetType(), activity.QualifiedName, contextGuid, empty, activity.ExecutionStatus, utcNow, nextEventOrderId, null); if (wrapper.GetTrackingProfile(exec).TryTrackActivityEvent(activity, activity.ExecutionStatus, exec, record)) { wrapper.TrackingChannel.Send(record); } } } } }
// loading with some state public Scheduler(WorkflowExecutor rootExec, bool canRun) { this.rootWorkflowExecutor = rootExec; this.threadRequested = false; // canRun is true if normal creation // false if loading from a persisted state. Will be set to true later at ResumeOnIdle this.canRun = canRun; this.highPriorityEntriesQueue = (Queue<SchedulableItem>)rootExec.RootActivity.GetValue(Scheduler.HighPriorityEntriesQueueProperty); this.normalPriorityEntriesQueue = (Queue<SchedulableItem>)rootExec.RootActivity.GetValue(Scheduler.NormalPriorityEntriesQueueProperty); if (this.highPriorityEntriesQueue == null) { this.highPriorityEntriesQueue = new Queue<SchedulableItem>(); rootExec.RootActivity.SetValue(Scheduler.HighPriorityEntriesQueueProperty, this.highPriorityEntriesQueue); } if (this.normalPriorityEntriesQueue == null) { this.normalPriorityEntriesQueue = new Queue<SchedulableItem>(); rootExec.RootActivity.SetValue(Scheduler.NormalPriorityEntriesQueueProperty, this.normalPriorityEntriesQueue); } this.empty = ((this.normalPriorityEntriesQueue.Count == 0) && (this.highPriorityEntriesQueue.Count == 0)); }
private void OnInstanceEvent(object sender, WorkflowExecutor.WorkflowExecutionEventArgs e) { switch (e.EventType) { case WorkflowEventInternal.Completed: InstanceCompleted(sender, new WorkflowEventArgs(((WorkflowExecutor)sender).WorkflowInstance)); break; case WorkflowEventInternal.Terminated: InstanceTerminated(sender, new WorkflowEventArgs(((WorkflowExecutor)sender).WorkflowInstance)); break; case WorkflowEventInternal.Unloaded: InstanceUnloaded(sender, new WorkflowEventArgs(((WorkflowExecutor)sender).WorkflowInstance)); break; case WorkflowEventInternal.Changed: OnWorkflowChanged(sender, e); break; case WorkflowEventInternal.HandlerInvoking: OnHandlerInvoking(sender, e); break; case WorkflowEventInternal.HandlerInvoked: OnHandlerInvoked(sender, e); break; case WorkflowEventInternal.ActivityStatusChange: OnActivityStatusChanged(sender, (WorkflowExecutor.ActivityStatusChangeEventArgs)e); break; case WorkflowEventInternal.ActivityExecuting: OnActivityExecuting(sender, (WorkflowExecutor.ActivityExecutingEventArgs)e); break; default: return; } }
private void WorkflowExecutionEvent(object sender, WorkflowExecutor.WorkflowExecutionEventArgs e) { if (null == sender) throw new ArgumentNullException("sender"); if (!typeof(WorkflowExecutor).IsInstanceOfType(sender)) throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, ExecutionStringManager.InvalidArgumentType, "sender", typeof(WorkflowExecutor).ToString())); WorkflowExecutor exec = (WorkflowExecutor)sender; PerformanceCounterAction action; switch (e.EventType) { case WorkflowEventInternal.Created: action = PerformanceCounterAction.Creation; break; case WorkflowEventInternal.Started: action = PerformanceCounterAction.Starting; break; case WorkflowEventInternal.Runnable: action = PerformanceCounterAction.Runnable; break; case WorkflowEventInternal.Executing: action = PerformanceCounterAction.Executing; break; case WorkflowEventInternal.NotExecuting: action = PerformanceCounterAction.NotExecuting; break; case WorkflowEventInternal.Resumed: action = PerformanceCounterAction.Resumption; break; case WorkflowEventInternal.SchedulerEmpty: // // SchedulerEmpty signals that are about to persist // after which we will be idle. We need to do the idle // work now so that it is included in the state for the idle persist. action = PerformanceCounterAction.Idle; break; case WorkflowEventInternal.Completed: action = PerformanceCounterAction.Completion; break; case WorkflowEventInternal.Suspended: action = PerformanceCounterAction.Suspension; break; case WorkflowEventInternal.Terminated: action = PerformanceCounterAction.Termination; break; case WorkflowEventInternal.Loaded: action = PerformanceCounterAction.Loading; break; case WorkflowEventInternal.Aborted: action = PerformanceCounterAction.Aborted; break; case WorkflowEventInternal.Unloaded: action = PerformanceCounterAction.Unloading; break; case WorkflowEventInternal.Persisted: action = PerformanceCounterAction.Persisted; break; default: return; } Notify(action, exec); }
private void NotifyCounter(PerformanceCounterAction action, PerformanceCounterStatement statement, WorkflowExecutor executor) { foreach (PerformanceCounter counter in statement.Counters) { switch (statement.Operation) { case PerformanceCounterOperation.Increment: counter.Increment(); break; case PerformanceCounterOperation.Decrement: counter.Decrement(); break; default: System.Diagnostics.Debug.Assert(false, "Unknown performance counter operation."); break; } } }
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); } } }
internal bool TryTrackUserEvent(Activity activity, string keyName, object argument, WorkflowExecutor exec, UserTrackingRecord record) { List<UserTrackPoint> points; if (TryGetCacheItems(activity, out points)) { bool ret = false; foreach (UserTrackPoint point in points) { if (point.IsMatch(activity, keyName, argument)) { ret = true; point.Track(activity, argument, exec, record.Body); record.Annotations.AddRange(point.Annotations); } } return ret; } return false; }
private List<TrackingChannelWrapper> GetChannels(Activity schedule, WorkflowExecutor exec, Guid instanceID, Type workflowType, ref TrackingListenerBroker broker) { if (this._services == null) { return null; } bool flag = false; if (broker == null) { broker = new TrackingListenerBroker(); flag = true; } List<TrackingChannelWrapper> list = new List<TrackingChannelWrapper>(); List<string> callPath = null; Guid empty = Guid.Empty; Guid context = this.GetContext(exec.RootActivity); Guid callerContextGuid = Guid.Empty; Guid callerParentContextGuid = Guid.Empty; TrackingCallingState trackingCallingState = exec.TrackingCallingState; TrackingListenerBroker broker1 = (TrackingListenerBroker) exec.RootActivity.GetValue(WorkflowExecutor.TrackingListenerBrokerProperty); IList<string> collection = (trackingCallingState != null) ? trackingCallingState.CallerActivityPathProxy : null; if ((collection != null) && (collection.Count > 0)) { callPath = new List<string>(collection); empty = trackingCallingState.CallerWorkflowInstanceId; callerContextGuid = trackingCallingState.CallerContextGuid; callerParentContextGuid = trackingCallingState.CallerParentContextGuid; } TrackingParameters parameters = new TrackingParameters(instanceID, workflowType, exec.WorkflowDefinition, callPath, empty, context, callerContextGuid, callerParentContextGuid); for (int i = 0; i < this._services.Count; i++) { TrackingChannel trackingChannel = null; Type trackingServiceType = this._services[i].GetType(); RTTrackingProfile profile = null; if (flag) { profile = this._profileManager.GetProfile(this._services[i], schedule); if (profile == null) { continue; } broker.AddService(trackingServiceType, profile.Version); } else { if (!broker.ContainsService(trackingServiceType)) { continue; } if (broker.IsProfileInstance(trackingServiceType)) { profile = this._profileManager.GetProfile(this._services[i], schedule, instanceID); if (profile == null) { throw new InvalidOperationException(ExecutionStringManager.MissingProfileForService + trackingServiceType.ToString()); } profile.IsPrivate = true; } else { Version version; if (!broker.TryGetProfileVersionId(trackingServiceType, out version)) { continue; } profile = this._profileManager.GetProfile(this._services[i], schedule, version); if (profile == null) { throw new InvalidOperationException(ExecutionStringManager.MissingProfileForService + trackingServiceType.ToString() + ExecutionStringManager.MissingProfileForVersion + version.ToString()); } if (broker.IsProfilePrivate(trackingServiceType)) { profile = profile.Clone(); profile.IsPrivate = true; } } } trackingChannel = this._services[i].GetTrackingChannel(parameters); if (trackingChannel == null) { throw new InvalidOperationException(ExecutionStringManager.NullChannel); } list.Add(new TrackingChannelWrapper(trackingChannel, this._services[i].GetType(), workflowType, profile)); } return list; }
internal void ReloadProfiles(WorkflowExecutor exec, Guid instanceId, ref TrackingListenerBroker broker, ref List<TrackingChannelWrapper> channels) { Type workflowType = exec.WorkflowDefinition.GetType(); foreach (TrackingService service in this._services) { TrackingProfile profile = null; TrackingChannelWrapper wrapper = null; if (service.TryReloadProfile(workflowType, instanceId, out profile)) { bool flag = false; int index = 0; while (index < channels.Count) { if (service.GetType() == channels[index].TrackingServiceType) { wrapper = channels[index]; flag = true; break; } index++; } if (profile == null) { if (flag) { broker.RemoveService(wrapper.TrackingServiceType); channels.RemoveAt(index); } } else { RTTrackingProfile profile2 = new RTTrackingProfile(profile, exec.WorkflowDefinition, workflowType) { IsPrivate = true }; if (!flag) { List<string> callPath = null; Guid empty = Guid.Empty; TrackingCallingState trackingCallingState = exec.TrackingCallingState; IList<string> collection = null; Guid context = this.GetContext(exec.RootActivity); Guid callerContextGuid = Guid.Empty; Guid callerParentContextGuid = Guid.Empty; if (trackingCallingState != null) { collection = trackingCallingState.CallerActivityPathProxy; if ((collection != null) && (collection.Count > 0)) { callPath = new List<string>(collection); empty = trackingCallingState.CallerWorkflowInstanceId; callerContextGuid = trackingCallingState.CallerContextGuid; callerParentContextGuid = trackingCallingState.CallerParentContextGuid; } } TrackingParameters parameters = new TrackingParameters(instanceId, workflowType, exec.WorkflowDefinition, callPath, empty, context, callerContextGuid, callerParentContextGuid); TrackingChannelWrapper item = new TrackingChannelWrapper(service.GetTrackingChannel(parameters), service.GetType(), workflowType, profile2); channels.Add(item); Type type = service.GetType(); broker.AddService(type, profile2.Version); broker.MakeProfileInstance(type); } else { wrapper.SetTrackingProfile(profile2); broker.MakeProfileInstance(wrapper.TrackingServiceType); } } } } }
public ScheduleWork(WorkflowExecutor executor, bool suppress) { this.oldValue = scheduleInfo; scheduleInfo = new ScheduleInfo(executor, suppress); }
private static void FireEvents(List<SchedulerLockGuardInfo> eventList, WorkflowExecutor workflowExec) { if (!workflowExec.IsInstanceValid && (workflowExec.WorkflowStatus == WorkflowStatus.Completed || workflowExec.WorkflowStatus == WorkflowStatus.Terminated)) { // The workflow is dead, let the instance have a hard ref to the corpse for support of the query apis. workflowExec.WorkflowInstance.DeadWorkflow = workflowExec; } for (int i = 0; i < eventList.Count; i++) { SchedulerLockGuardInfo eseg = eventList[i]; // eseg.EventInfo is non-null only if the event type is Suspended or Terminated // If the event type is Suspended, then call FireWorkflowSuspended after casting // the event argument to a String. // If the event type is Terminated, then call FireWorkflowTerminated after casting // the event argument to either a String or an Exception. switch (eseg.EventType) { case WorkflowEventInternal.Suspended: workflowExec.FireWorkflowSuspended((String)eseg.EventInfo); break; case WorkflowEventInternal.Terminated: if ((eseg.EventInfo as System.Exception) != null) { workflowExec.FireWorkflowTerminated((Exception)eseg.EventInfo); } else { workflowExec.FireWorkflowTerminated((String)eseg.EventInfo); } break; default: workflowExec.FireWorkflowExecutionEvent(eseg.Sender, eseg.EventType); break; } } }
private void OnActivityStatusChanged(object sender, WorkflowExecutor.ActivityStatusChangeEventArgs eventArgs) { if (this.isZombie || !this.isAttached) return; try { lock (this.eventLock) { // We will receive an event when Activity.Execute() is about to be called. if (eventArgs.Activity.ExecutionStatus == ActivityExecutionStatus.Executing) return; IWorkflowCoreRuntime workflowCoreRuntime = (IWorkflowCoreRuntime)sender; Guid scheduleTypeId = GetScheduleTypeId(workflowCoreRuntime); // When the activity starts executing, update its handler list for stepping. if (eventArgs.Activity.ExecutionStatus == ActivityExecutionStatus.Executing) EnumerateEventHandlersForActivity(scheduleTypeId, eventArgs.Activity); this.controllerConduit.BeforeActivityStatusChanged(this.programId, scheduleTypeId, workflowCoreRuntime.InstanceID, eventArgs.Activity.QualifiedName, GetHierarchicalId(eventArgs.Activity), eventArgs.Activity.ExecutionStatus, GetContextId(eventArgs.Activity)); this.controllerConduit.ActivityStatusChanged(this.programId, scheduleTypeId, workflowCoreRuntime.InstanceID, eventArgs.Activity.QualifiedName, GetHierarchicalId(eventArgs.Activity), eventArgs.Activity.ExecutionStatus, GetContextId(eventArgs.Activity)); } } catch { // Don't throw exceptions to the Runtime. Ignore exceptions that may occur if the debugger detaches // and closes the remoting channel. } }
internal SchedulerLockGuard(InstanceLock il, WorkflowExecutor w) { lg = il.Enter(); workflowExec = w; }
private void WorkflowExecutionEvent(object sender, WorkflowExecutor.WorkflowExecutionEventArgs e) { switch (e.EventType) { case WorkflowEventInternal.Terminated: case WorkflowEventInternal.Aborted: case WorkflowEventInternal.Completed: { WorkflowExecutor executor = (WorkflowExecutor) sender; lock (this._listenerLock) { this._listeners.Remove(executor.ID); } break; } case WorkflowEventInternal.Aborting: break; default: return; } }
public ScheduleWork(WorkflowExecutor executor) { this.oldValue = scheduleInfo; scheduleInfo = new ScheduleInfo(executor, false); }
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 ScheduleInfo(WorkflowExecutor executor, bool suppress) { this.suppress = suppress; this.scheduleWork = false; this.executor = executor; }
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(); } } } } }