예제 #1
0
        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);
        }
        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);
        }
예제 #3
0
        public override bool Equals(object obj)
        {
            EventQueueName eventQueueName = obj as EventQueueName;

            if (eventQueueName == null)
            {
                return(false);
            }
            return(0 == this.CompareTo(eventQueueName));
        }
        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);
        }
예제 #5
0
        public void EventHandler(object sender, ExternalDataEventArgs eventArgs)
        {
            if (eventArgs == null)
            {
                throw new ArgumentNullException("eventArgs");
            }

            try
            {
                object         workItem;
                IPendingWork   workHandler;
                object[]       args = this.enqueueWrapper.PrepareEventArgsArray(sender, eventArgs, out workItem, out workHandler);
                EventQueueName key  = GetKey(args);

                String securityIdentifier = null;
                if (eventArgs.Identity == null)
                {
                    IIdentity       identity        = System.Threading.Thread.CurrentPrincipal.Identity;
                    WindowsIdentity windowsIdentity = identity as WindowsIdentity;
                    if (windowsIdentity != null && windowsIdentity.User != null)
                    {
                        securityIdentifier = windowsIdentity.User.Translate(typeof(NTAccount)).ToString();
                    }
                    else if (identity != null)
                    {
                        securityIdentifier = identity.Name;
                    }

                    eventArgs.Identity = securityIdentifier;
                }
                else
                {
                    securityIdentifier = eventArgs.Identity;
                }

                MethodMessage message = new MethodMessage(this.proxiedType, this.eventName, args, securityIdentifier);

                WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "Firing event {0} for instance {1}", this.eventName, eventArgs.InstanceId);

                this.enqueueWrapper.DeliverMessage(eventArgs, key, message, workItem, workHandler);
            }
            catch (Exception e)
            {
                if (ExternalDataExchangeService.IsIrrecoverableException(e))
                {
                    throw;
                }
                else
                {
                    throw new EventDeliveryFailedException(SR.GetString(SR.Error_EventDeliveryFailedException, this.proxiedType, this.eventName, eventArgs.InstanceId), e);
                }
            }
        }
예제 #6
0
        public override bool Equals(object obj)
        {
            EventQueueName k = obj as EventQueueName;

            //Without the cast we end up in op_Equality below
            if ((object)k == null)
            {
                return(false);
            }

            return(0 == CompareTo(k));
        }
예제 #7
0
        public int CompareTo(EventQueueName eventQueueName)
        {
            if (eventQueueName == null)
            {
                return(-1);
            }
            int num = StringComparer.Ordinal.Compare(this.MethodName, eventQueueName.MethodName);

            if (num == 0)
            {
                num = StringComparer.Ordinal.Compare(this.AssemblyQualifiedName, eventQueueName.AssemblyQualifiedName);
                if ((num != 0) || (this.correlationValues == null))
                {
                    return(num);
                }
                num = (eventQueueName.correlationValues != null) ? (this.correlationValues.Length - eventQueueName.correlationValues.Length) : -1;
                if (num != 0)
                {
                    return(num);
                }
                for (int i = 0; i < this.correlationValues.Length; i++)
                {
                    if ((this.correlationValues[i] == null) || (eventQueueName.correlationValues[i] == null))
                    {
                        return(-1);
                    }
                    object obj2 = this.correlationValues[i].Value;
                    object obj3 = this.FindCorrelationValue(this.correlationValues[i].Name, eventQueueName.correlationValues);
                    if ((obj2 != null) || (obj3 != null))
                    {
                        if (obj2 == null)
                        {
                            return(-1);
                        }
                        IComparable comparable = obj2 as IComparable;
                        if (comparable != null)
                        {
                            num = comparable.CompareTo(obj3);
                            if (num != 0)
                            {
                                return(num);
                            }
                        }
                        else if (!obj2.Equals(obj3))
                        {
                            return(-1);
                        }
                    }
                }
            }
            return(num);
        }
