protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } if (this.Fault == null) { throw new InvalidOperationException(SR.GetString(CultureInfo.CurrentCulture, "Error_PropertyNotSet", new object[] { FaultProperty.Name })); } WorkflowQueuingService service = executionContext.GetService <WorkflowQueuingService>(); base.RaiseEvent(SendingFaultEvent, this, EventArgs.Empty); WebServiceInputActivity activityByName = base.GetActivityByName(this.InputActivityName) as WebServiceInputActivity; IComparable queueName = new EventQueueName(activityByName.InterfaceType, activityByName.MethodName, activityByName.QualifiedName); IMethodResponseMessage message = null; WorkflowQueue workflowQueue = service.GetWorkflowQueue(queueName); if (workflowQueue.Count != 0) { message = workflowQueue.Dequeue() as IMethodResponseMessage; } message.SendException(this.Fault); return(ActivityExecutionStatus.Closed); }
private bool ProcessQueueItem(ActivityExecutionContext context) { WorkflowQueuingService qService = context.GetService <WorkflowQueuingService>(); if (!qService.Exists(this.QueueName)) { return(false); } WorkflowQueue queue = qService.GetWorkflowQueue(this.QueueName); // If the queue has messages, then process the first one if (queue.Count == 0) { return(false); } FileWatcherEventArgs e = (FileWatcherEventArgs)queue.Dequeue(); // Raise the FileSystemEvent base.RaiseGenericEvent <FileWatcherEventArgs>(FileSystemEvent.FileWatcherEventHandlerEvent, this, e); DoUnsubscribe(context, this); DeleteQueue(context); return(true); }
protected override void Initialize(IServiceProvider provider) { if (provider == null) { throw new ArgumentNullException("provider"); } if (this.Parent != null) { throw new InvalidOperationException("This is a root Activity"); } _queueName = new EventQueueName(this.Type, this.MethodName); WorkflowQueuingService queueService = (WorkflowQueuingService)provider.GetService(typeof(WorkflowQueuingService)); if (queueService != null) { WorkflowQueue queue = null; if (queueService.Exists(_queueName)) { queue = queueService.GetWorkflowQueue(_queueName); queue.Enabled = true; } else { queue = queueService.CreateWorkflowQueue(_queueName, true); } } base.Initialize(provider); }
internal override void Execute(ActivityExecutionContext context) { base.Execute(context); StateActivity rootState = StateMachineHelpers.GetRootState(base.State); Queue <StateActivity> queue = new Queue <StateActivity>(); queue.Enqueue(rootState); while (queue.Count > 0) { foreach (Activity activity3 in queue.Dequeue().EnabledActivities) { EventDrivenActivity eventDriven = activity3 as EventDrivenActivity; if (eventDriven != null) { IComparable queueName = StateMachineHelpers.GetEventActivity(eventDriven).QueueName; if (queueName != null) { WorkflowQueue workflowQueue = StateMachineSubscriptionManager.GetWorkflowQueue(context, queueName); if (workflowQueue != null) { workflowQueue.Enabled = base.SubscriptionManager.Subscriptions.ContainsKey(queueName); } } } else { StateActivity item = activity3 as StateActivity; if (item != null) { queue.Enqueue(item); } } } } }
internal void Unsubscribe(ActivityExecutionContext context) { WorkflowQueuingService workflowQueuingService = context.GetService <WorkflowQueuingService>(); WorkflowQueue workflowQueue = workflowQueuingService.GetWorkflowQueue(StateMachineWorkflowActivity.SetStateQueueName); workflowQueue.UnregisterForQueueItemAvailable(this); }
void q_QueueItemAvailable(object sender, QueueEventArgs e) { ActivityExecutionContext aec = sender as ActivityExecutionContext; if (aec != null) { WorkflowQueuingService qs = aec.GetService <WorkflowQueuingService>(); WorkflowQueue q = qs.GetWorkflowQueue(e.QueueName); //get the outparameters from the workflow object o = q.Dequeue(); //delete the queue qs.DeleteWorkflowQueue(e.QueueName); Dictionary <string, object> outparams = o as Dictionary <string, object>; if (outparams != null) { foreach (KeyValuePair <string, object> item in outparams) { if (this.Parameters.Contains(item.Key)) { //modify the value this.Parameters[item.Key].SetValue(WorkflowParameterBinding.ValueProperty, item.Value); } } } aec.CloseActivity(); } }
public async Task HandleWorkflowsUntilPunctuation(Immutable <IndexWorkflowRecordNode> workflowRecords) { try { var workflows = workflowRecords.Value; while (workflows != null) { Dictionary <IIndexableGrain, HashSet <Guid> > grainsToActiveWorkflows = null; if (IsFaultTolerant) { grainsToActiveWorkflows = await GetActiveWorkflowsListsFromGrains(workflows); } var updatesToIndexes = CreateAMapForUpdatesToIndexes(); PopulateUpdatesToIndexes(workflows, updatesToIndexes, grainsToActiveWorkflows); await Task.WhenAll(PrepareIndexUpdateTasks(updatesToIndexes)); if (IsFaultTolerant) { Task.WhenAll(RemoveFromActiveWorkflowsInGrainsTasks(grainsToActiveWorkflows)).Ignore(); } workflows = (await WorkflowQueue.GiveMoreWorkflowsOrSetAsIdle()).Value; } } catch (Exception e) { throw e; } }
protected override ActivityExecutionStatus Execute(ActivityExecutionContext aec) { //get the services needed //custom service to run the workflow CallWorkflowService ws = aec.GetService <CallWorkflowService>(); //Queuing service to setup the queue so the service can "callback" WorkflowQueuingService qs = aec.GetService <WorkflowQueuingService>(); //create the queue the service can call back on when the child workflow is done //you might want the queuename to be something different string qn = String.Format("{0}:{1}:{2}", this.WorkflowInstanceId.ToString(), Type.Name, this.Name); WorkflowQueue q = qs.CreateWorkflowQueue(qn, false); q.QueueItemAvailable += new EventHandler <QueueEventArgs>(q_QueueItemAvailable); //copy the params to a new collection Dictionary <string, object> inparams = new Dictionary <string, object>(); foreach (WorkflowParameterBinding bp in this.Parameters) { PropertyInfo pi = Type.GetProperty(bp.ParameterName); if (pi.CanWrite) { inparams.Add(bp.ParameterName, bp.Value); } } //ask the service to start the workflow ws.StartWorkflow(Type, inparams, this.WorkflowInstanceId, qn); return(ActivityExecutionStatus.Executing); }
private static void CreateFollowerEntry(IServiceProvider context, Type interfaceType, string followermethodName, string initializermethodName) { if (!CorrelationResolver.IsInitializingMember(interfaceType, initializermethodName, null)) { return; } WorkflowQueuingService queueSvcs = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService)); FollowerQueueCreator follower = new FollowerQueueCreator(followermethodName); WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "Creating follower {0} on initializer {1}", interfaceType.Name + followermethodName, interfaceType.Name + initializermethodName); ICollection <CorrelationProperty> corrValues = CorrelationResolver.ResolveCorrelationValues(interfaceType, initializermethodName, null, true); EventQueueName key = new EventQueueName(interfaceType, initializermethodName, corrValues); WorkflowQueue initializerQueue = null; if (queueSvcs.Exists(key)) { initializerQueue = queueSvcs.GetWorkflowQueue(key); } else { // traversed follower before initializer initializerQueue = queueSvcs.CreateWorkflowQueue(key, true); initializerQueue.Enabled = false; } initializerQueue.RegisterForQueueItemArrived(follower); }
public async Task RunAsync(TimeSpan delay) { var delayStub = Workflow.NewLocalActivityStub <ISignalBlastDelayActivity, SignalBlastDelayActivity>(); signalQueue = await Workflow.NewQueueAsync <SignalRequest <string> >(int.MaxValue); // Process messages until we get one that passes NULL. while (true) { var signalRequest = await signalQueue.DequeueAsync(); var name = signalRequest.Arg <string>("name"); var reply = (string)null; if (name != null) { reply = $"Hello {name}!"; if (delay > TimeSpan.Zero) { await delayStub.DelayAsync(delay); } } await signalRequest.ReplyAsync(reply); if (name == null) { break; } } }
/// <summary> /// Unsubscribes to item available. /// </summary> /// <param name="ctx">The CTX.</param> protected void UnsubscribeFromQueueItemAvailable(ActivityExecutionContext ctx) { WorkflowQueue queue = GetQueue(ctx); queue.UnregisterForQueueItemAvailable(this); queue.QueuingService.DeleteWorkflowQueue(this.Name); }
public async Task <string> HelloAsync() { signalQueue = await Workflow.NewQueueAsync <string>(); var name = await signalQueue.DequeueAsync(); return($"Hello {name}!"); }
protected override void Initialize(IServiceProvider provider) { ThreadMonitor.WriteToConsole(Thread.CurrentThread, "WaitForMessageActivity", "WaitForMessageActivity: Processed Initialization"); WorkflowQueuingService queuingService = (WorkflowQueuingService)provider.GetService(typeof(WorkflowQueuingService)); this.workflowQueue = queuingService.CreateWorkflowQueue("WaitForMessageActivityQueue", false); this.workflowQueue.QueueItemAvailable += this.HandleExternalEvent; }
void IEventActivity.Unsubscribe(ActivityExecutionContext parentContext, IActivityEventListener <QueueEventArgs> parentEventHandler) { WorkflowQueuingService queueService = parentContext.GetService <WorkflowQueuingService>(); if (_queueName != null && queueService != null && parentEventHandler != null) { WorkflowQueue queue = queueService.GetWorkflowQueue(_queueName); queue.UnregisterForQueueItemAvailable(parentEventHandler); } }
private Boolean DoSubscribe(ActivityExecutionContext context, IActivityEventListener <QueueEventArgs> listener) { WorkflowQueue queue = CreateQueue(context); queue.RegisterForQueueItemAvailable(listener); FileWatcherService fileService = context.GetService <FileWatcherService>(); this.subscriptionId = fileService.RegisterListener(this.QueueName, this.Path, this.Filter, this.NotifyFilter, this.IncludeSubdirectories); return(subscriptionId != Guid.Empty); }
public async Task RunResultAsync() { resultQueue = await Workflow.NewQueueAsync <SignalRequest <string> >(); var signalRequest = await resultQueue.DequeueAsync(); SignalProcessed = true; Name = signalRequest.Arg <string>("name"); await signalRequest.ReplyAsync($"Hello {Name}!"); }
public async Task RunVoidAsync() { voidQueue = await Workflow.NewQueueAsync <SignalRequest>(); var signalRequest = await voidQueue.DequeueAsync(); SignalProcessed = true; Name = signalRequest.Arg <string>("name"); await signalRequest.ReplyAsync(); }
internal static WorkflowQueue GetWorkflowQueue(ActivityExecutionContext context, IComparable queueName) { WorkflowQueuingService workflowQueuingService = context.GetService <WorkflowQueuingService>(); if (workflowQueuingService.Exists(queueName)) { WorkflowQueue workflowQueue = workflowQueuingService.GetWorkflowQueue(queueName); return(workflowQueue); } return(null); }
private void CreateSubscription(Guid instanceId, ActivityExecutionContext context, ICollection <CorrelationProperty> correlationValues) { WorkflowQueuingService queueSvcs = context.GetService <WorkflowQueuingService>(); EventQueueName queueId = new EventQueueName(this.interfaceType, this.followerOperation, correlationValues); WorkflowQueue workflowQueue = null; if (!queueSvcs.Exists(queueId)) { WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "CorrelationTokenInvalidatedHandler: creating q {0} ", queueId.GetHashCode()); workflowQueue = queueSvcs.CreateWorkflowQueue(queueId, true); queueCreator = true; } else { workflowQueue = queueSvcs.GetWorkflowQueue(queueId); } if (this.eventHandler != null) { workflowQueue.RegisterForQueueItemAvailable(this.eventHandler); } WorkflowSubscriptionService subscriptionService = (WorkflowSubscriptionService)context.GetService(typeof(WorkflowSubscriptionService)); MessageEventSubscription subscription = new MessageEventSubscription(queueId, instanceId); this.queueName = queueId; this.subscriptionId = subscription.SubscriptionId; subscription.InterfaceType = this.interfaceType; subscription.MethodName = this.followerOperation; this.interfaceType = null; this.followerOperation = null; if (correlationValues != null) { foreach (CorrelationProperty property in correlationValues) { subscription.CorrelationProperties.Add(property); } } if (this.eventHandler != null) { return; } if (subscriptionService == null) { return; } subscriptionService.CreateSubscription(subscription); }
public virtual WorkflowBase GetNextWorkflow() { if (WorkflowQueue.Count == 0) { return(null); } var wftype = WorkflowQueue.Dequeue(); var wf = CreateInstance <WorkflowBase>(wftype); return(wf); }
internal static void ChangeEventDrivenQueueState(ActivityExecutionContext context, EventDrivenActivity eventDriven, bool enabled) { IComparable queueName = GetQueueName(StateMachineHelpers.GetEventActivity(eventDriven)); if (queueName != null) { WorkflowQueue workflowQueue = GetWorkflowQueue(context, queueName); if (workflowQueue != null) { workflowQueue.Enabled = enabled; } } }
/// <summary> /// Queues the item available. /// </summary> /// <param name="ctx">The CTX.</param> protected ActivityExecutionStatus ProcessQueueElement(ActivityExecutionContext ctx) { WorkflowQueue queue = GetQueue(ctx); AssignmentEntity assignment = queue.Dequeue() as AssignmentEntity; if (assignment != null) { return(CheckAssignmentCompletion(assignment)); } return(ActivityExecutionStatus.Executing); }
/// <summary> /// Executes the activity. /// </summary> /// <param name="executionContext">The execution context.</param> /// <returns>The <see cref="ActivityExecutionStatus"/> object.</returns> protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { Logger.Instance.WriteMethodEntry(EventIdentifier.AsyncUpdateResourceExecute); try { // Ideally we would set CallContext in OnActivityExecutionContextLoad instead here in Execute // as OnActivityExecutionContextLoad gets called on each hydration and rehydration of the workflow instance // but looks like it's invoked on a different thread context than the rest of the workflow instance execution. // To minimize the loss of the CallContext on rehydration, we'll set it in the Execute of every WAL child activities. // It will still get lost (momentarily) when the workflow is persisted in the middle of the execution of a replicator activity, for example. Logger.SetContextItem(this, this.WorkflowInstanceId); SequentialWorkflow parentWorkflow; if (!SequentialWorkflow.TryGetContainingWorkflow(this, out parentWorkflow)) { throw Logger.Instance.ReportError(new InvalidOperationException(Messages.UnableToGetParentWorkflowError)); } // Create the workflow program queue so we can facilitate asynchronous // submission of requests WorkflowQueue queue = CreateWorkflowProgramQueue(this.queuingService, this); object[] args = new object[] { this.ActorId, this.ResourceId, this.UpdateParameters, parentWorkflow.RequestId, this.ApplyAuthorizationPolicy, 0, queue.QueueName }; Logger.Instance.WriteVerbose(EventIdentifier.AsyncUpdateResourceExecute, "Invoking DataAccessService.Update() for ActorId: '{0}', ResourceId: '{1}', ParentRequestId: '{3}' ApplyAuthorizationPolicy: '{4}' and QueueName: '{6}'.", args); // Submit the request via reflection and cleanup the queue // Added the AuthorizationTimeOut value of 0, which is "Fire and Forget" this.dataAccessServiceType.InvokeMember( "Update", BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance, null, this.dataAccessService, args, CultureInfo.InvariantCulture); DeleteWorkflowProgramQueue(this.queuingService, queue); return(base.Execute(executionContext)); } catch (Exception ex) { throw Logger.Instance.ReportError(EventIdentifier.AsyncUpdateResourceExecuteError, ex); } finally { Logger.Instance.WriteMethodExit(EventIdentifier.AsyncUpdateResourceExecute); } }
public async Task DoItAsync() { signalQueue = await Workflow.NewQueueAsync <string>(); while (true) { state = await signalQueue.DequeueAsync(); if (state == "done") { break; } } }
private void DoUnsubscribe(ActivityExecutionContext context, IActivityEventListener <QueueEventArgs> listener) { if (!this.subscriptionId.Equals(Guid.Empty)) { FileWatcherService fileService = context.GetService <FileWatcherService>(); fileService.UnregisterListener(this.subscriptionId); this.subscriptionId = Guid.Empty; } WorkflowQueuingService qService = context.GetService <WorkflowQueuingService>(); WorkflowQueue queue = qService.GetWorkflowQueue(this.QueueName); queue.UnregisterForQueueItemAvailable(listener); }
void IEventActivity.Unsubscribe(ActivityExecutionContext parentContext, IActivityEventListener <QueueEventArgs> parentEventHandler) { if (parentContext == null) { throw new ArgumentNullException("parentContext"); } if (parentEventHandler == null) { throw new ArgumentNullException("parentEventHandler"); } System.Diagnostics.Debug.Assert(this.SubscriptionID != Guid.Empty); WorkflowQueuingService qService = parentContext.GetService <WorkflowQueuingService>(); WorkflowQueue wfQueue = null; try { wfQueue = qService.GetWorkflowQueue(this.SubscriptionID); } catch { // If the queue no longer exists, eat the exception, we clear the subscription id later. } if (wfQueue != null && wfQueue.Count != 0) { wfQueue.Dequeue(); } // WinOE Activity root = parentContext.Activity; while (root.Parent != null) { root = root.Parent; } TimerEventSubscriptionCollection timers = (TimerEventSubscriptionCollection)root.GetValue(TimerEventSubscriptionCollection.TimerCollectionProperty); Debug.Assert(timers != null, "TimerEventSubscriptionCollection on root activity should never be null, but it was"); timers.Remove(this.SubscriptionID); if (wfQueue != null) { wfQueue.UnregisterForQueueItemAvailable(parentEventHandler); qService.DeleteWorkflowQueue(this.SubscriptionID); } this.SubscriptionID = Guid.Empty; }
private StateMachineSubscription SubscribeEventActivity(ActivityExecutionContext context, IEventActivity eventActivity) { EventActivitySubscription subscription = new EventActivitySubscription(); StateActivity state = (StateActivity)context.Activity; subscription.Subscribe(context, state, eventActivity); WorkflowQueue workflowQueue = GetWorkflowQueue(context, subscription.QueueName); if (workflowQueue != null) { workflowQueue.Enabled = true; } this.Subscriptions[subscription.QueueName] = subscription; return(subscription); }
internal static void ChangeEventDrivenQueueState(ActivityExecutionContext context, EventDrivenActivity eventDriven, bool enabled) { IEventActivity eventActivity = StateMachineHelpers.GetEventActivity(eventDriven); IComparable queueName = GetQueueName(eventActivity); if (queueName == null) { return; // skip unitialized follower } WorkflowQueue workflowQueue = GetWorkflowQueue(context, queueName); if (workflowQueue != null) { workflowQueue.Enabled = enabled; } }
void IActivityEventListener <QueueEventArgs> .OnEvent(object sender, QueueEventArgs e) { ActivityExecutionContext executionContext = sender as ActivityExecutionContext; WorkflowQueuingService queueService = executionContext.GetService <WorkflowQueuingService>(); WorkflowQueue queue = queueService.GetWorkflowQueue(e.QueueName); if (queue.Count > 0) { object item = queue.Dequeue(); ProcessQueueItem(executionContext, item); queue.UnregisterForQueueItemAvailable(this); // run all Activities base.Execute(executionContext); } }
internal void DeleteQueue(ActivityExecutionContext context) { if (!StateMachineHelpers.IsRootExecutionContext(context)) { // we only subscribe to the set state event if // we're at the root level. If this instance is // being called, it is not possible to set the // state from the host side directly return; } WorkflowQueuingService workflowQueuingService = context.GetService <WorkflowQueuingService>(); WorkflowQueue workflowQueue = workflowQueuingService.GetWorkflowQueue(StateMachineWorkflowActivity.SetStateQueueName); workflowQueuingService.DeleteWorkflowQueue(StateMachineWorkflowActivity.SetStateQueueName); }