public void UnregisterForQueueItemAvailable(IActivityEventListener<QueueEventArgs> eventListener) { if (eventListener == null) throw new ArgumentNullException("eventListener"); lock (qService.SyncRoot) { ActivityExecutorDelegateInfo<QueueEventArgs> subscriber = new ActivityExecutorDelegateInfo<QueueEventArgs>(eventListener, qService.CallingActivity); bool removed = qService.GetQueueState(this.queueName).AsynchronousListeners.Remove(subscriber); if (!removed) { WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "WorkflowQueue:QueueItemAvailable unsubscribe failed for activity '{0}' with context Id {1}", subscriber.ActivityQualifiedName, subscriber.ContextId); } } }
public void SubscribeForCorrelationTokenInitializedEvent(Activity activity, IActivityEventListener<CorrelationTokenEventArgs> dataChangeListener) { if (dataChangeListener == null) { throw new ArgumentNullException("dataChangeListener"); } if (activity == null) { throw new ArgumentNullException("activity"); } ActivityExecutorDelegateInfo<CorrelationTokenEventArgs> item = new ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>(dataChangeListener, ContextActivityUtils.ContextActivity(activity), true); IList<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>> list = base.GetValue(SubscriptionsProperty) as IList<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>>; if (list == null) { list = new List<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>>(); base.SetValue(SubscriptionsProperty, list); } list.Add(item); }
public void RegisterForQueueItemAvailable(IActivityEventListener<QueueEventArgs> eventListener, string subscriberQualifiedName) { if (eventListener == null) throw new ArgumentNullException("eventListener"); lock (qService.SyncRoot) { EventQueueState qState = qService.GetQueueState(this.queueName); ActivityExecutorDelegateInfo<QueueEventArgs> subscriber = new ActivityExecutorDelegateInfo<QueueEventArgs>(eventListener, qService.CallingActivity); if (subscriberQualifiedName != null) { subscriber.SubscribedActivityQualifiedName = subscriberQualifiedName; } qState.AsynchronousListeners.Add(subscriber); WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "WorkflowQueue:QueueItemAvailable subscribe for activity '{0}' with context Id {1}", subscriber.ActivityQualifiedName, subscriber.ContextId); if (qState.AsynchronousListeners.Count == 1) qService.NotifyAsynchronousSubscribers(this.queueName, qState, qState.Messages.Count); } }
internal static bool Subscribe(IServiceProvider context, Activity activity, Type interfaceType, string methodName, IActivityEventListener<QueueEventArgs> eventListener, Guid instanceId) { if (activity == null) throw new ArgumentNullException("activity"); if (interfaceType == null) throw new ArgumentNullException("interfaceType"); if (methodName == null) throw new ArgumentNullException("methodName"); WorkflowQueuingService queueService = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService)); IComparable queueName = ResolveQueueName(activity, interfaceType, methodName); if (queueName != null) { // initializer WorkflowQueue queue = null; if (queueService.Exists(queueName)) { queue = queueService.GetWorkflowQueue(queueName); queue.Enabled = true; } else { queue = queueService.CreateWorkflowQueue(queueName, true); } if (eventListener != null) { queue.RegisterForQueueItemAvailable(eventListener, activity.QualifiedName); WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "CorrelationService: activity '{0}' subscribing to QueueItemAvailable", activity.QualifiedName); return true; } return false; } SubscribeForCorrelationTokenInvalidation(activity, interfaceType, methodName, eventListener, instanceId); return false; }
public void UnsubscribeFromCorrelationTokenInitializedEvent(Activity activity, IActivityEventListener <CorrelationTokenEventArgs> dataChangeListener) { }
internal static bool Unsubscribe(IServiceProvider context, Activity activity, Type interfaceType, string methodName, IActivityEventListener<QueueEventArgs> eventListener) { if (activity == null) throw new ArgumentException("activity"); if (interfaceType == null) throw new ArgumentNullException("interfaceType"); if (methodName == null) throw new ArgumentNullException("methodName"); WorkflowQueuingService queueService = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService)); IComparable queueName = ResolveQueueName(activity, interfaceType, methodName); if (queueName != null) { if (queueService.Exists(queueName)) { queueService.GetWorkflowQueue(queueName).UnregisterForQueueItemAvailable(eventListener); return true; } } return false; }
public void UnregisterForQueueItemArrived(IActivityEventListener <QueueEventArgs> eventListener) { }
private static bool TryCompensateLastCompletedChildActivity(ActivityExecutionContext context, Activity targetActivity, IActivityEventListener<ActivityExecutionStatusChangedEventArgs> statusChangeHandler, bool isimmediateCompensation) { SortedDictionary<int, CompensationInfo> sortedListOfCompensatableTargets = new SortedDictionary<int, CompensationInfo>(); if (targetActivity is CompositeActivity) { if (CollectCompensatableTargetActivities(targetActivity as CompositeActivity, sortedListOfCompensatableTargets, isimmediateCompensation)) { return true; } if (CollectCompensatableActiveContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation)) { return true; } CollectCompensatableCompletedContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation); if (sortedListOfCompensatableTargets.Count == 0) { CompleteRevokedExecutionContext(targetActivity, context); return false; } int? nullable = targetActivity.GetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty) as int?; int num = -1; CompensationInfo info = null; foreach (int num2 in sortedListOfCompensatableTargets.Keys) { if (nullable.HasValue) { int? nullable2 = nullable; int num3 = num2; if ((nullable2.GetValueOrDefault() < num3) && nullable2.HasValue) { break; } } info = sortedListOfCompensatableTargets[num2]; num = num2; } if (info == null) { CompleteRevokedExecutionContext(targetActivity, context); return false; } targetActivity.SetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty, num); if ((info.TargetActivity != null) && (info.TargetActivity is ICompensatableActivity)) { info.TargetActivity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler); context.CompensateActivity(info.TargetActivity); return true; } if ((info.TargetExecutionInfo != null) && (info.TargetExecutionContextManager != null)) { ActivityExecutionContext context2 = info.TargetExecutionContextManager.DiscardPersistedExecutionContext(info.TargetExecutionInfo); if (context2.Activity is ICompensatableActivity) { context2.Activity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler); context2.CompensateActivity(context2.Activity); return true; } if (context2.Activity is CompositeActivity) { Activity lastCompensatableChild = GetLastCompensatableChild(context2.Activity as CompositeActivity); if (lastCompensatableChild != null) { lastCompensatableChild.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler); context2.CompensateActivity(lastCompensatableChild); return true; } return TryCompensateLastCompletedChildActivity(context2, context2.Activity, statusChangeHandler, false); } } else if ((info.TargetExecutionContext != null) && (info.TargetExecutionContext.Activity is CompositeActivity)) { Activity activity = GetLastCompensatableChild(info.TargetExecutionContext.Activity as CompositeActivity); if (activity != null) { activity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler); info.TargetExecutionContext.CompensateActivity(activity); return true; } return TryCompensateLastCompletedChildActivity(info.TargetExecutionContext, info.TargetExecutionContext.Activity, statusChangeHandler, false); } } return false; }
public void UnregisterForQueueItemArrived (IActivityEventListener<QueueEventArgs> eventListener) { }
public void RegisterForQueueItemAvailable (IActivityEventListener<QueueEventArgs> eventListener) { }
public void RegisterForQueueItemAvailable(IActivityEventListener <QueueEventArgs> eventListener) { RegisterForQueueItemAvailable(eventListener, null); }
internal CorrelationTokenInvalidatedHandler(Type interfaceType, string operation, IActivityEventListener <QueueEventArgs> eventHandler, Guid instanceId) { this.eventHandler = eventHandler; this.interfaceType = interfaceType; this.followerOperation = operation; this.instanceId = instanceId; }
public void UnregisterForQueueItemArrived(IActivityEventListener<QueueEventArgs> eventListener) { if (eventListener == null) throw new ArgumentNullException("eventListener"); lock (qService.SyncRoot) { qService.GetQueueState(this.queueName).SynchronousListeners.Remove(new ActivityExecutorDelegateInfo<QueueEventArgs>(eventListener, qService.CallingActivity)); } }
public void UnsubscribeFromCorrelationTokenInitializedEvent(Activity activity, IActivityEventListener <CorrelationTokenEventArgs> dataChangeListener) { if (dataChangeListener == null) { throw new ArgumentNullException("dataChangeListener"); } if (activity == null) { throw new ArgumentNullException("activity"); } ActivityExecutorDelegateInfo <CorrelationTokenEventArgs> subscriber = new ActivityExecutorDelegateInfo <CorrelationTokenEventArgs>(dataChangeListener, ContextActivityUtils.ContextActivity(activity), true); IList <ActivityExecutorDelegateInfo <CorrelationTokenEventArgs> > subscriptions = GetValue(SubscriptionsProperty) as IList <ActivityExecutorDelegateInfo <CorrelationTokenEventArgs> >; if (subscriptions != null) { subscriptions.Remove(subscriber); } }
public void UnregisterForQueueItemAvailable(IActivityEventListener <QueueEventArgs> eventListener) { }
internal static bool Unsubscribe(IServiceProvider context, Activity activity, Type interfaceType, string methodName, IActivityEventListener <QueueEventArgs> eventListener) { if (activity == null) { throw new ArgumentException("activity"); } if (interfaceType == null) { throw new ArgumentNullException("interfaceType"); } if (methodName == null) { throw new ArgumentNullException("methodName"); } WorkflowQueuingService queueService = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService)); IComparable queueName = ResolveQueueName(activity, interfaceType, methodName); if (queueName != null) { if (queueService.Exists(queueName)) { queueService.GetWorkflowQueue(queueName).UnregisterForQueueItemAvailable(eventListener); return(true); } } return(false); }
public ActivityExecutorDelegateInfo(IActivityEventListener <T> eventListener, Activity contextActivity) : this(false, eventListener, contextActivity) { }
private static void SubscribeForCorrelationTokenInvalidation(Activity activity, Type interfaceType, string followermethodName, IActivityEventListener <QueueEventArgs> eventListener, Guid instanceId) { CorrelationToken reference = GetCorrelationToken(activity); CorrelationTokenInvalidatedHandler dataChangeEventListener = new CorrelationTokenInvalidatedHandler(interfaceType, followermethodName, eventListener, instanceId); reference.SubscribeForCorrelationTokenInitializedEvent(activity, dataChangeEventListener); }
public void RegisterForQueueItemAvailable (IActivityEventListener<QueueEventArgs> eventListener, string subscriberQualifiedName) { }
internal static bool Subscribe(IServiceProvider context, Activity activity, Type interfaceType, string methodName, IActivityEventListener <QueueEventArgs> eventListener, Guid instanceId) { if (activity == null) { throw new ArgumentNullException("activity"); } if (interfaceType == null) { throw new ArgumentNullException("interfaceType"); } if (methodName == null) { throw new ArgumentNullException("methodName"); } WorkflowQueuingService queueService = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService)); IComparable queueName = ResolveQueueName(activity, interfaceType, methodName); if (queueName != null) { // initializer WorkflowQueue queue = null; if (queueService.Exists(queueName)) { queue = queueService.GetWorkflowQueue(queueName); queue.Enabled = true; } else { queue = queueService.CreateWorkflowQueue(queueName, true); } if (eventListener != null) { queue.RegisterForQueueItemAvailable(eventListener, activity.QualifiedName); WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "CorrelationService: activity '{0}' subscribing to QueueItemAvailable", activity.QualifiedName); return(true); } return(false); } SubscribeForCorrelationTokenInvalidation(activity, interfaceType, methodName, eventListener, instanceId); return(false); }
internal static bool TryCompensateLastCompletedChildActivity(ActivityExecutionContext context, Activity targetActivity, IActivityEventListener<ActivityExecutionStatusChangedEventArgs> statusChangeHandler) { bool flag; try { flag = TryCompensateLastCompletedChildActivity(context, targetActivity, statusChangeHandler, true); } catch (Exception) { if (targetActivity.Parent == null) { CompleteRevokedExecutionContext(targetActivity, context); } throw; } return flag; }
private static void SubscribeForCorrelationTokenInvalidation(Activity activity, Type interfaceType, string followermethodName, IActivityEventListener<QueueEventArgs> eventListener, Guid instanceId) { CorrelationToken reference = GetCorrelationToken(activity); CorrelationTokenInvalidatedHandler dataChangeEventListener = new CorrelationTokenInvalidatedHandler(interfaceType, followermethodName, eventListener, instanceId); reference.SubscribeForCorrelationTokenInitializedEvent(activity, dataChangeEventListener); }
public void UnsubscribeFromCorrelationTokenInitializedEvent (Activity activity, IActivityEventListener<CorrelationTokenEventArgs> dataChangeListener) { }
public void RegisterForQueueItemAvailable(IActivityEventListener <QueueEventArgs> eventListener, string subscriberQualifiedName) { }