예제 #8
0
        private void ProcessParameters(ActivityExecutionContext context, IMethodMessage message, Type interfaceType, string operation)
        {
            WorkflowParameterBindingCollection parameters = ParameterBindings;

            if (parameters == null)
            {
                return;
            }

            //cache mInfo todo
            MethodInfo mInfo = interfaceType.GetMethod(operation);

            if (mInfo == null)
            {
                return;
            }

            int  index            = 0;
            bool responseRequired = false;

            foreach (ParameterInfo formalParameter in mInfo.GetParameters())
            {
                // populate in params, checking on IsIn alone is not sufficient
                if (!(formalParameter.ParameterType.IsByRef || (formalParameter.IsIn && formalParameter.IsOut)))
                {
                    if (parameters.Contains(formalParameter.Name))
                    {
                        WorkflowParameterBinding binding = parameters[formalParameter.Name];
                        binding.Value = message.Args[index++];
                    }
                }
                else
                {
                    responseRequired = true;
                }
            }

            if (mInfo.ReturnType != typeof(void) || responseRequired)
            {
                // create queue entry {interface, operation and receive activity Id}
                IComparable queueId = new EventQueueName(interfaceType, operation, QualifiedName);
                // enqueue the message for sendresponse reply context
                WorkflowQueuingService queuingService = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService));
                if (!queuingService.Exists(queueId))
                {
                    queuingService.CreateWorkflowQueue(queueId, true);
                }

                queuingService.GetWorkflowQueue(queueId).Enqueue(message);
            }
        }
 public int CompareTo(EventQueueName eventQueueName)
 {
     if (eventQueueName == null)
     {
         return -1;
     }
     int num = StringComparer.Ordinal.Compare(this.MethodName, eventQueueName.MethodName);
     if (num == 0)
     {
         num = StringComparer.Ordinal.Compare(this.AssemblyQualifiedName, eventQueueName.AssemblyQualifiedName);
         if ((num != 0) || (this.correlationValues == null))
         {
             return num;
         }
         num = (eventQueueName.correlationValues != null) ? (this.correlationValues.Length - eventQueueName.correlationValues.Length) : -1;
         if (num != 0)
         {
             return num;
         }
         for (int i = 0; i < this.correlationValues.Length; i++)
         {
             if ((this.correlationValues[i] == null) || (eventQueueName.correlationValues[i] == null))
             {
                 return -1;
             }
             object obj2 = this.correlationValues[i].Value;
             object obj3 = this.FindCorrelationValue(this.correlationValues[i].Name, eventQueueName.correlationValues);
             if ((obj2 != null) || (obj3 != null))
             {
                 if (obj2 == null)
                 {
                     return -1;
                 }
                 IComparable comparable = obj2 as IComparable;
                 if (comparable != null)
                 {
                     num = comparable.CompareTo(obj3);
                     if (num != 0)
                     {
                         return num;
                     }
                 }
                 else if (!obj2.Equals(obj3))
                 {
                     return -1;
                 }
             }
         }
     }
     return num;
 }
        private static void SafeEnqueueItem(WorkflowInstance instance, EventQueueName key, MethodMessage message)
        {
Label_0000:
            try
            {
                instance.EnqueueItem(key, message, null, null);
            }
            catch (WorkflowOwnershipException)
            {
                WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Warning, 0, string.Format(CultureInfo.InvariantCulture, "Workflow Web Host Encountered Workflow Instance Ownership conflict for instanceid {0}.", new object[] { instance.InstanceId }));
                Thread.Sleep(500);
                goto Label_0000;
            }
        }
예제 #11
0
        private ActivityExecutionStatus ExecuteForActivity(ActivityExecutionContext context, Type interfaceType, string operation)
        {
            WorkflowQueuingService queueSvcs = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService));
            IComparable            queueId   = new EventQueueName(interfaceType, operation);

            if (queueId != null)
            {
                WorkflowQueue queue;
                object        msg = InboundActivityHelper.DequeueMessage(queueId, queueSvcs, this, out queue);
                if (msg != null)
                {
                    this.ProcessMessage(context, msg, interfaceType, operation);
                    return(ActivityExecutionStatus.Closed);
                }
            }
            return(ActivityExecutionStatus.Executing);
        }
 void IActivityEventListener <QueueEventArgs> .OnEvent(object sender, QueueEventArgs args)
 {
     lock (this.sync)
     {
         WorkflowQueue  queue     = (WorkflowQueue)sender;
         EventQueueName queueName = (EventQueueName)queue.QueueName;
         WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "FollowerQueueCreator: initialized on operation {0} for follower {1}", new object[] { queueName.InterfaceType.Name + queueName.MethodName, this.followerOperation });
         IMethodMessage message = queue.Peek() as IMethodMessage;
         ICollection <CorrelationProperty> propertyValues = CorrelationResolver.ResolveCorrelationValues(queueName.InterfaceType, queueName.MethodName, message.Args, false);
         EventQueueName name2 = new EventQueueName(queueName.InterfaceType, this.followerOperation, propertyValues);
         if (!queue.QueuingService.Exists(name2))
         {
             WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "FollowerQueueCreator::CreateQueue creating q {0}", new object[] { name2.GetHashCode() });
             queue.QueuingService.CreateWorkflowQueue(name2, true);
         }
     }
 }
