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 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); }
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 virtual WorkflowBase GetNextWorkflow() { if (WorkflowQueue.Count == 0) { return(null); } var wftype = WorkflowQueue.Dequeue(); var wf = CreateInstance <WorkflowBase>(wftype); return(wf); }
/// <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); }
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; }
internal static object DequeueMessage(IComparable queueId, WorkflowQueuingService queueSvcs, Activity activity, out WorkflowQueue queue) { object obj2 = null; queue = queueSvcs.GetWorkflowQueue(queueId); if (queue.Count != 0) { obj2 = queue.Dequeue(); if (obj2 == null) { throw new ArgumentException(SR.GetString("Error_InvalidEventMessage", new object[] { activity.QualifiedName })); } } return(obj2); }
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 override void ProcessEvent(ActivityExecutionContext context) { WorkflowQueuingService workflowQueuingService = context.GetService <WorkflowQueuingService>(); WorkflowQueue workflowQueue = workflowQueuingService.GetWorkflowQueue(StateMachineWorkflowActivity.SetStateQueueName); SetStateEventArgs eventArgs = workflowQueue.Dequeue() as SetStateEventArgs; StateActivity currentState = StateMachineHelpers.GetCurrentState(context); if (currentState == null) { throw new InvalidOperationException(SR.GetStateMachineWorkflowMustHaveACurrentState()); } StateActivity rootState = StateMachineHelpers.GetRootState((StateActivity)context.Activity); StateMachineExecutionState executionState = StateMachineExecutionState.Get(rootState); SetStateAction action = new SetStateAction(currentState.QualifiedName, eventArgs.TargetStateName); Debug.Assert(!executionState.HasEnqueuedActions); executionState.EnqueueAction(action); executionState.ProcessActions(context); }
void IEventActivity.Unsubscribe(ActivityExecutionContext parentContext, IActivityEventListener <QueueEventArgs> parentEventHandler) { if (parentContext == null) { throw new ArgumentNullException("parentContext"); } if (parentEventHandler == null) { throw new ArgumentNullException("parentEventHandler"); } WorkflowQueuingService service = parentContext.GetService <WorkflowQueuingService>(); WorkflowQueue workflowQueue = null; try { workflowQueue = service.GetWorkflowQueue(this.SubscriptionID); } catch { } if ((workflowQueue != null) && (workflowQueue.Count != 0)) { workflowQueue.Dequeue(); } Activity parent = parentContext.Activity; while (parent.Parent != null) { parent = parent.Parent; } ((TimerEventSubscriptionCollection)parent.GetValue(TimerEventSubscriptionCollection.TimerCollectionProperty)).Remove(this.SubscriptionID); if (workflowQueue != null) { workflowQueue.UnregisterForQueueItemAvailable(parentEventHandler); service.DeleteWorkflowQueue(this.SubscriptionID); } this.SubscriptionID = Guid.Empty; }
protected sealed override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } WorkflowQueuingService queueService = executionContext.GetService <WorkflowQueuingService>(); WorkflowQueue queue = queueService.GetWorkflowQueue(_queueName); queue.RegisterForQueueItemAvailable(this, this.QualifiedName); if (queue.Count > 0) { object item = queue.Dequeue(); ProcessQueueItem(executionContext, item); queue.UnregisterForQueueItemAvailable(this); // run all Activities return(base.Execute(executionContext)); } return(ActivityExecutionStatus.Executing); }
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } if (this.Fault == null) { throw new InvalidOperationException(SR.GetString(CultureInfo.CurrentCulture, SR.Error_PropertyNotSet, FaultProperty.Name)); } WorkflowQueuingService queueService = executionContext.GetService <WorkflowQueuingService>(); // fire event this.RaiseEvent(WebServiceFaultActivity.SendingFaultEvent, this, EventArgs.Empty); WebServiceInputActivity webservicereceive = this.GetActivityByName(this.InputActivityName) as WebServiceInputActivity; IComparable queueId = new EventQueueName(webservicereceive.InterfaceType, webservicereceive.MethodName, webservicereceive.QualifiedName); Debug.Assert(queueService.Exists(queueId)); IMethodResponseMessage responseMessage = null; WorkflowQueue queue = queueService.GetWorkflowQueue(queueId); if (queue.Count != 0) { responseMessage = queue.Dequeue() as IMethodResponseMessage; } System.Diagnostics.Debug.Assert(responseMessage != null); // populate exception & reset the waiting thread responseMessage.SendException(this.Fault); return(ActivityExecutionStatus.Closed); }
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } WorkflowQueuingService queueService = executionContext.GetService <WorkflowQueuingService>(); // fire event this.RaiseEvent(WebServiceOutputActivity.SendingOutputEvent, this, EventArgs.Empty); WebServiceInputActivity webservicereceive = this.GetActivityByName(this.InputActivityName) as WebServiceInputActivity; if (webservicereceive == null) { Activity parent = this.Parent; while (parent != null) { //typically if defined inside a custom activity string qualifiedName = parent.QualifiedName + "." + this.InputActivityName; webservicereceive = this.GetActivityByName(qualifiedName) as WebServiceInputActivity; if (webservicereceive != null) { break; } parent = this.Parent; } } if (webservicereceive == null) { throw new InvalidOperationException(SR.GetString(SR.Error_CannotResolveWebServiceInput, this.QualifiedName, this.InputActivityName)); } IComparable queueId = new EventQueueName(webservicereceive.InterfaceType, webservicereceive.MethodName, webservicereceive.QualifiedName); MethodInfo mInfo = webservicereceive.InterfaceType.GetMethod(webservicereceive.MethodName); if (!queueService.Exists(queueId)) { // determine if no response is required, // compiler did not catch it, do the runtime check and return if (mInfo.ReturnType == typeof(void)) { return(ActivityExecutionStatus.Closed); } bool isresponseRequired = false; foreach (ParameterInfo formalParameter in mInfo.GetParameters()) { if (formalParameter.ParameterType.IsByRef || (formalParameter.IsIn && formalParameter.IsOut)) { isresponseRequired = true; } } if (isresponseRequired) { return(ActivityExecutionStatus.Closed); } } if (!queueService.Exists(queueId)) { throw new InvalidOperationException(SR.GetString(SR.Error_WebServiceInputNotProcessed, webservicereceive.QualifiedName)); } IMethodResponseMessage responseMessage = null; WorkflowQueue queue = queueService.GetWorkflowQueue(queueId); if (queue.Count != 0) { responseMessage = queue.Dequeue() as IMethodResponseMessage; } IMethodMessage message = responseMessage as IMethodMessage; WorkflowParameterBindingCollection parameterBindings = this.ParameterBindings; ArrayList outArgs = new ArrayList(); // populate result if (this.ParameterBindings.Contains("(ReturnValue)")) { WorkflowParameterBinding retBind = this.ParameterBindings["(ReturnValue)"]; if (retBind != null) { outArgs.Add(retBind.Value); } } foreach (ParameterInfo formalParameter in mInfo.GetParameters()) { // update out and byref values if (formalParameter.ParameterType.IsByRef || (formalParameter.IsIn && formalParameter.IsOut)) { WorkflowParameterBinding binding = parameterBindings[formalParameter.Name]; outArgs.Add(binding.Value); } } // reset the waiting thread responseMessage.SendResponse(outArgs); return(ActivityExecutionStatus.Closed); }
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } WorkflowQueuingService service = executionContext.GetService <WorkflowQueuingService>(); base.RaiseEvent(SendingOutputEvent, this, EventArgs.Empty); WebServiceInputActivity activityByName = base.GetActivityByName(this.InputActivityName) as WebServiceInputActivity; if (activityByName == null) { for (Activity activity2 = base.Parent; activity2 != null; activity2 = base.Parent) { string activityQualifiedName = activity2.QualifiedName + "." + this.InputActivityName; activityByName = base.GetActivityByName(activityQualifiedName) as WebServiceInputActivity; if (activityByName != null) { break; } } } if (activityByName == null) { throw new InvalidOperationException(SR.GetString("Error_CannotResolveWebServiceInput", new object[] { base.QualifiedName, this.InputActivityName })); } IComparable queueName = new EventQueueName(activityByName.InterfaceType, activityByName.MethodName, activityByName.QualifiedName); MethodInfo method = activityByName.InterfaceType.GetMethod(activityByName.MethodName); if (!service.Exists(queueName)) { if (method.ReturnType == typeof(void)) { return(ActivityExecutionStatus.Closed); } bool flag = false; foreach (ParameterInfo info2 in method.GetParameters()) { if (info2.ParameterType.IsByRef || (info2.IsIn && info2.IsOut)) { flag = true; } } if (flag) { return(ActivityExecutionStatus.Closed); } } if (!service.Exists(queueName)) { throw new InvalidOperationException(SR.GetString("Error_WebServiceInputNotProcessed", new object[] { activityByName.QualifiedName })); } IMethodResponseMessage message = null; WorkflowQueue workflowQueue = service.GetWorkflowQueue(queueName); if (workflowQueue.Count != 0) { message = workflowQueue.Dequeue() as IMethodResponseMessage; } WorkflowParameterBindingCollection parameterBindings = this.ParameterBindings; ArrayList outArgs = new ArrayList(); if (this.ParameterBindings.Contains("(ReturnValue)")) { WorkflowParameterBinding binding = this.ParameterBindings["(ReturnValue)"]; if (binding != null) { outArgs.Add(binding.Value); } } foreach (ParameterInfo info3 in method.GetParameters()) { if (info3.ParameterType.IsByRef || (info3.IsIn && info3.IsOut)) { WorkflowParameterBinding binding2 = parameterBindings[info3.Name]; outArgs.Add(binding2.Value); } } message.SendResponse(outArgs); return(ActivityExecutionStatus.Closed); }