1864 lines
72 KiB
C#
1864 lines
72 KiB
C#
using System;
|
|
using System.Text;
|
|
using System.Reflection;
|
|
using System.ComponentModel;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.Diagnostics;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Xml;
|
|
using System.Xml.XPath;
|
|
using System.Xml.Schema;
|
|
using System.IO;
|
|
using System.Runtime.Serialization.Formatters.Binary;
|
|
using System.Threading;
|
|
using System.Timers;
|
|
using System.Security.Permissions;
|
|
using System.Security.Cryptography;
|
|
|
|
using System.Workflow.Runtime;
|
|
using System.Workflow.ComponentModel;
|
|
using System.Workflow.Runtime.Hosting;
|
|
using System.Workflow.Runtime.Tracking;
|
|
|
|
namespace System.Workflow.Runtime
|
|
{
|
|
/// <summary>
|
|
/// Creates TrackingListener instances
|
|
/// </summary>
|
|
internal class TrackingListenerFactory
|
|
{
|
|
private List<TrackingService> _services = null;
|
|
private bool _initialized = false;
|
|
private Dictionary<Guid, WeakReference> _listeners = new Dictionary<Guid, WeakReference>();
|
|
private volatile object _listenerLock = new object();
|
|
|
|
private System.Timers.Timer _timer = null;
|
|
private double _interval = 60000;
|
|
|
|
private TrackingProfileManager _profileManager = new TrackingProfileManager();
|
|
|
|
internal TrackingListenerFactory()
|
|
{
|
|
}
|
|
|
|
internal TrackingProfileManager TrackingProfileManager
|
|
{
|
|
get { return _profileManager; }
|
|
}
|
|
/// <summary>
|
|
/// Must be called
|
|
/// </summary>
|
|
/// <param name="skedExec"></param>
|
|
internal void Initialize(WorkflowRuntime runtime)
|
|
{
|
|
lock (this)
|
|
{
|
|
_services = runtime.TrackingServices;
|
|
_profileManager.Initialize(runtime);
|
|
runtime.WorkflowExecutorInitializing += WorkflowExecutorInitializing;
|
|
|
|
_timer = new System.Timers.Timer();
|
|
_timer.Interval = _interval;
|
|
_timer.AutoReset = false; // ensure that only one timer thread at a time
|
|
_timer.Elapsed += new ElapsedEventHandler(Cleanup);
|
|
_timer.Start();
|
|
|
|
_initialized = true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clean up static state created in Initialize
|
|
/// </summary>
|
|
internal void Uninitialize(WorkflowRuntime runtime)
|
|
{
|
|
lock (this)
|
|
{
|
|
_profileManager.Uninitialize();
|
|
runtime.WorkflowExecutorInitializing -= WorkflowExecutorInitializing;
|
|
_timer.Elapsed -= new ElapsedEventHandler(Cleanup);
|
|
_timer.Stop();
|
|
_services = null;
|
|
_initialized = false;
|
|
|
|
_timer.Dispose();
|
|
_timer = null;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Callback for associating tracking listeners to in memory instances. Fires for new and loading instances.
|
|
/// </summary>
|
|
/// <param name="sender">WorkflowExecutor</param>
|
|
/// <param name="e"></param>
|
|
void WorkflowExecutorInitializing(object sender, WorkflowRuntime.WorkflowExecutorInitializingEventArgs e)
|
|
{
|
|
if (null == sender)
|
|
throw new ArgumentNullException("sender");
|
|
|
|
if (null == e)
|
|
throw new ArgumentNullException("e");
|
|
|
|
if (!typeof(WorkflowExecutor).IsInstanceOfType(sender))
|
|
throw new ArgumentException("sender");
|
|
|
|
WorkflowExecutor exec = (WorkflowExecutor)sender;
|
|
//
|
|
// Add an event to clean up the WeakRef entry
|
|
exec.WorkflowExecutionEvent += new EventHandler<WorkflowExecutor.WorkflowExecutionEventArgs>(WorkflowExecutionEvent);
|
|
TrackingCallingState trackingCallingState = exec.TrackingCallingState;
|
|
TrackingListenerBroker listenerBroker = (TrackingListenerBroker)exec.RootActivity.GetValue(WorkflowExecutor.TrackingListenerBrokerProperty);
|
|
if (listenerBroker != null)
|
|
{
|
|
listenerBroker.ReplaceServices(exec.WorkflowRuntime.TrackingServiceReplacement);
|
|
}
|
|
TrackingListener listener = null;
|
|
//
|
|
// Check if we still have a weakref to the listener for this instance
|
|
WeakReference weakref = null;
|
|
if (e.Loading)
|
|
{
|
|
bool found = false;
|
|
lock (_listenerLock)
|
|
{
|
|
found = _listeners.TryGetValue(exec.InstanceId, out weakref);
|
|
}
|
|
if (found)
|
|
{
|
|
try
|
|
{
|
|
//
|
|
// Instead of checking IsAlive take a ref to the Target
|
|
// so that it isn't GC'd underneath us.
|
|
listener = weakref.Target as TrackingListener;
|
|
}
|
|
catch (InvalidOperationException)
|
|
{
|
|
//
|
|
// This seems weird but according to msdn
|
|
// accessing Target can throw ???
|
|
// Ignore because it's the same as a null target.
|
|
}
|
|
}
|
|
//
|
|
// If listener is null because we didn't find the wr in the cache
|
|
// or because the Target has been GC'd create a new listener
|
|
if (null != listener)
|
|
{
|
|
listener.Broker = listenerBroker;
|
|
}
|
|
else
|
|
{
|
|
Debug.Assert(null != listenerBroker, "TrackingListenerBroker should not be null during loading");
|
|
listener = GetTrackingListener(exec.WorkflowDefinition, exec, listenerBroker);
|
|
if (null != listener)
|
|
{
|
|
if (null != weakref)
|
|
weakref.Target = listener;
|
|
else
|
|
{
|
|
lock (_listenerLock)
|
|
{
|
|
_listeners.Add(exec.ID, new WeakReference(listener));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// New instance is being created
|
|
listener = GetTrackingListener(exec.WorkflowDefinition, exec);
|
|
|
|
if (null != listener)
|
|
{
|
|
exec.RootActivity.SetValue(WorkflowExecutor.TrackingListenerBrokerProperty, listener.Broker);
|
|
lock (_listenerLock)
|
|
{
|
|
_listeners.Add(exec.ID, new WeakReference(listener));
|
|
}
|
|
}
|
|
else
|
|
exec.RootActivity.SetValue(WorkflowExecutor.TrackingListenerBrokerProperty, new TrackingListenerBroker());
|
|
}
|
|
|
|
if (null != listener)
|
|
{
|
|
exec.WorkflowExecutionEvent += new EventHandler<WorkflowExecutor.WorkflowExecutionEventArgs>(listener.WorkflowExecutionEvent);
|
|
}
|
|
|
|
}
|
|
|
|
void WorkflowExecutionEvent(object sender, WorkflowExecutor.WorkflowExecutionEventArgs e)
|
|
{
|
|
switch (e.EventType)
|
|
{
|
|
case WorkflowEventInternal.Aborted:
|
|
case WorkflowEventInternal.Completed:
|
|
case WorkflowEventInternal.Terminated:
|
|
//
|
|
// The instance is done - remove
|
|
// the WeakRef from our list
|
|
WorkflowExecutor exec = (WorkflowExecutor)sender;
|
|
lock (_listenerLock)
|
|
{
|
|
_listeners.Remove(exec.ID);
|
|
}
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
void Cleanup(object sender, ElapsedEventArgs e)
|
|
{
|
|
List<Guid> _toRemove = new List<Guid>();
|
|
if ((null != _listeners) || (_listeners.Count > 0))
|
|
{
|
|
lock (_listenerLock)
|
|
{
|
|
foreach (KeyValuePair<Guid, WeakReference> kvp in _listeners)
|
|
{
|
|
if (null == kvp.Value.Target)
|
|
_toRemove.Add(kvp.Key);
|
|
}
|
|
if (_toRemove.Count > 0)
|
|
{
|
|
foreach (Guid g in _toRemove)
|
|
_listeners.Remove(g);
|
|
}
|
|
}
|
|
}
|
|
|
|
lock (this)
|
|
{
|
|
if (_timer != null)
|
|
{
|
|
_timer.Start();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return a tracking listener for a new instance
|
|
/// </summary>
|
|
/// <param name="sked">SequentialWorkflow for which the tracking listener will be associated</param>
|
|
/// <param name="skedExec">ScheduleExecutor for the schedule instance</param>
|
|
/// <returns>New TrackingListener instance</returns>
|
|
internal TrackingListener GetTrackingListener(Activity sked, WorkflowExecutor skedExec)
|
|
{
|
|
if (!_initialized)
|
|
Initialize(skedExec.WorkflowRuntime);
|
|
|
|
return GetListener(sked, skedExec, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return a tracking listener for an existing instance (normally used during loading)
|
|
/// </summary>
|
|
/// <param name="sked">SequentialWorkflow for which the tracking listener will be associated</param>
|
|
/// <param name="skedExec">ScheduleExecutor for the schedule instance</param>
|
|
/// <param name="broker">TrackingListenerBroker</param>
|
|
/// <returns>New TrackingListener instance</returns>
|
|
internal TrackingListener GetTrackingListener(Activity sked, WorkflowExecutor skedExec, TrackingListenerBroker broker)
|
|
{
|
|
if (!_initialized)
|
|
Initialize(skedExec.WorkflowRuntime);
|
|
|
|
if (null == broker)
|
|
{
|
|
WorkflowTrace.Tracking.TraceEvent(TraceEventType.Error, 0, ExecutionStringManager.NullTrackingBroker);
|
|
return null;
|
|
}
|
|
|
|
return GetListener(sked, skedExec, broker);
|
|
}
|
|
|
|
private TrackingListener GetListenerFromWRCache(Guid instanceId)
|
|
{
|
|
WeakReference wr = null;
|
|
TrackingListener listener = null;
|
|
lock (_listenerLock)
|
|
{
|
|
if (!_listeners.TryGetValue(instanceId, out wr))
|
|
throw new InvalidOperationException(string.Format(System.Globalization.CultureInfo.InvariantCulture, ExecutionStringManager.ListenerNotInCache, instanceId));
|
|
|
|
listener = wr.Target as TrackingListener;
|
|
|
|
if (null == listener)
|
|
throw new ObjectDisposedException(string.Format(System.Globalization.CultureInfo.InvariantCulture, ExecutionStringManager.ListenerNotInCacheDisposed, instanceId));
|
|
}
|
|
|
|
return listener;
|
|
}
|
|
|
|
internal void ReloadProfiles(WorkflowExecutor exec)
|
|
{
|
|
// Keep control events from other threads out
|
|
using (new ServiceEnvironment(exec.RootActivity))
|
|
{
|
|
using (exec.ExecutorLock.Enter())
|
|
{
|
|
// check if this is a valid in-memory instance
|
|
if (!exec.IsInstanceValid)
|
|
throw new InvalidOperationException(ExecutionStringManager.WorkflowNotValid);
|
|
|
|
// suspend the instance
|
|
bool localSuspend = exec.Suspend(ExecutionStringManager.TrackingProfileUpdate);
|
|
try
|
|
{
|
|
//
|
|
// Get new profiles
|
|
TrackingListener listener = GetListenerFromWRCache(exec.InstanceId);
|
|
listener.ReloadProfiles(exec, exec.InstanceId);
|
|
}
|
|
finally
|
|
{
|
|
if (localSuspend)
|
|
{
|
|
// @undone: for now this will not return till the instance is done
|
|
// Once Kumar has fixed 4335, we can enable this.
|
|
exec.Resume();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void ReloadProfiles(WorkflowExecutor exec, Guid instanceId, ref TrackingListenerBroker broker, ref List<TrackingChannelWrapper> channels)
|
|
{
|
|
Type workflowType = exec.WorkflowDefinition.GetType();
|
|
//
|
|
// Ask every tracking service if they want to reload
|
|
// even if they originally returned null for a profile
|
|
foreach (TrackingService service in _services)
|
|
{
|
|
TrackingProfile profile = null;
|
|
TrackingChannelWrapper w = null;
|
|
//
|
|
// Check if the service wants to reload a profile
|
|
if (service.TryReloadProfile(workflowType, instanceId, out profile))
|
|
{
|
|
bool found = false;
|
|
int i;
|
|
for (i = 0; i < channels.Count; i++)
|
|
{
|
|
if (service.GetType() == channels[i].TrackingServiceType)
|
|
{
|
|
w = channels[i];
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
//
|
|
// If we don't have a profile, remove what we had for this service type (if anything)
|
|
if (null == profile)
|
|
{
|
|
if (found)
|
|
{
|
|
broker.RemoveService(w.TrackingServiceType);
|
|
channels.RemoveAt(i);
|
|
}
|
|
continue;
|
|
}
|
|
//
|
|
// Parse the new profile - instance only, the cache is not involved
|
|
RTTrackingProfile rtp = new RTTrackingProfile(profile, exec.WorkflowDefinition, workflowType);
|
|
rtp.IsPrivate = true;
|
|
|
|
if (!found)
|
|
{
|
|
//
|
|
// This is a new profile, create new channel, channelwrapper and broker item
|
|
List<string> activityCallPath = null;
|
|
Guid callerInstanceId = Guid.Empty;
|
|
TrackingCallingState trackingCallingState = exec.TrackingCallingState;
|
|
Debug.Assert((null != trackingCallingState), "WorkflowState is null");
|
|
IList<string> path = null;
|
|
Guid context = GetContext(exec.RootActivity), callerContext = Guid.Empty, callerParentContext = Guid.Empty;
|
|
//
|
|
// Use CallerActivityPathProxy to determine if this is an invoked instance
|
|
if (trackingCallingState != null)
|
|
{
|
|
path = trackingCallingState.CallerActivityPathProxy;
|
|
if ((null != path) && (path.Count > 0))
|
|
{
|
|
activityCallPath = new List<string>(path);
|
|
|
|
Debug.Assert(Guid.Empty != trackingCallingState.CallerWorkflowInstanceId, "Instance has an ActivityCallPath but CallerInstanceId is empty");
|
|
callerInstanceId = trackingCallingState.CallerWorkflowInstanceId;
|
|
|
|
callerContext = trackingCallingState.CallerContextGuid;
|
|
callerParentContext = trackingCallingState.CallerParentContextGuid;
|
|
}
|
|
}
|
|
|
|
TrackingParameters tp = new TrackingParameters(instanceId, workflowType, exec.WorkflowDefinition, activityCallPath, callerInstanceId, context, callerContext, callerParentContext);
|
|
TrackingChannel channel = service.GetTrackingChannel(tp);
|
|
|
|
TrackingChannelWrapper wrapper = new TrackingChannelWrapper(channel, service.GetType(), workflowType, rtp);
|
|
channels.Add(wrapper);
|
|
|
|
Type t = service.GetType();
|
|
broker.AddService(t, rtp.Version);
|
|
broker.MakeProfileInstance(t);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Don't need to call MakeProfilePrivate on the wrapper
|
|
// because we've already marked it as private and we already
|
|
// have a private copy of it.
|
|
//w.MakeProfilePrivate( exec );
|
|
w.SetTrackingProfile(rtp);
|
|
broker.MakeProfileInstance(w.TrackingServiceType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal Guid GetContext(Activity activity)
|
|
{
|
|
return ((ActivityExecutionContextInfo)ContextActivityUtils.ContextActivity(activity).GetValue(Activity.ActivityExecutionContextInfoProperty)).ContextGuid;
|
|
}
|
|
|
|
private TrackingListener GetListener(Activity sked, WorkflowExecutor skedExec, TrackingListenerBroker broker)
|
|
{
|
|
if ((null == sked) || (null == skedExec))
|
|
{
|
|
WorkflowTrace.Tracking.TraceEvent(TraceEventType.Error, 0, ExecutionStringManager.NullParameters);
|
|
return null;
|
|
}
|
|
|
|
if ((null == _services) || (_services.Count <= 0))
|
|
return null;
|
|
|
|
bool load = (null != broker);
|
|
|
|
List<TrackingChannelWrapper> channels = GetChannels(sked, skedExec, skedExec.InstanceId, sked.GetType(), ref broker);
|
|
|
|
if ((null == channels) || (0 == channels.Count))
|
|
return null;
|
|
|
|
return new TrackingListener(this, sked, skedExec, channels, broker, load);
|
|
}
|
|
|
|
private List<TrackingChannelWrapper> GetChannels(Activity schedule, WorkflowExecutor exec, Guid instanceID, Type workflowType, ref TrackingListenerBroker broker)
|
|
{
|
|
if (null == _services)
|
|
return null;
|
|
|
|
bool initBroker = false;
|
|
if (null == broker)
|
|
{
|
|
broker = new TrackingListenerBroker();
|
|
initBroker = true;
|
|
}
|
|
|
|
List<TrackingChannelWrapper> channels = new List<TrackingChannelWrapper>();
|
|
|
|
List<string> activityCallPath = null;
|
|
Guid callerInstanceId = Guid.Empty;
|
|
Guid context = GetContext(exec.RootActivity), callerContext = Guid.Empty, callerParentContext = Guid.Empty;
|
|
|
|
Debug.Assert(exec is WorkflowExecutor, "Executor is not WorkflowExecutor");
|
|
TrackingCallingState trackingCallingState = exec.TrackingCallingState;
|
|
TrackingListenerBroker trackingListenerBroker = (TrackingListenerBroker)exec.RootActivity.GetValue(WorkflowExecutor.TrackingListenerBrokerProperty);
|
|
IList<string> path = trackingCallingState != null ? trackingCallingState.CallerActivityPathProxy : null;
|
|
//
|
|
// Use CallerActivityPathProxy to determine if this is an invoked instance
|
|
if ((null != path) && (path.Count > 0))
|
|
{
|
|
activityCallPath = new List<string>(path);
|
|
|
|
Debug.Assert(Guid.Empty != trackingCallingState.CallerWorkflowInstanceId, "Instance has an ActivityCallPath but CallerInstanceId is empty");
|
|
callerInstanceId = trackingCallingState.CallerWorkflowInstanceId;
|
|
|
|
callerContext = trackingCallingState.CallerContextGuid;
|
|
callerParentContext = trackingCallingState.CallerParentContextGuid;
|
|
}
|
|
|
|
TrackingParameters parameters = new TrackingParameters(instanceID, workflowType, exec.WorkflowDefinition, activityCallPath, callerInstanceId, context, callerContext, callerParentContext);
|
|
|
|
for (int i = 0; i < _services.Count; i++)
|
|
{
|
|
TrackingChannel channel = null;
|
|
Type serviceType = _services[i].GetType();
|
|
|
|
//
|
|
// See if the service has a profile for this schedule type
|
|
// If not we don't do any tracking for the service
|
|
//
|
|
RTTrackingProfile profile = null;
|
|
|
|
//
|
|
// If we've created the broker get the current version of the profile
|
|
if (initBroker)
|
|
{
|
|
profile = _profileManager.GetProfile(_services[i], schedule);
|
|
|
|
if (null == profile)
|
|
continue;
|
|
|
|
broker.AddService(serviceType, profile.Version);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Only reload the services that are in the broker
|
|
// If services that weren't originally associated to an instance
|
|
// wish to join that instance they should call ReloadTrackingProfiles
|
|
if (!broker.ContainsService(serviceType))
|
|
continue;
|
|
|
|
if (broker.IsProfileInstance(serviceType))
|
|
{
|
|
profile = _profileManager.GetProfile(_services[i], schedule, instanceID);
|
|
|
|
if (null == profile)
|
|
throw new InvalidOperationException(ExecutionStringManager.MissingProfileForService + serviceType.ToString());
|
|
|
|
profile.IsPrivate = true;
|
|
}
|
|
else
|
|
{
|
|
Version versionId;
|
|
if (broker.TryGetProfileVersionId(serviceType, out versionId))
|
|
{
|
|
profile = _profileManager.GetProfile(_services[i], schedule, versionId);
|
|
|
|
if (null == profile)
|
|
throw new InvalidOperationException(ExecutionStringManager.MissingProfileForService + serviceType.ToString() + ExecutionStringManager.MissingProfileForVersion + versionId.ToString());
|
|
//
|
|
// If the profile is marked as private clone the instance we got from the cache
|
|
// The cloned instance is marked as private during the cloning
|
|
if (broker.IsProfilePrivate(serviceType))
|
|
{
|
|
profile = profile.Clone();
|
|
profile.IsPrivate = true;
|
|
}
|
|
}
|
|
else
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If profile is not null get a channel
|
|
channel = _services[i].GetTrackingChannel(parameters);
|
|
|
|
if (null == channel)
|
|
throw new InvalidOperationException(ExecutionStringManager.NullChannel);
|
|
|
|
channels.Add(new TrackingChannelWrapper(channel, _services[i].GetType(), workflowType, profile));
|
|
}
|
|
|
|
return channels;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handles subscribing to status change events and receiving event notifications.
|
|
/// </summary>
|
|
internal class TrackingListener
|
|
{
|
|
private List<TrackingChannelWrapper> _channels = null;
|
|
private TrackingListenerBroker _broker = null;
|
|
private TrackingListenerFactory _factory = null;
|
|
|
|
protected TrackingListener()
|
|
{
|
|
}
|
|
|
|
internal TrackingListener(TrackingListenerFactory factory, Activity sked, WorkflowExecutor exec, List<TrackingChannelWrapper> channels, TrackingListenerBroker broker, bool load)
|
|
{
|
|
if ((null == sked) || (null == broker))
|
|
{
|
|
WorkflowTrace.Tracking.TraceEvent(TraceEventType.Error, 0, ExecutionStringManager.NullParameters);
|
|
return;
|
|
}
|
|
_factory = factory;
|
|
_channels = channels;
|
|
//
|
|
// Keep a reference to the broker so that we can hand it out when adding subscriptions
|
|
_broker = broker;
|
|
//
|
|
// Give the broker our reference so that it can call us back on behalf of subscriptions
|
|
_broker.TrackingListener = this;
|
|
}
|
|
|
|
internal TrackingListenerBroker Broker
|
|
{
|
|
get { return _broker; }
|
|
set { _broker = value; }
|
|
}
|
|
|
|
internal void ReloadProfiles(WorkflowExecutor exec, Guid instanceId)
|
|
{
|
|
//
|
|
// Ask the factory to redo the channels and broker
|
|
_factory.ReloadProfiles(exec, instanceId, ref _broker, ref _channels);
|
|
}
|
|
|
|
|
|
#region Event Handlers
|
|
|
|
internal void ActivityStatusChange(object sender, WorkflowExecutor.ActivityStatusChangeEventArgs e)
|
|
{
|
|
WorkflowTrace.Tracking.TraceInformation("TrackingListener::ActivityStatusChange - Received Activity Status Change Event for activity {0}", e.Activity.QualifiedName);
|
|
|
|
if (null == sender)
|
|
throw new ArgumentNullException("sender");
|
|
|
|
if (!typeof(WorkflowExecutor).IsInstanceOfType(sender))
|
|
throw new ArgumentException("sender");
|
|
|
|
if (null == e)
|
|
throw new ArgumentNullException("e");
|
|
|
|
WorkflowExecutor exec = (WorkflowExecutor)sender;
|
|
|
|
if ((null == _channels) || (_channels.Count <= 0))
|
|
{
|
|
WorkflowTrace.Tracking.TraceEvent(TraceEventType.Error, 0, ExecutionStringManager.NoChannels);
|
|
return;
|
|
}
|
|
|
|
Activity activity = e.Activity;
|
|
|
|
if (!SubscriptionRequired(activity, exec))
|
|
return;
|
|
//
|
|
// Get the shared data that is the same for each tracking channel that gets a record
|
|
Guid parentContextGuid = Guid.Empty, contextGuid = Guid.Empty;
|
|
GetContext(activity, exec, out contextGuid, out parentContextGuid);
|
|
|
|
DateTime dt = DateTime.UtcNow;
|
|
int eventOrderId = _broker.GetNextEventOrderId();
|
|
|
|
foreach (TrackingChannelWrapper wrapper in _channels)
|
|
{
|
|
//
|
|
// Create a record for each tracking channel
|
|
// Each channel gets a distinct record because extract data will almost always be different.
|
|
ActivityTrackingRecord record = new ActivityTrackingRecord(activity.GetType(), activity.QualifiedName, contextGuid, parentContextGuid, activity.ExecutionStatus, dt, eventOrderId, null);
|
|
|
|
bool extracted = wrapper.GetTrackingProfile(exec).TryTrackActivityEvent(activity, activity.ExecutionStatus, exec, record);
|
|
//
|
|
// Only send the record to the channel if the profile indicates that it is interested
|
|
// This doesn't mean that the Body will always have data in it,
|
|
// it may be an empty extraction (just header info)
|
|
if (extracted)
|
|
wrapper.TrackingChannel.Send(record);
|
|
}
|
|
}
|
|
|
|
internal void UserTrackPoint(object sender, WorkflowExecutor.UserTrackPointEventArgs e)
|
|
{
|
|
if (!typeof(WorkflowExecutor).IsInstanceOfType(sender))
|
|
throw new ArgumentException("sender is not WorkflowExecutor");
|
|
|
|
WorkflowExecutor exec = (WorkflowExecutor)sender;
|
|
Activity activity = e.Activity;
|
|
|
|
DateTime dt = DateTime.UtcNow;
|
|
int eventOrderId = _broker.GetNextEventOrderId();
|
|
|
|
Guid parentContextGuid, contextGuid;
|
|
GetContext(activity, exec, out contextGuid, out parentContextGuid);
|
|
|
|
foreach (TrackingChannelWrapper wrapper in _channels)
|
|
{
|
|
UserTrackingRecord record = new UserTrackingRecord(activity.GetType(), activity.QualifiedName, contextGuid, parentContextGuid, dt, eventOrderId, e.Key, e.Args);
|
|
|
|
if (wrapper.GetTrackingProfile(exec).TryTrackUserEvent(activity, e.Key, e.Args, exec, record))
|
|
wrapper.TrackingChannel.Send(record);
|
|
}
|
|
}
|
|
|
|
internal void WorkflowExecutionEvent(object sender, WorkflowExecutor.WorkflowExecutionEventArgs e)
|
|
{
|
|
if (null == sender)
|
|
throw new ArgumentNullException("sender");
|
|
|
|
WorkflowExecutor exec = sender as WorkflowExecutor;
|
|
if (null == exec)
|
|
throw new ArgumentException(ExecutionStringManager.InvalidSenderWorkflowExecutor);
|
|
//
|
|
// Many events are mapped "forward" and sent to tracking services
|
|
// (Persisting->Persisted, SchedulerEmpty->Idle)
|
|
// This is so that a batch is always available when a tracking service gets an event.
|
|
// Without this tracking data could be inconsistent with the state of the instance.
|
|
switch (e.EventType)
|
|
{
|
|
case WorkflowEventInternal.Creating:
|
|
NotifyChannels(TrackingWorkflowEvent.Created, e, exec);
|
|
return;
|
|
case WorkflowEventInternal.Starting:
|
|
NotifyChannels(TrackingWorkflowEvent.Started, e, exec);
|
|
return;
|
|
case WorkflowEventInternal.Suspending:
|
|
NotifyChannels(TrackingWorkflowEvent.Suspended, e, exec);
|
|
return;
|
|
case WorkflowEventInternal.Resuming:
|
|
NotifyChannels(TrackingWorkflowEvent.Resumed, e, exec);
|
|
return;
|
|
case WorkflowEventInternal.Persisting:
|
|
NotifyChannels(TrackingWorkflowEvent.Persisted, e, exec);
|
|
return;
|
|
case WorkflowEventInternal.Unloading:
|
|
NotifyChannels(TrackingWorkflowEvent.Unloaded, e, exec);
|
|
return;
|
|
case WorkflowEventInternal.Loading:
|
|
NotifyChannels(TrackingWorkflowEvent.Loaded, e, exec);
|
|
return;
|
|
case WorkflowEventInternal.Completing:
|
|
NotifyChannels(TrackingWorkflowEvent.Completed, e, exec);
|
|
NotifyChannelsOfCompletionOrTermination();
|
|
return;
|
|
case WorkflowEventInternal.Aborting:
|
|
NotifyChannels(TrackingWorkflowEvent.Aborted, e, exec);
|
|
return;
|
|
case WorkflowEventInternal.Terminating:
|
|
NotifyChannels(TrackingWorkflowEvent.Terminated, e, exec);
|
|
NotifyChannelsOfCompletionOrTermination();
|
|
return;
|
|
case WorkflowEventInternal.Exception:
|
|
NotifyChannels(TrackingWorkflowEvent.Exception, e, exec);
|
|
return;
|
|
case WorkflowEventInternal.SchedulerEmpty:
|
|
NotifyChannels(TrackingWorkflowEvent.Idle, e, exec);
|
|
return;
|
|
case WorkflowEventInternal.UserTrackPoint:
|
|
UserTrackPoint(exec, (WorkflowExecutor.UserTrackPointEventArgs)e);
|
|
return;
|
|
case WorkflowEventInternal.ActivityStatusChange:
|
|
ActivityStatusChange(exec, (WorkflowExecutor.ActivityStatusChangeEventArgs)e);
|
|
return;
|
|
case WorkflowEventInternal.DynamicChangeBegin:
|
|
DynamicUpdateBegin(exec, (WorkflowExecutor.DynamicUpdateEventArgs)e);
|
|
return;
|
|
case WorkflowEventInternal.DynamicChangeRollback:
|
|
DynamicUpdateRollback(exec, (WorkflowExecutor.DynamicUpdateEventArgs)e);
|
|
return;
|
|
case WorkflowEventInternal.DynamicChangeCommit:
|
|
DynamicUpdateCommit(exec, (WorkflowExecutor.DynamicUpdateEventArgs)e);
|
|
return;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
internal void DynamicUpdateBegin(object sender, WorkflowExecutor.DynamicUpdateEventArgs e)
|
|
{
|
|
if (null == sender)
|
|
throw new ArgumentNullException("sender");
|
|
|
|
if (!typeof(WorkflowExecutor).IsInstanceOfType(sender))
|
|
throw new ArgumentException("sender");
|
|
|
|
WorkflowExecutor exec = (WorkflowExecutor)sender;
|
|
//
|
|
// WorkflowChangeEventArgs may be null or the WorkflowChanges may be null or empty
|
|
// If so there's no work to do here
|
|
if (null == e.ChangeActions)
|
|
return;
|
|
//
|
|
// Clone the profiles to create instance specific copies (if they aren't already)
|
|
MakeProfilesPrivate(exec);
|
|
//
|
|
// Give the profiles the changes. At this point we are in a volatile state.
|
|
// Profiles must act as if the changes will succeed but roll back any internal changes if they do not.
|
|
foreach (TrackingChannelWrapper channel in _channels)
|
|
{
|
|
channel.GetTrackingProfile(exec).WorkflowChangeBegin(e.ChangeActions);
|
|
}
|
|
}
|
|
|
|
internal void DynamicUpdateRollback(object sender, WorkflowExecutor.DynamicUpdateEventArgs e)
|
|
{
|
|
if (null == sender)
|
|
throw new ArgumentNullException("sender");
|
|
|
|
if (!typeof(WorkflowExecutor).IsInstanceOfType(sender))
|
|
throw new ArgumentException("sender");
|
|
|
|
WorkflowExecutor exec = (WorkflowExecutor)sender;
|
|
|
|
foreach (TrackingChannelWrapper channel in _channels)
|
|
{
|
|
channel.GetTrackingProfile(exec).WorkflowChangeRollback();
|
|
}
|
|
}
|
|
|
|
internal void DynamicUpdateCommit(object sender, WorkflowExecutor.DynamicUpdateEventArgs e)
|
|
{
|
|
if (null == sender)
|
|
throw new ArgumentNullException("sender");
|
|
|
|
if (!typeof(WorkflowExecutor).IsInstanceOfType(sender))
|
|
throw new ArgumentException("sender");
|
|
|
|
WorkflowExecutor exec = (WorkflowExecutor)sender;
|
|
|
|
DateTime dt = DateTime.UtcNow;
|
|
foreach (TrackingChannelWrapper channel in _channels)
|
|
{
|
|
channel.GetTrackingProfile(exec).WorkflowChangeCommit();
|
|
}
|
|
//
|
|
// Notify tracking channels of changes
|
|
int eventOrderId = _broker.GetNextEventOrderId();
|
|
|
|
foreach (TrackingChannelWrapper wrapper in _channels)
|
|
{
|
|
WorkflowTrackingRecord rec = new WorkflowTrackingRecord(TrackingWorkflowEvent.Changed, dt, eventOrderId, new TrackingWorkflowChangedEventArgs(e.ChangeActions, exec.WorkflowDefinition));
|
|
if (wrapper.GetTrackingProfile(exec).TryTrackInstanceEvent(TrackingWorkflowEvent.Changed, rec))
|
|
wrapper.TrackingChannel.Send(rec);
|
|
}
|
|
}
|
|
|
|
#endregion Event Handlers
|
|
|
|
#region Private Methods
|
|
|
|
private void NotifyChannels(TrackingWorkflowEvent evt, WorkflowExecutor.WorkflowExecutionEventArgs e, WorkflowExecutor exec)
|
|
{
|
|
DateTime dt = DateTime.UtcNow;
|
|
int eventOrderId = _broker.GetNextEventOrderId();
|
|
|
|
foreach (TrackingChannelWrapper wrapper in _channels)
|
|
{
|
|
EventArgs args = null;
|
|
switch (evt)
|
|
{
|
|
case TrackingWorkflowEvent.Suspended:
|
|
args = new TrackingWorkflowSuspendedEventArgs(((WorkflowExecutor.WorkflowExecutionSuspendingEventArgs)e).Error);
|
|
break;
|
|
case TrackingWorkflowEvent.Terminated:
|
|
WorkflowExecutor.WorkflowExecutionTerminatingEventArgs wtea = (WorkflowExecutor.WorkflowExecutionTerminatingEventArgs)e;
|
|
if (null != wtea.Exception)
|
|
args = new TrackingWorkflowTerminatedEventArgs(wtea.Exception);
|
|
else
|
|
args = new TrackingWorkflowTerminatedEventArgs(wtea.Error);
|
|
break;
|
|
case TrackingWorkflowEvent.Exception:
|
|
WorkflowExecutor.WorkflowExecutionExceptionEventArgs weea = (WorkflowExecutor.WorkflowExecutionExceptionEventArgs)e;
|
|
args = new TrackingWorkflowExceptionEventArgs(weea.Exception, weea.CurrentPath, weea.OriginalPath, weea.ContextGuid, weea.ParentContextGuid);
|
|
break;
|
|
}
|
|
WorkflowTrackingRecord rec = new WorkflowTrackingRecord(evt, dt, eventOrderId, args);
|
|
if (wrapper.GetTrackingProfile(exec).TryTrackInstanceEvent(evt, rec))
|
|
wrapper.TrackingChannel.Send(rec);
|
|
}
|
|
}
|
|
|
|
private void NotifyChannelsOfCompletionOrTermination()
|
|
{
|
|
foreach (TrackingChannelWrapper wrapper in _channels)
|
|
wrapper.TrackingChannel.InstanceCompletedOrTerminated();
|
|
}
|
|
|
|
private void GetContext(Activity activity, WorkflowExecutor exec, out Guid contextGuid, out Guid parentContextGuid)
|
|
{
|
|
contextGuid = _factory.GetContext(activity);
|
|
|
|
if (null != activity.Parent)
|
|
parentContextGuid = _factory.GetContext(activity.Parent);
|
|
else
|
|
parentContextGuid = contextGuid;
|
|
|
|
Debug.Assert(contextGuid != Guid.Empty, "TrackingContext is empty");
|
|
Debug.Assert(parentContextGuid != Guid.Empty, "Parent TrackingContext is empty");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clone all profiles to create private versions in order to hold subscriptions for dynamic changes
|
|
/// </summary>
|
|
private void MakeProfilesPrivate(WorkflowExecutor exec)
|
|
{
|
|
foreach (TrackingChannelWrapper channel in _channels)
|
|
{
|
|
channel.MakeProfilePrivate(exec);
|
|
_broker.MakeProfilePrivate(channel.TrackingServiceType);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Determine if subscriptions are needed
|
|
/// </summary>
|
|
/// <param name="activity">Activity for which to check subscription needs</param>
|
|
/// <returns></returns>
|
|
private bool SubscriptionRequired(Activity activity, WorkflowExecutor exec)
|
|
{
|
|
//
|
|
// Give each channel a chance to prep itself
|
|
bool needed = false;
|
|
|
|
foreach (TrackingChannelWrapper channel in _channels)
|
|
{
|
|
if ((channel.GetTrackingProfile(exec).ActivitySubscriptionNeeded(activity)) && (!needed))
|
|
needed = true;
|
|
}
|
|
|
|
return needed;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
/// <summary>
|
|
/// This is a lightweight class that is serialized so that the TrackingListener doesn't have to be.
|
|
/// Every subscription that the listener adds holds a reference to this class.
|
|
/// When an instance is loaded the broker is given to the listener factory and the listener factory
|
|
/// gives the broker the new listener. This saves us from having to persist the listener itself which
|
|
/// means that while we do need to persist a list of service types and their profile version we don't
|
|
/// have to persist the channels themselves (and we can't control how heavy channels get as they are host defined).
|
|
/// </summary>
|
|
[Serializable]
|
|
internal class TrackingListenerBroker : System.Runtime.Serialization.ISerializable
|
|
{
|
|
[NonSerialized]
|
|
private TrackingListener _listener = null;
|
|
private int _eventOrderId = 0;
|
|
private Dictionary<Guid, ServiceProfileContainer> _services = new Dictionary<Guid, ServiceProfileContainer>();
|
|
|
|
internal TrackingListenerBroker()
|
|
{
|
|
}
|
|
|
|
internal TrackingListenerBroker(TrackingListener listener)
|
|
{
|
|
_listener = listener;
|
|
}
|
|
|
|
internal TrackingListener TrackingListener
|
|
{
|
|
//
|
|
// FxCops minbar complains because this isn't used.
|
|
// The Setter is required; seems weird not to have a getter.
|
|
//get { return _listener; }
|
|
set { _listener = value; }
|
|
}
|
|
|
|
internal bool ContainsService(Type trackingServiceType)
|
|
{
|
|
return _services.ContainsKey(HashHelper.HashServiceType(trackingServiceType));
|
|
}
|
|
|
|
internal void AddService(Type trackingServiceType, Version profileVersionId)
|
|
{
|
|
_services.Add(HashHelper.HashServiceType(trackingServiceType), new ServiceProfileContainer(profileVersionId));
|
|
}
|
|
|
|
internal void ReplaceServices(Dictionary<string, Type> replacements)
|
|
{
|
|
if (replacements != null && replacements.Count > 0)
|
|
{
|
|
ServiceProfileContainer item;
|
|
foreach (KeyValuePair<string, Type> replacement in replacements)
|
|
{
|
|
Guid previous = HashHelper.HashServiceType(replacement.Key);
|
|
if (_services.TryGetValue(previous, out item))
|
|
{
|
|
_services.Remove(previous);
|
|
Guid current = HashHelper.HashServiceType(replacement.Value);
|
|
if (!_services.ContainsKey(current))
|
|
{
|
|
_services.Add(current, item);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void RemoveService(Type trackingServiceType)
|
|
{
|
|
_services.Remove(HashHelper.HashServiceType(trackingServiceType));
|
|
}
|
|
|
|
internal bool TryGetProfileVersionId(Type trackingServiceType, out Version profileVersionId)
|
|
{
|
|
profileVersionId = new Version(0, 0);
|
|
|
|
ServiceProfileContainer service = null;
|
|
if (_services.TryGetValue(HashHelper.HashServiceType(trackingServiceType), out service))
|
|
{
|
|
profileVersionId = service.ProfileVersionId;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
internal void MakeProfilePrivate(Type trackingServiceType)
|
|
{
|
|
ServiceProfileContainer service = null;
|
|
if (!_services.TryGetValue(HashHelper.HashServiceType(trackingServiceType), out service))
|
|
throw new ArgumentException(ExecutionStringManager.InvalidTrackingService);
|
|
|
|
service.IsPrivate = true;
|
|
}
|
|
|
|
internal bool IsProfilePrivate(Type trackingServiceType)
|
|
{
|
|
ServiceProfileContainer service = null;
|
|
if (!_services.TryGetValue(HashHelper.HashServiceType(trackingServiceType), out service))
|
|
throw new ArgumentException(ExecutionStringManager.InvalidTrackingService);
|
|
|
|
return service.IsPrivate;
|
|
}
|
|
|
|
internal void MakeProfileInstance(Type trackingServiceType)
|
|
{
|
|
ServiceProfileContainer service = null;
|
|
if (!_services.TryGetValue(HashHelper.HashServiceType(trackingServiceType), out service))
|
|
throw new ArgumentException(ExecutionStringManager.InvalidTrackingService);
|
|
//
|
|
// Can't be instance without being private
|
|
service.IsPrivate = true;
|
|
service.IsInstance = true;
|
|
}
|
|
|
|
internal bool IsProfileInstance(Type trackingServiceType)
|
|
{
|
|
ServiceProfileContainer service = null;
|
|
if (!_services.TryGetValue(HashHelper.HashServiceType(trackingServiceType), out service))
|
|
throw new ArgumentException(ExecutionStringManager.InvalidTrackingService);
|
|
|
|
return service.IsInstance;
|
|
}
|
|
|
|
internal int GetNextEventOrderId()
|
|
{
|
|
checked
|
|
{
|
|
return ++_eventOrderId;
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
internal class ServiceProfileContainer
|
|
{
|
|
Version _profileVersionId = new Version(0, 0);
|
|
bool _isPrivate = false;
|
|
bool _isInstance = false;
|
|
|
|
protected ServiceProfileContainer() { }
|
|
|
|
internal ServiceProfileContainer(Version profileVersionId)
|
|
{
|
|
_profileVersionId = profileVersionId;
|
|
}
|
|
|
|
internal Version ProfileVersionId
|
|
{
|
|
get { return _profileVersionId; }
|
|
}
|
|
|
|
internal bool IsPrivate
|
|
{
|
|
get { return _isPrivate; }
|
|
set { _isPrivate = value; }
|
|
}
|
|
|
|
internal bool IsInstance
|
|
{
|
|
get { return _isInstance; }
|
|
set { _isInstance = value; }
|
|
}
|
|
}
|
|
|
|
#region ISerializable Members
|
|
|
|
[SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter = true)]
|
|
public void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
|
|
{
|
|
info.AddValue("eventOrderId", this._eventOrderId);
|
|
info.AddValue("services", this._services.Count == 0 ? null : this._services);
|
|
}
|
|
private TrackingListenerBroker(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
|
|
{
|
|
this._eventOrderId = info.GetInt32("eventOrderId");
|
|
this._services = (Dictionary<Guid, ServiceProfileContainer>)info.GetValue("services", typeof(Dictionary<Guid, ServiceProfileContainer>));
|
|
if (this._services == null)
|
|
this._services = new Dictionary<Guid, ServiceProfileContainer>();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
/// <summary>
|
|
/// Manages profile requests, caching profiles and creating RTTrackingProfile instances.
|
|
/// </summary>
|
|
internal class TrackingProfileManager
|
|
{
|
|
//
|
|
// This is a dictionary keyed by tracking service type
|
|
// that returns a dictionary that is key by schedule type
|
|
// that returns a Set of profile versions for that schedule type
|
|
// The set is constrained by VersionId
|
|
private Dictionary<Type, Dictionary<Type, ProfileList>> _cacheLookup;
|
|
//
|
|
// Protects _cacheLookup
|
|
private object _cacheLock = new object();
|
|
//
|
|
// Values assigned in Initialize
|
|
private bool _init = false;
|
|
private List<TrackingService> _services = null;
|
|
private WorkflowRuntime _runtime = null;
|
|
|
|
internal TrackingProfileManager()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// Clears all entries from the cache by reinitializing the member
|
|
/// </summary>
|
|
public static void ClearCache()
|
|
{
|
|
WorkflowRuntime.ClearTrackingProfileCache();
|
|
}
|
|
|
|
internal void ClearCacheImpl()
|
|
{
|
|
lock (_cacheLock)
|
|
{
|
|
_cacheLookup = new Dictionary<Type, Dictionary<Type, ProfileList>>();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Create static state
|
|
/// </summary>
|
|
/// <param name="runtime"></param>
|
|
internal void Initialize(WorkflowRuntime runtime)
|
|
{
|
|
lock (_cacheLock)
|
|
{
|
|
if (null == runtime)
|
|
throw new ArgumentException(ExecutionStringManager.NullEngine);
|
|
|
|
_runtime = runtime;
|
|
//
|
|
// Initialize the cache
|
|
// Do this every time the runtime starts/stops to make life easier
|
|
// for IProfileNotification tracking services that might have updated
|
|
// profiles while we were stopped - we'll go get new versions since nothing is cached
|
|
// without them having to fire updated events.
|
|
_cacheLookup = new Dictionary<Type, Dictionary<Type, ProfileList>>();
|
|
if (null != runtime.TrackingServices)
|
|
{
|
|
_services = runtime.TrackingServices;
|
|
foreach (TrackingService service in _services)
|
|
{
|
|
if (service is IProfileNotification)
|
|
{
|
|
((IProfileNotification)service).ProfileUpdated += new EventHandler<ProfileUpdatedEventArgs>(ProfileUpdated);
|
|
((IProfileNotification)service).ProfileRemoved += new EventHandler<ProfileRemovedEventArgs>(ProfileRemoved);
|
|
}
|
|
}
|
|
}
|
|
_init = true;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Clean up static state
|
|
/// </summary>
|
|
internal void Uninitialize()
|
|
{
|
|
lock (_cacheLock)
|
|
{
|
|
if (null != _runtime)
|
|
{
|
|
foreach (TrackingService service in _services)
|
|
{
|
|
if (service is IProfileNotification)
|
|
{
|
|
((IProfileNotification)service).ProfileUpdated -= new EventHandler<ProfileUpdatedEventArgs>(ProfileUpdated);
|
|
((IProfileNotification)service).ProfileRemoved -= new EventHandler<ProfileRemovedEventArgs>(ProfileRemoved);
|
|
}
|
|
}
|
|
}
|
|
_runtime = null;
|
|
_services = null;
|
|
_init = false;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Retrieves the current version of a profile from the specified service
|
|
/// </summary>
|
|
internal RTTrackingProfile GetProfile(TrackingService service, Activity schedule)
|
|
{
|
|
if (!_init)
|
|
throw new ApplicationException(ExecutionStringManager.TrackingProfileManagerNotInitialized);
|
|
|
|
if ((null == service) || (null == schedule))
|
|
{
|
|
WorkflowTrace.Tracking.TraceEvent(TraceEventType.Error, 0, ExecutionStringManager.NullParameters);
|
|
return null;
|
|
}
|
|
|
|
Type workflowType = schedule.GetType();
|
|
RTTrackingProfile tp = null;
|
|
if (service is IProfileNotification)
|
|
{
|
|
//
|
|
// If we found the profile in the cache return it, it may be null, this is OK
|
|
// (no profile for this service type/schedule type combination)
|
|
if (TryGetFromCache(service.GetType(), workflowType, out tp))
|
|
return tp;
|
|
}
|
|
//
|
|
// Either we don't have anything in the cache for this schedule/service combination
|
|
// or this is a base TrackingService that doesn't notify of profile updates
|
|
// Get the profile from the service
|
|
TrackingProfile profile = null;
|
|
|
|
if (!service.TryGetProfile(workflowType, out profile))
|
|
{
|
|
//
|
|
// No profile for this schedule from this service
|
|
// RemoveProfile will just mark this service/schedule as not currently having a profile in the cache
|
|
RemoveProfile(workflowType, service.GetType());
|
|
return null;
|
|
}
|
|
//
|
|
// Check the cache to see if we already have this version
|
|
// For TrackingService types this is necessary.
|
|
// For IProfileNotification types this is a bit redundant
|
|
// but another threadcould have inserted the profile into the cache
|
|
// so check again before acquiring the writer lock
|
|
if (TryGetFromCache(service.GetType(), workflowType, profile.Version, out tp))
|
|
return tp;
|
|
//
|
|
// No profile, create it
|
|
string xaml = schedule.GetValue(Activity.WorkflowXamlMarkupProperty) as string;
|
|
if (null != xaml && xaml.Length > 0)
|
|
{
|
|
//
|
|
// Never add xaml only workflows to the cache
|
|
// Each one must be handled distinctly
|
|
return CreateProfile(profile, schedule, service.GetType());
|
|
}
|
|
else
|
|
{
|
|
tp = CreateProfile(profile, workflowType, service.GetType());
|
|
}
|
|
|
|
lock (_cacheLock)
|
|
{
|
|
//
|
|
// Recheck the cache with exclusive access
|
|
RTTrackingProfile tmp = null;
|
|
if (TryGetFromCache(service.GetType(), workflowType, profile.Version, out tmp))
|
|
return tmp;
|
|
//
|
|
// Add it to the cache
|
|
if (!AddToCache(tp, service.GetType()))
|
|
throw new ApplicationException(ExecutionStringManager.ProfileCacheInsertFailure);
|
|
|
|
return tp;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Retrieves the specified version of a profile from the specified service
|
|
/// </summary>
|
|
internal RTTrackingProfile GetProfile(TrackingService service, Activity workflow, Version versionId)
|
|
{
|
|
if (null == service)
|
|
throw new ArgumentNullException("service");
|
|
if (null == workflow)
|
|
throw new ArgumentNullException("workflow");
|
|
|
|
if (!_init)
|
|
throw new InvalidOperationException(ExecutionStringManager.TrackingProfileManagerNotInitialized);
|
|
|
|
Type workflowType = workflow.GetType();
|
|
RTTrackingProfile tp = null;
|
|
//
|
|
// Looking for a specific version, see if it is in the cache
|
|
if (TryGetFromCache(service.GetType(), workflowType, versionId, out tp))
|
|
return tp;
|
|
|
|
TrackingProfile profile = service.GetProfile(workflowType, versionId);
|
|
//
|
|
// No profile, create it
|
|
string xaml = workflow.GetValue(Activity.WorkflowXamlMarkupProperty) as string;
|
|
if (null != xaml && xaml.Length > 0)
|
|
{
|
|
//
|
|
// Never add xaml only workflows to the cache
|
|
// Each one must be handled distinctly
|
|
return CreateProfile(profile, workflow, service.GetType());
|
|
}
|
|
else
|
|
{
|
|
tp = CreateProfile(profile, workflowType, service.GetType());
|
|
}
|
|
|
|
lock (_cacheLock)
|
|
{
|
|
//
|
|
// Recheck the cache with exclusive access
|
|
RTTrackingProfile tmp = null;
|
|
if (TryGetFromCache(service.GetType(), workflowType, versionId, out tmp))
|
|
return tmp;
|
|
//
|
|
// Add it to the cache
|
|
if (!AddToCache(tp, service.GetType()))
|
|
throw new ApplicationException(ExecutionStringManager.ProfileCacheInsertFailure);
|
|
|
|
return tp;
|
|
}
|
|
}
|
|
|
|
internal RTTrackingProfile GetProfile(TrackingService service, Activity workflow, Guid instanceId)
|
|
{
|
|
//
|
|
// An instance based profile will never be in the cache
|
|
TrackingProfile profile = service.GetProfile(instanceId);
|
|
|
|
if (null == profile)
|
|
return null;
|
|
|
|
return new RTTrackingProfile(profile, workflow, service.GetType());
|
|
}
|
|
|
|
#region Private Methods
|
|
|
|
private RTTrackingProfile CreateProfile(TrackingProfile profile, Type workflowType, Type serviceType)
|
|
{
|
|
//
|
|
// Can't use the activity definition that we have here, it may have been updated
|
|
// Get the base definition and use it to create the profile.
|
|
Activity tmpSchedule = _runtime.GetWorkflowDefinition(workflowType);
|
|
return new RTTrackingProfile(profile, tmpSchedule, serviceType);
|
|
}
|
|
private RTTrackingProfile CreateProfile(TrackingProfile profile, Activity schedule, Type serviceType)
|
|
{
|
|
//
|
|
// This is called for Xaml only workflows
|
|
return new RTTrackingProfile(profile, schedule, serviceType);
|
|
}
|
|
/// <summary>
|
|
/// Add a profile to the cache but do not reset the NoProfiles flag for the schedule type
|
|
/// </summary>
|
|
/// <param name="profile">RTTrackingProfile to add</param>
|
|
/// <param name="serviceType">TrackingService type</param>
|
|
/// <returns>True if the profile was successfully added; false if not</returns>
|
|
private bool AddToCache(RTTrackingProfile profile, Type serviceType)
|
|
{
|
|
return AddToCache(profile, serviceType, false);
|
|
}
|
|
/// <summary>
|
|
/// Adds a profile to the cache and optionally resets the NoProfiles flag for the schedule type
|
|
/// </summary>
|
|
/// <param name="profile">RTTrackingProfile to add</param>
|
|
/// <param name="serviceType">TrackingService type</param>
|
|
/// <param name="resetNoProfiles">true will reset NoProfiles (to false); false will leave NoProfiles as is</param>
|
|
/// <returns>True if the profile was successfully added; false if not</returns>
|
|
private bool AddToCache(RTTrackingProfile profile, Type serviceType, bool resetNoProfiles)
|
|
{
|
|
//
|
|
// Profile may be null, serviceType may not
|
|
if (null == serviceType)
|
|
return false;
|
|
|
|
lock (_cacheLock)
|
|
{
|
|
Dictionary<Type, ProfileList> schedules = null;
|
|
//
|
|
// Get the dictionary for the service type,
|
|
// create it if it doesn't exist
|
|
if (!_cacheLookup.TryGetValue(serviceType, out schedules))
|
|
{
|
|
schedules = new Dictionary<Type, ProfileList>();
|
|
_cacheLookup.Add(serviceType, schedules);
|
|
}
|
|
//
|
|
// The the ProfileList for the schedule type,
|
|
// create it if it doesn't exist
|
|
ProfileList profiles = null;
|
|
if (!schedules.TryGetValue(profile.WorkflowType, out profiles))
|
|
{
|
|
profiles = new ProfileList();
|
|
schedules.Add(profile.WorkflowType, profiles);
|
|
}
|
|
if (resetNoProfiles)
|
|
profiles.NoProfile = false;
|
|
return profiles.Profiles.TryAdd(new CacheItem(profile));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Gets a profile from the cache
|
|
/// </summary>
|
|
private bool TryGetFromCache(Type serviceType, Type workflowType, out RTTrackingProfile profile)
|
|
{
|
|
return TryGetFromCache(serviceType, workflowType, new Version(0, 0), out profile); // 0 is an internal signal to get the most current
|
|
}
|
|
/// <summary>
|
|
/// Gets a profile from the cache
|
|
/// </summary>
|
|
private bool TryGetFromCache(Type serviceType, Type workflowType, Version versionId, out RTTrackingProfile profile)
|
|
{
|
|
profile = null;
|
|
CacheItem item = null;
|
|
lock (_cacheLock)
|
|
{
|
|
Dictionary<Type, ProfileList> schedules = null;
|
|
|
|
if (!_cacheLookup.TryGetValue(serviceType, out schedules))
|
|
return false;
|
|
|
|
ProfileList profiles = null;
|
|
if (!schedules.TryGetValue(workflowType, out profiles))
|
|
return false;
|
|
|
|
//
|
|
// 0 means get the current version
|
|
if (0 == versionId.Major)
|
|
{
|
|
//
|
|
// Currently the schedule type doesn't have a profile associated to it
|
|
if (profiles.NoProfile)
|
|
return true;
|
|
|
|
if ((null == profiles.Profiles) || (0 == profiles.Profiles.Count))
|
|
return false;
|
|
|
|
//
|
|
// Current version is highest versionId
|
|
// which means it is at the end of the Set
|
|
int endPos = profiles.Profiles.Count - 1;
|
|
|
|
if (null == profiles.Profiles[endPos])
|
|
return false;
|
|
|
|
profile = profiles.Profiles[endPos].TrackingProfile;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if ((null == profiles.Profiles) || (0 == profiles.Profiles.Count))
|
|
return false;
|
|
|
|
if (profiles.Profiles.TryGetValue(new CacheItem(workflowType, versionId), out item))
|
|
{
|
|
profile = item.TrackingProfile;
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Event Handlers
|
|
/// <summary>
|
|
/// Listens on ProfileUpdated events from IProfileNotification services
|
|
/// </summary>
|
|
/// <param name="sender">Type of the tracking service sending the update</param>
|
|
/// <param name="e">ProfileUpdatedEventArgs containing the new profile and the schedule type</param>
|
|
private void ProfileUpdated(object sender, ProfileUpdatedEventArgs e)
|
|
{
|
|
if (null == sender)
|
|
throw new ArgumentNullException("sender");
|
|
|
|
Type t = sender.GetType();
|
|
|
|
if (null == e.WorkflowType)
|
|
throw new ArgumentNullException("e");
|
|
|
|
if (null == e.TrackingProfile)
|
|
{
|
|
RemoveProfile(e.WorkflowType, t);
|
|
return;
|
|
}
|
|
|
|
RTTrackingProfile profile = CreateProfile(e.TrackingProfile, e.WorkflowType, t);
|
|
//
|
|
// If AddToCache fails this version is already in the cache and we don't care
|
|
AddToCache(profile, t, true);
|
|
}
|
|
|
|
private void ProfileRemoved(object sender, ProfileRemovedEventArgs e)
|
|
{
|
|
if (null == sender)
|
|
throw new ArgumentNullException("sender");
|
|
|
|
if (null == e.WorkflowType)
|
|
throw new ArgumentNullException("e");
|
|
|
|
RemoveProfile(e.WorkflowType, sender.GetType());
|
|
}
|
|
|
|
private void RemoveProfile(Type workflowType, Type serviceType)
|
|
{
|
|
lock (_cacheLock)
|
|
{
|
|
Dictionary<Type, ProfileList> schedules = null;
|
|
|
|
if (!_cacheLookup.TryGetValue(serviceType, out schedules))
|
|
{
|
|
schedules = new Dictionary<Type, ProfileList>();
|
|
_cacheLookup.Add(serviceType, schedules);
|
|
}
|
|
ProfileList profiles = null;
|
|
if (!schedules.TryGetValue(workflowType, out profiles))
|
|
{
|
|
profiles = new ProfileList();
|
|
schedules.Add(workflowType, profiles);
|
|
}
|
|
//
|
|
// Finally indicate that there isn't a profile for this schedule type
|
|
// Calling UpdateProfile for this type will result in resetting this field
|
|
// regardless of whether the version of the profile passed is in the cache or not
|
|
profiles.NoProfile = true;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Private Classes
|
|
private class ProfileList
|
|
{
|
|
internal bool NoProfile = false;
|
|
internal Set<CacheItem> Profiles = new Set<CacheItem>(5);
|
|
}
|
|
|
|
private class CacheItem : IComparable
|
|
{
|
|
internal RTTrackingProfile TrackingProfile = null;
|
|
internal DateTime LastAccess = DateTime.UtcNow;
|
|
//
|
|
// VersionId and ScheduleType are stored separately from the profile so that they
|
|
// can be used to identify the profile if it has been pushed from the cache.
|
|
internal Version VersionId = new Version(0, 0);
|
|
internal Type ScheduleType = null;
|
|
|
|
internal CacheItem()
|
|
{
|
|
}
|
|
|
|
internal CacheItem(RTTrackingProfile profile)
|
|
{
|
|
if (null == profile)
|
|
throw new ArgumentNullException("profile");
|
|
|
|
ScheduleType = profile.WorkflowType;
|
|
|
|
this.TrackingProfile = profile;
|
|
VersionId = profile.Version;
|
|
}
|
|
|
|
internal CacheItem(Type workflowType, Version versionId)
|
|
{
|
|
VersionId = versionId;
|
|
ScheduleType = workflowType;
|
|
}
|
|
|
|
#region IComparable Members
|
|
|
|
public int CompareTo(object obj)
|
|
{
|
|
if (!(obj is CacheItem))
|
|
throw new ArgumentException(ExecutionStringManager.InvalidCacheItem);
|
|
|
|
CacheItem item = (CacheItem)obj;
|
|
if ((VersionId == item.VersionId) && (ScheduleType == item.ScheduleType))
|
|
return 0;
|
|
else
|
|
return (VersionId > item.VersionId) ? 1 : -1;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
/// <summary>
|
|
/// Represents a wrapper around a channel and its artifacts, such as its tracking service type and profile
|
|
/// </summary>
|
|
internal class TrackingChannelWrapper
|
|
{
|
|
private Type _serviceType = null, _scheduleType = null;
|
|
private TrackingChannel _channel = null;
|
|
[NonSerialized]
|
|
private RTTrackingProfile _profile = null;
|
|
private Version _profileVersionId;
|
|
|
|
private TrackingChannelWrapper() { }
|
|
|
|
public TrackingChannelWrapper(TrackingChannel channel, Type serviceType, Type workflowType, RTTrackingProfile profile)
|
|
{
|
|
_serviceType = serviceType;
|
|
_scheduleType = workflowType;
|
|
_channel = channel;
|
|
_profile = profile;
|
|
_profileVersionId = profile.Version;
|
|
}
|
|
|
|
internal Type TrackingServiceType
|
|
{
|
|
get { return _serviceType; }
|
|
}
|
|
|
|
internal TrackingChannel TrackingChannel
|
|
{
|
|
get { return _channel; }
|
|
}
|
|
/// <summary>
|
|
/// Get the tracking profile for the channel
|
|
/// </summary>
|
|
/// <param name="exec">BaseExecutor</param>
|
|
/// <returns>RTTrackingProfile</returns>
|
|
internal RTTrackingProfile GetTrackingProfile(WorkflowExecutor skedExec)
|
|
{
|
|
if (null != _profile)
|
|
return _profile;
|
|
else
|
|
throw new InvalidOperationException(String.Format(System.Globalization.CultureInfo.CurrentCulture, ExecutionStringManager.NullProfileForChannel, this._scheduleType.AssemblyQualifiedName));
|
|
}
|
|
|
|
internal void SetTrackingProfile(RTTrackingProfile profile)
|
|
{
|
|
_profile = profile;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clone the tracking profile stored in the cache and
|
|
/// </summary>
|
|
/// <param name="exec"></param>
|
|
internal void MakeProfilePrivate(WorkflowExecutor exec)
|
|
{
|
|
if (null != _profile)
|
|
{
|
|
//
|
|
// If the profile is not already a private copy make it so
|
|
if (!_profile.IsPrivate)
|
|
{
|
|
_profile = _profile.Clone();
|
|
_profile.IsPrivate = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We're not holding a reference to a profile
|
|
// so get it from the cache and clone it into a private copy
|
|
RTTrackingProfile tmp = GetTrackingProfile(exec);
|
|
_profile = tmp.Clone();
|
|
_profile.IsPrivate = true;
|
|
}
|
|
}
|
|
}
|
|
internal class Set<T> : IEnumerable<T> where T : IComparable
|
|
{
|
|
List<T> list = null;
|
|
|
|
public Set()
|
|
{
|
|
list = new List<T>();
|
|
}
|
|
|
|
public Set(int capacity)
|
|
{
|
|
list = new List<T>(capacity);
|
|
}
|
|
|
|
public int Count
|
|
{
|
|
get { return list.Count; }
|
|
}
|
|
|
|
public void Add(T item)
|
|
{
|
|
int pos = -1;
|
|
if (!Search(item, out pos))
|
|
list.Insert(pos, item);
|
|
else
|
|
throw new ArgumentException(ExecutionStringManager.ItemAlreadyExist);
|
|
}
|
|
|
|
public bool TryAdd(T item)
|
|
{
|
|
int pos = -1;
|
|
if (!Search(item, out pos))
|
|
{
|
|
list.Insert(pos, item);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool Contains(T item)
|
|
{
|
|
int pos = -1;
|
|
return Search(item, out pos);
|
|
}
|
|
|
|
public IEnumerator<T> GetEnumerator()
|
|
{
|
|
return list.GetEnumerator();
|
|
}
|
|
|
|
System.Collections.IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return list.GetEnumerator();
|
|
}
|
|
|
|
public bool TryGetValue(T item, out T value)
|
|
{
|
|
int pos = -1;
|
|
if (Search(item, out pos))
|
|
{
|
|
value = list[pos];
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
value = default(T);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public T this[int index]
|
|
{
|
|
get { return list[index]; }
|
|
}
|
|
|
|
private bool Search(T item, out int insertPos)
|
|
{
|
|
insertPos = -1;
|
|
|
|
int pos = 0,
|
|
high = list.Count,
|
|
low = -1,
|
|
diff = 0;
|
|
|
|
while (high - low > 1)
|
|
{
|
|
pos = (high + low) / 2;
|
|
|
|
diff = list[pos].CompareTo(item);
|
|
|
|
if (0 == diff)
|
|
{
|
|
insertPos = pos;
|
|
return true;
|
|
}
|
|
else if (diff > 0)
|
|
high = pos;
|
|
else
|
|
low = pos;
|
|
}
|
|
|
|
if (low == -1)
|
|
{
|
|
insertPos = 0;
|
|
return false;
|
|
}
|
|
|
|
if (0 != diff)
|
|
{
|
|
insertPos = (diff < 0) ? pos + 1 : pos;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Persisted tracking State pertaining to workflow invoking for an individual schedule. There could be multiple called schedules under
|
|
/// an instance.
|
|
/// </summary>
|
|
[Serializable]
|
|
internal class TrackingCallingState
|
|
{
|
|
#region data members
|
|
private IList<string> callerActivityPathProxy;
|
|
private Guid callerInstanceId;
|
|
private Guid callerContextGuid;
|
|
private Guid callerParentContextGuid;
|
|
|
|
#endregion data members
|
|
|
|
#region Property accessors
|
|
|
|
/// <summary>
|
|
/// Activity proxy of the caller/execer activity, if any
|
|
/// //@@Undone for Ashishmi: Hold on to ActivityPath Proxy in one of your class impl
|
|
/// </summary>
|
|
/// <value></value>
|
|
internal IList<string> CallerActivityPathProxy
|
|
{
|
|
get { return callerActivityPathProxy; }
|
|
set { callerActivityPathProxy = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Instance ID of the caller/exec'er schedule, if any
|
|
/// </summary>
|
|
/// <value></value>
|
|
public Guid CallerWorkflowInstanceId
|
|
{
|
|
get { return callerInstanceId; }
|
|
set { callerInstanceId = value; }
|
|
}
|
|
/// <summary>
|
|
/// Context of the caller's invoke activity
|
|
/// </summary>
|
|
/// <value>int</value>
|
|
public Guid CallerContextGuid
|
|
{
|
|
get { return callerContextGuid; }
|
|
set { callerContextGuid = value; }
|
|
}
|
|
/// <summary>
|
|
/// ParentContext of the caller's invoke activity
|
|
/// </summary>
|
|
/// <value>int</value>
|
|
public Guid CallerParentContextGuid
|
|
{
|
|
get { return callerParentContextGuid; }
|
|
set { callerParentContextGuid = value; }
|
|
}
|
|
|
|
#endregion Property accessors
|
|
|
|
}
|
|
|
|
internal static class HashHelper
|
|
{
|
|
internal static Guid HashServiceType(Type serviceType)
|
|
{
|
|
return HashServiceType(serviceType.AssemblyQualifiedName);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Cryptographic.Standard", "CA5350:MD5CannotBeUsed",
|
|
Justification = "Design has been approved. We are not using MD5 for any security or cryptography purposes but rather as a hash.")]
|
|
internal static Guid HashServiceType(String serviceFullTypeName)
|
|
{
|
|
byte[] data;
|
|
byte[] result;
|
|
|
|
UnicodeEncoding ue = new UnicodeEncoding();
|
|
data = ue.GetBytes(serviceFullTypeName);
|
|
|
|
if (AppSettings.FIPSRequired)
|
|
{
|
|
result = MD5PInvokeHelper.CalculateHash(data);
|
|
}
|
|
else
|
|
{
|
|
MD5 md5 = new MD5CryptoServiceProvider();
|
|
result = md5.ComputeHash(data);
|
|
}
|
|
|
|
return new Guid(result);
|
|
}
|
|
}
|
|
}
|