예제 #13
0
 //Back - off logic for conflicting workflow load across workflow runtime boundaries.
 static void SafeEnqueueItem(WorkflowInstance instance, EventQueueName key, MethodMessage message)
 {
     while (true) //When Execution times out ASP.NET going to forcefully plung this request.
     {
         try
         {
             instance.EnqueueItem(key, message, null, null);
             return;
         }
         catch (WorkflowOwnershipException)
         {
             WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Warning, 0, String.Format(System.Globalization.CultureInfo.InvariantCulture, "Workflow Web Host Encountered Workflow Instance Ownership conflict for instanceid {0}.", instance.InstanceId));
             //Back-off for 1/2 sec. Should we make this configurable?
             System.Threading.Thread.Sleep(500);
             continue;
         }
     }
 }
 public void EventHandler(object sender, ExternalDataEventArgs eventArgs)
 {
     if (eventArgs == null)
     {
         throw new ArgumentNullException("eventArgs");
     }
     try
     {
         object         obj2;
         IPendingWork   work;
         object[]       objArray = this.enqueueWrapper.PrepareEventArgsArray(sender, eventArgs, out obj2, out work);
         EventQueueName key      = this.GetKey(objArray);
         string         name     = null;
         if (eventArgs.Identity == null)
         {
             IIdentity       identity  = Thread.CurrentPrincipal.Identity;
             WindowsIdentity identity2 = identity as WindowsIdentity;
             if ((identity2 != null) && (identity2.User != null))
             {
                 name = identity2.User.Translate(typeof(NTAccount)).ToString();
             }
             else if (identity != null)
             {
                 name = identity.Name;
             }
             eventArgs.Identity = name;
         }
         else
         {
             name = eventArgs.Identity;
         }
         MethodMessage message = new MethodMessage(this.proxiedType, this.eventName, objArray, name);
         WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "Firing event {0} for instance {1}", new object[] { this.eventName, eventArgs.InstanceId });
         this.enqueueWrapper.DeliverMessage(eventArgs, key, message, obj2, work);
     }
     catch (Exception exception)
     {
         if (ExternalDataExchangeService.IsIrrecoverableException(exception))
         {
             throw;
         }
         throw new EventDeliveryFailedException(SR.GetString("Error_EventDeliveryFailedException", new object[] { this.proxiedType, this.eventName, eventArgs.InstanceId }), exception);
     }
 }
 protected sealed override void Initialize(IServiceProvider provider)
 {
     if (provider == null)
     {
         throw new ArgumentNullException("provider");
     }
     if ((!base.IsDynamicActivity && !this.IsNestedUnderMultiInstanceContainer) || this.IsInitializingUnderMultiInstanceContainer)
     {
         Type        interfaceType = this.InterfaceType;
         string      eventName     = this.EventName;
         IComparable comparable    = null;
         if (CorrelationResolver.IsInitializingMember(interfaceType, eventName, null))
         {
             comparable = new EventQueueName(interfaceType, eventName);
         }
         base.SetValue(QueueNameProperty, comparable);
         CorrelationService.Initialize(provider, this, interfaceType, eventName, base.WorkflowInstanceId);
     }
 }
예제 #16
0
        protected sealed override void Initialize(IServiceProvider provider)
        {
            if (provider == null)
            {
                throw new ArgumentNullException("provider");
            }
            if (base.Parent == null)
            {
                throw new InvalidOperationException(SR.GetString("Error_MustHaveParent"));
            }
            WorkflowQueuingService service = (WorkflowQueuingService)provider.GetService(typeof(WorkflowQueuingService));
            EventQueueName         name    = new EventQueueName(this.InterfaceType, this.MethodName);

            base.SetValue(QueueNameProperty, name);
            if (!service.Exists(name))
            {
                service.CreateWorkflowQueue(name, true);
            }
        }
예제 #17
0
        private void ProcessParameters(ActivityExecutionContext context, IMethodMessage message, Type interfaceType, string operation)
        {
            WorkflowParameterBindingCollection parameterBindings = this.ParameterBindings;

            if (parameterBindings != null)
            {
                MethodInfo method = interfaceType.GetMethod(operation);
                if (method != null)
                {
                    int  num  = 0;
                    bool flag = false;
                    foreach (ParameterInfo info2 in method.GetParameters())
                    {
                        if (!info2.ParameterType.IsByRef && (!info2.IsIn || !info2.IsOut))
                        {
                            if (parameterBindings.Contains(info2.Name))
                            {
                                WorkflowParameterBinding binding = parameterBindings[info2.Name];
                                binding.Value = message.Args[num++];
                            }
                        }
                        else
                        {
                            flag = true;
                        }
                    }
                    if ((method.ReturnType != typeof(void)) || flag)
                    {
                        IComparable            queueName = new EventQueueName(interfaceType, operation, base.QualifiedName);
                        WorkflowQueuingService service   = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService));
                        if (!service.Exists(queueName))
                        {
                            service.CreateWorkflowQueue(queueName, true);
                        }
                        service.GetWorkflowQueue(queueName).Enqueue(message);
                    }
                }
            }
        }
예제 #18
0
        void IActivityEventListener <QueueEventArgs> .OnEvent(object sender, QueueEventArgs args)
        {
            lock (sync)
            {
                WorkflowQueue queue = (WorkflowQueue)sender;

                // create the queue after extracting the correlation values from the message
                EventQueueName staticId = (EventQueueName)queue.QueueName;
                WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "FollowerQueueCreator: initialized on operation {0} for follower {1}", staticId.InterfaceType.Name + staticId.MethodName, this.followerOperation);

                IMethodMessage message = queue.Peek() as IMethodMessage;

                ICollection <CorrelationProperty> corrValues = CorrelationResolver.ResolveCorrelationValues(staticId.InterfaceType, staticId.MethodName, message.Args, false);

                EventQueueName queueName = new EventQueueName(staticId.InterfaceType, this.followerOperation, corrValues);
                if (!queue.QueuingService.Exists(queueName))
                {
                    WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "FollowerQueueCreator::CreateQueue creating q {0}", queueName.GetHashCode());
                    queue.QueuingService.CreateWorkflowQueue(queueName, true);
                }
            }
        }
 private static void CreateFollowerEntry(IServiceProvider context, Type interfaceType, string followermethodName, string initializermethodName)
 {
     if (CorrelationResolver.IsInitializingMember(interfaceType, initializermethodName, null))
     {
         WorkflowQueuingService service       = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService));
         FollowerQueueCreator   eventListener = new FollowerQueueCreator(followermethodName);
         WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "Creating follower {0} on initializer {1}", new object[] { interfaceType.Name + followermethodName, interfaceType.Name + initializermethodName });
         ICollection <CorrelationProperty> propertyValues = CorrelationResolver.ResolveCorrelationValues(interfaceType, initializermethodName, null, true);
         EventQueueName queueName     = new EventQueueName(interfaceType, initializermethodName, propertyValues);
         WorkflowQueue  workflowQueue = null;
         if (service.Exists(queueName))
         {
             workflowQueue = service.GetWorkflowQueue(queueName);
         }
         else
         {
             workflowQueue         = service.CreateWorkflowQueue(queueName, true);
             workflowQueue.Enabled = false;
         }
         workflowQueue.RegisterForQueueItemArrived(eventListener);
     }
 }
 private static void CreateFollowerEntry(IServiceProvider context, Type interfaceType, string followermethodName, string initializermethodName)
 {
     if (CorrelationResolver.IsInitializingMember(interfaceType, initializermethodName, null))
     {
         WorkflowQueuingService service = (WorkflowQueuingService) context.GetService(typeof(WorkflowQueuingService));
         FollowerQueueCreator eventListener = new FollowerQueueCreator(followermethodName);
         WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "Creating follower {0} on initializer {1}", new object[] { interfaceType.Name + followermethodName, interfaceType.Name + initializermethodName });
         ICollection<CorrelationProperty> propertyValues = CorrelationResolver.ResolveCorrelationValues(interfaceType, initializermethodName, null, true);
         EventQueueName queueName = new EventQueueName(interfaceType, initializermethodName, propertyValues);
         WorkflowQueue workflowQueue = null;
         if (service.Exists(queueName))
         {
             workflowQueue = service.GetWorkflowQueue(queueName);
         }
         else
         {
             workflowQueue = service.CreateWorkflowQueue(queueName, true);
             workflowQueue.Enabled = false;
         }
         workflowQueue.RegisterForQueueItemArrived(eventListener);
     }
 }
 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;
 }
예제 #22
0
        protected sealed override void Initialize(IServiceProvider provider)
        {
            if (provider == null)
            {
                throw new ArgumentNullException("provider");
            }

            //When activity is dropped inside multi instance container(replicator)
            //We delay CorrelationService initialization to template initialization time.
            if ((!this.IsDynamicActivity && !IsNestedUnderMultiInstanceContainer) || IsInitializingUnderMultiInstanceContainer)
            {
                Type        type      = this.InterfaceType;
                string      eventName = this.EventName;
                IComparable queueName = null;
                if (CorrelationResolver.IsInitializingMember(type, eventName, null))
                {
                    queueName = new EventQueueName(type, eventName);
                }
                this.SetValue(QueueNameProperty, queueName);

                CorrelationService.Initialize(provider, this, type, eventName, this.WorkflowInstanceId);
            }
        }
예제 #23
0
        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);
        }
예제 #24
0
        protected sealed override void Initialize(IServiceProvider provider)
        {
            if (provider == null)
            {
                throw new ArgumentNullException("provider");
            }

            if (this.Parent == null)
            {
                throw new InvalidOperationException(SR.GetString(SR.Error_MustHaveParent));
            }

            WorkflowQueuingService queueService = (WorkflowQueuingService)provider.GetService(typeof(WorkflowQueuingService));

            //create a static q entry
            EventQueueName key = new EventQueueName(this.InterfaceType, this.MethodName);

            this.SetValue(QueueNameProperty, key);

            if (!queueService.Exists(key))
            {
                queueService.CreateWorkflowQueue(key, true);
            }
        }
 protected object[] Invoke(Type interfaceType, string methodName, bool isActivation, object[] parameters)
 {
     EventHandler<WorkflowCompletedEventArgs> handler3 = null;
     object[] objArray;
     Guid workflowInstanceId = GetWorkflowInstanceId(ref isActivation);
     EventQueueName key = new EventQueueName(interfaceType, methodName);
     MethodInfo method = interfaceType.GetMethod(methodName);
     bool responseRequired = method.ReturnType != typeof(void);
     if (!responseRequired)
     {
         foreach (ParameterInfo info2 in method.GetParameters())
         {
             if (info2.ParameterType.IsByRef || info2.IsOut)
             {
                 responseRequired = true;
                 break;
             }
         }
     }
     MethodMessage methodMessage = PrepareMessage(interfaceType, methodName, parameters, responseRequired);
     EventHandler<WorkflowTerminatedEventArgs> handler = null;
     EventHandler<WorkflowCompletedEventArgs> handler2 = null;
     try
     {
         WorkflowInstance workflow;
         if (isActivation)
         {
             workflow = this.WorkflowRuntime.CreateWorkflow(this.workflowType, null, workflowInstanceId);
             SafeEnqueueItem(workflow, key, methodMessage);
             workflow.Start();
         }
         else
         {
             workflow = this.WorkflowRuntime.GetWorkflow(workflowInstanceId);
             SafeEnqueueItem(workflow, key, methodMessage);
         }
         bool workflowTerminated = false;
         handler = delegate (object sender, WorkflowTerminatedEventArgs e) {
             if (e.WorkflowInstance.InstanceId.Equals(workflowInstanceId))
             {
                 methodMessage.SendException(e.Exception);
                 workflowTerminated = true;
             }
         };
         if (handler3 == null)
         {
             handler3 = delegate (object sender, WorkflowCompletedEventArgs e) {
                 if (e.WorkflowInstance.InstanceId.Equals(workflowInstanceId))
                 {
                     methodMessage.SendException(new ApplicationException(SR.GetString(CultureInfo.CurrentCulture, "Error_WorkflowCompleted")));
                 }
             };
         }
         handler2 = handler3;
         this.WorkflowRuntime.WorkflowTerminated += handler;
         this.WorkflowRuntime.WorkflowCompleted += handler2;
         ManualWorkflowSchedulerService service = this.WorkflowRuntime.GetService<ManualWorkflowSchedulerService>();
         if (service != null)
         {
             service.RunWorkflow(workflow.InstanceId);
         }
         if (!responseRequired)
         {
             return new object[0];
         }
         IMethodResponseMessage message = methodMessage.WaitForResponseMessage();
         if (message.Exception != null)
         {
             if (!workflowTerminated)
             {
                 throw message.Exception;
             }
             throw new ApplicationException(SR.GetString(CultureInfo.CurrentCulture, "Error_WorkflowTerminated"), message.Exception);
         }
         if (message.OutArgs != null)
         {
             return ((ArrayList) message.OutArgs).ToArray();
         }
         objArray = new object[0];
     }
     finally
     {
         if (handler != null)
         {
             this.WorkflowRuntime.WorkflowTerminated -= handler;
         }
         if (handler2 != null)
         {
             this.WorkflowRuntime.WorkflowCompleted -= handler2;
         }
     }
     return objArray;
 }
예제 #26
0
        // IComparable implementation
        public int CompareTo(EventQueueName eventQueueName)
        {
            if (eventQueueName == null)
            {
                return(-1);
            }

            // compare operation
            int compared = StringComparer.Ordinal.Compare(this.MethodName, eventQueueName.MethodName);

            if (compared == 0)
            {
                // compare type names
#pragma warning disable 56506
                compared = StringComparer.Ordinal.Compare(AssemblyQualifiedName, eventQueueName.AssemblyQualifiedName);
#pragma warning restore 56506

                if (compared == 0)
                {
                    if (this.correlationValues != null)
                    {
                        compared = (eventQueueName.correlationValues != null) ? (this.correlationValues.Length - eventQueueName.correlationValues.Length) : -1;

                        if (compared == 0)
                        {
                            // compare correlation values
                            for (int i = 0; i < this.correlationValues.Length; i++)
                            {
                                if (this.correlationValues[i] == null || eventQueueName.correlationValues[i] == null)
                                {
                                    compared = -1;
                                    break; // match failed
                                }

                                object leftValue  = this.correlationValues[i].Value;
                                object rightValue = FindCorrelationValue(this.correlationValues[i].Name, eventQueueName.correlationValues);

#pragma warning suppress 56506
                                if (leftValue == null && rightValue == null)
                                {
                                    continue;
                                }

                                // do the explicit equals check
                                if (leftValue != null)
                                {
                                    IComparable comparable = leftValue as IComparable;
                                    if (comparable != null)
                                    {
                                        compared = comparable.CompareTo(rightValue);
                                        if (compared != 0)
                                        {
                                            break; // match failed
                                        }
                                    }
                                    else if ((!leftValue.Equals(rightValue)))
                                    {
                                        compared = -1;
                                        break; // match failed
                                    }
                                }
                                else
                                {
                                    compared = -1;
                                    break; // match failed
                                }
                            }
                        }
                    }
                }
            }
            return(compared);
        }
예제 #27
0
        protected Object[] Invoke(Type interfaceType, String methodName, bool isActivation, Object[] parameters)
        {
            Guid             workflowInstanceId = GetWorkflowInstanceId(ref isActivation);
            WorkflowInstance wfInstance;

            EventQueueName key = new EventQueueName(interfaceType, methodName);

            MethodInfo mInfo = interfaceType.GetMethod(methodName);

            bool responseRequired = (mInfo.ReturnType != typeof(void));

            if (!responseRequired)
            {
                foreach (ParameterInfo parameter in mInfo.GetParameters())
                {
                    if (parameter.ParameterType.IsByRef || parameter.IsOut)
                    {
                        responseRequired = true;
                        break;
                    }
                }
            }

            MethodMessage methodMessage = PrepareMessage(interfaceType, methodName, parameters, responseRequired);

            EventHandler <WorkflowTerminatedEventArgs> workflowTerminationHandler = null;
            EventHandler <WorkflowCompletedEventArgs>  workflowCompletedHandler   = null;

            try
            {
                if (isActivation)
                {
                    wfInstance = WorkflowRuntime.CreateWorkflow(this.workflowType, null, workflowInstanceId);
                    SafeEnqueueItem(wfInstance, key, methodMessage);
                    wfInstance.Start();
                }
                else
                {
                    wfInstance = WorkflowRuntime.GetWorkflow(workflowInstanceId);
                    SafeEnqueueItem(wfInstance, key, methodMessage);
                }

                bool workflowTerminated = false;

                //Handler for workflow termination in b/w outstanding req-response.
                workflowTerminationHandler = delegate(Object sender, WorkflowTerminatedEventArgs e)
                {
                    if (e.WorkflowInstance.InstanceId.Equals(workflowInstanceId))
                    {
                        methodMessage.SendException(e.Exception);
                        workflowTerminated = true;
                    }
                };

                workflowCompletedHandler = delegate(Object sender, WorkflowCompletedEventArgs e)
                {
                    if (e.WorkflowInstance.InstanceId.Equals(workflowInstanceId))
                    {
                        methodMessage.SendException(new ApplicationException(SR.GetString(System.Globalization.CultureInfo.CurrentCulture, SR.Error_WorkflowCompleted)));
                    }
                };

                WorkflowRuntime.WorkflowTerminated += workflowTerminationHandler;
                WorkflowRuntime.WorkflowCompleted  += workflowCompletedHandler;

                ManualWorkflowSchedulerService scheduler = WorkflowRuntime.GetService <ManualWorkflowSchedulerService>();

                if (scheduler != null)
                {
                    scheduler.RunWorkflow(wfInstance.InstanceId);
                }

                if (!responseRequired)
                {
                    // no ret, out or ref
                    return(new Object[] { });
                }

                IMethodResponseMessage response = methodMessage.WaitForResponseMessage();

                if (response.Exception != null)
                {
                    if (!workflowTerminated)
                    {
                        throw response.Exception;
                    }
                    else
                    {
                        throw new ApplicationException(SR.GetString(System.Globalization.CultureInfo.CurrentCulture, SR.Error_WorkflowTerminated), response.Exception);
                    }
                }

                if (response.OutArgs != null)
                {
                    return(((ArrayList)response.OutArgs).ToArray());
                }
                else
                {
                    return new Object[] { }
                };
            }
            finally
            {
                if (workflowTerminationHandler != null)
                {
                    WorkflowRuntime.WorkflowTerminated -= workflowTerminationHandler;
                }

                if (workflowCompletedHandler != null)
                {
                    WorkflowRuntime.WorkflowCompleted -= workflowCompletedHandler;
                }
            }
        }
        protected object[] Invoke(Type interfaceType, string methodName, bool isActivation, object[] parameters)
        {
            EventHandler <WorkflowCompletedEventArgs> handler3 = null;

            object[]       objArray;
            Guid           workflowInstanceId = GetWorkflowInstanceId(ref isActivation);
            EventQueueName key              = new EventQueueName(interfaceType, methodName);
            MethodInfo     method           = interfaceType.GetMethod(methodName);
            bool           responseRequired = method.ReturnType != typeof(void);

            if (!responseRequired)
            {
                foreach (ParameterInfo info2 in method.GetParameters())
                {
                    if (info2.ParameterType.IsByRef || info2.IsOut)
                    {
                        responseRequired = true;
                        break;
                    }
                }
            }
            MethodMessage methodMessage = PrepareMessage(interfaceType, methodName, parameters, responseRequired);
            EventHandler <WorkflowTerminatedEventArgs> handler  = null;
            EventHandler <WorkflowCompletedEventArgs>  handler2 = null;

            try
            {
                WorkflowInstance workflow;
                if (isActivation)
                {
                    workflow = this.WorkflowRuntime.CreateWorkflow(this.workflowType, null, workflowInstanceId);
                    SafeEnqueueItem(workflow, key, methodMessage);
                    workflow.Start();
                }
                else
                {
                    workflow = this.WorkflowRuntime.GetWorkflow(workflowInstanceId);
                    SafeEnqueueItem(workflow, key, methodMessage);
                }
                bool workflowTerminated = false;
                handler = delegate(object sender, WorkflowTerminatedEventArgs e) {
                    if (e.WorkflowInstance.InstanceId.Equals(workflowInstanceId))
                    {
                        methodMessage.SendException(e.Exception);
                        workflowTerminated = true;
                    }
                };
                if (handler3 == null)
                {
                    handler3 = delegate(object sender, WorkflowCompletedEventArgs e) {
                        if (e.WorkflowInstance.InstanceId.Equals(workflowInstanceId))
                        {
                            methodMessage.SendException(new ApplicationException(SR.GetString(CultureInfo.CurrentCulture, "Error_WorkflowCompleted")));
                        }
                    };
                }
                handler2 = handler3;
                this.WorkflowRuntime.WorkflowTerminated += handler;
                this.WorkflowRuntime.WorkflowCompleted  += handler2;
                ManualWorkflowSchedulerService service = this.WorkflowRuntime.GetService <ManualWorkflowSchedulerService>();
                if (service != null)
                {
                    service.RunWorkflow(workflow.InstanceId);
                }
                if (!responseRequired)
                {
                    return(new object[0]);
                }
                IMethodResponseMessage message = methodMessage.WaitForResponseMessage();
                if (message.Exception != null)
                {
                    if (!workflowTerminated)
                    {
                        throw message.Exception;
                    }
                    throw new ApplicationException(SR.GetString(CultureInfo.CurrentCulture, "Error_WorkflowTerminated"), message.Exception);
                }
                if (message.OutArgs != null)
                {
                    return(((ArrayList)message.OutArgs).ToArray());
                }
                objArray = new object[0];
            }
            finally
            {
                if (handler != null)
                {
                    this.WorkflowRuntime.WorkflowTerminated -= handler;
                }
                if (handler2 != null)
                {
                    this.WorkflowRuntime.WorkflowCompleted -= handler2;
                }
            }
            return(objArray);
        }
예제 #29
0
        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;
        }
예제 #30
0
        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);
        }
예제 #31
0
        // IComparable implementation
        public int CompareTo(EventQueueName eventQueueName)
        {
            if (eventQueueName == null)
                return -1;

            // compare operation
            int compared = StringComparer.Ordinal.Compare(this.MethodName, eventQueueName.MethodName);

            if (compared == 0)
            {
                // compare type names
#pragma warning disable 56506
                compared = StringComparer.Ordinal.Compare(AssemblyQualifiedName, eventQueueName.AssemblyQualifiedName);
#pragma warning restore 56506

                if (compared == 0)
                {
                    if (this.correlationValues != null)
                    {
                        compared = (eventQueueName.correlationValues != null) ? (this.correlationValues.Length - eventQueueName.correlationValues.Length) : -1;

                        if (compared == 0)
                        {
                            // compare correlation values
                            for (int i = 0; i < this.correlationValues.Length; i++)
                            {
                                if (this.correlationValues[i] == null || eventQueueName.correlationValues[i] == null)
                                {
                                    compared = -1;
                                    break; // match failed
                                }

                                object leftValue = this.correlationValues[i].Value;
                                object rightValue = FindCorrelationValue(this.correlationValues[i].Name, eventQueueName.correlationValues);

#pragma warning suppress 56506
                                if (leftValue == null && rightValue == null)
                                {
                                    continue;
                                }

                                // do the explicit equals check
                                if (leftValue != null)
                                {
                                    IComparable comparable = leftValue as IComparable;
                                    if (comparable != null)
                                    {
                                        compared = comparable.CompareTo(rightValue);
                                        if (compared != 0)
                                        {
                                            break; // match failed
                                        }
                                    }
                                    else if ((!leftValue.Equals(rightValue)))
                                    {
                                        compared = -1;
                                        break; // match failed
                                    }
                                }
                                else
                                {
                                    compared = -1;
                                    break; // match failed
                                }
                            }
                        }
                    }
                }
            }
            return compared;
        }
        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);
        }
        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;
        }
 //Back - off logic for conflicting workflow load across workflow runtime boundaries.
 static void SafeEnqueueItem(WorkflowInstance instance, EventQueueName key, MethodMessage message)
 {
     while (true) //When Execution times out ASP.NET going to forcefully plung this request.
     {
         try
         {
             instance.EnqueueItem(key, message, null, null);
             return;
         }
         catch (WorkflowOwnershipException)
         {
             WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Warning, 0, String.Format(System.Globalization.CultureInfo.InvariantCulture, "Workflow Web Host Encountered Workflow Instance Ownership conflict for instanceid {0}.", instance.InstanceId));
             //Back-off for 1/2 sec. Should we make this configurable?
             System.Threading.Thread.Sleep(500);
             continue;
         }
     }
 }
 private static void SafeEnqueueItem(WorkflowInstance instance, EventQueueName key, MethodMessage message)
 {
 Label_0000:
     try
     {
         instance.EnqueueItem(key, message, null, null);
     }
     catch (WorkflowOwnershipException)
     {
         WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Warning, 0, string.Format(CultureInfo.InvariantCulture, "Workflow Web Host Encountered Workflow Instance Ownership conflict for instanceid {0}.", new object[] { instance.InstanceId }));
         Thread.Sleep(500);
         goto Label_0000;
     }
 }
        protected Object[] Invoke(Type interfaceType, String methodName, bool isActivation, Object[] parameters)
        {
            Guid workflowInstanceId = GetWorkflowInstanceId(ref isActivation);
            WorkflowInstance wfInstance;

            EventQueueName key = new EventQueueName(interfaceType, methodName);

            MethodInfo mInfo = interfaceType.GetMethod(methodName);

            bool responseRequired = (mInfo.ReturnType != typeof(void));

            if (!responseRequired)
            {
                foreach (ParameterInfo parameter in mInfo.GetParameters())
                {
                    if (parameter.ParameterType.IsByRef || parameter.IsOut)
                    {
                        responseRequired = true;
                        break;
                    }
                }
            }

            MethodMessage methodMessage = PrepareMessage(interfaceType, methodName, parameters, responseRequired);

            EventHandler<WorkflowTerminatedEventArgs> workflowTerminationHandler = null;
            EventHandler<WorkflowCompletedEventArgs> workflowCompletedHandler = null;

            try
            {
                if (isActivation)
                {
                    wfInstance = WorkflowRuntime.CreateWorkflow(this.workflowType, null, workflowInstanceId);
                    SafeEnqueueItem(wfInstance, key, methodMessage);
                    wfInstance.Start();
                }
                else
                {
                    wfInstance = WorkflowRuntime.GetWorkflow(workflowInstanceId);
                    SafeEnqueueItem(wfInstance, key, methodMessage);
                }

                bool workflowTerminated = false;

                //Handler for workflow termination in b/w outstanding req-response.
                workflowTerminationHandler = delegate(Object sender, WorkflowTerminatedEventArgs e)
                {
                    if (e.WorkflowInstance.InstanceId.Equals(workflowInstanceId))
                    {
                        methodMessage.SendException(e.Exception);
                        workflowTerminated = true;
                    }
                };

                workflowCompletedHandler = delegate(Object sender, WorkflowCompletedEventArgs e)
                {
                    if (e.WorkflowInstance.InstanceId.Equals(workflowInstanceId))
                    {
                        methodMessage.SendException(new ApplicationException(SR.GetString(System.Globalization.CultureInfo.CurrentCulture, SR.Error_WorkflowCompleted)));
                    }
                };

                WorkflowRuntime.WorkflowTerminated += workflowTerminationHandler;
                WorkflowRuntime.WorkflowCompleted += workflowCompletedHandler;

                ManualWorkflowSchedulerService scheduler = WorkflowRuntime.GetService<ManualWorkflowSchedulerService>();

                if (scheduler != null)
                {
                    scheduler.RunWorkflow(wfInstance.InstanceId);
                }

                if (!responseRequired)
                {
                    // no ret, out or ref
                    return new Object[] { };
                }

                IMethodResponseMessage response = methodMessage.WaitForResponseMessage();

                if (response.Exception != null)
                {
                    if (!workflowTerminated)
                        throw response.Exception;
                    else
                        throw new ApplicationException(SR.GetString(System.Globalization.CultureInfo.CurrentCulture, SR.Error_WorkflowTerminated), response.Exception);
                }

                if (response.OutArgs != null)
                    return ((ArrayList)response.OutArgs).ToArray();
                else
                    return new Object[] { };
            }
            finally
            {
                if (workflowTerminationHandler != null)
                    WorkflowRuntime.WorkflowTerminated -= workflowTerminationHandler;

                if (workflowCompletedHandler != null)
                    WorkflowRuntime.WorkflowCompleted -= workflowCompletedHandler;
            }
        }
 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;
 }
        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);
        }