Ejemplo n.º 1
0
            static void InvokeComplete(IAsyncResult resultParameter)
            {
                if (resultParameter.CompletedSynchronously)
                {
                    return;
                }

                InvokeAsyncResult invokeResult = resultParameter.AsyncState as InvokeAsyncResult;

                Fx.Assert(invokeResult != null,
                          "Async state should have been of type InvokeAsyncResult.");

                try
                {
                    invokeResult.returnValue = invokeResult.invoker.innerInvoker.InvokeEnd(invokeResult.serviceInstance, out invokeResult.outputs, resultParameter);
                }
                catch (Exception e)
                {
                    if (Fx.IsFatal(e))
                    {
                        throw;
                    }

                    ServiceErrorHandler.MarkException(e);
                    invokeResult.completionException = e;
                }
                finally
                {
                    if (invokeResult.DoFinish())
                    {
                        invokeResult.Complete(false, invokeResult.completionException);
                    }
                }
            }
Ejemplo n.º 2
0
        public object Invoke(object instance, object[] inputs, out object[] outputs)
        {
            if (instance == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("instance");
            }

            ServiceDurableInstance durableInstance = instance as ServiceDurableInstance;

            if (durableInstance == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
                          new InvalidOperationException(
                              SR2.GetString(SR2.InvokeCalledWithWrongType, typeof(DurableServiceAttribute).Name)));
            }

            object    serviceInstance    = durableInstance.StartOperation(this.canCreateInstance);
            Exception operationException = null;

            bool failFast = false;

            try
            {
                return(this.innerInvoker.Invoke(serviceInstance, inputs, out outputs));
            }
            catch (Exception e)
            {
                if (Fx.IsFatal(e))
                {
                    failFast = true;
                    throw;
                }

                operationException = e;
                ServiceErrorHandler.MarkException(e);
                throw;
            }
            finally
            {
                if (!failFast)
                {
                    durableInstance.FinishOperation(this.completesInstance, this.contractCausesSave, operationException);
                }
            }
        }
Ejemplo n.º 3
0
            bool DoInvoke()
            {
                bool finishNow = false;

                try
                {
                    IAsyncResult result = null;

                    using (OperationContextScope operationScope = new OperationContextScope(this.operationContext))
                    {
                        result = this.invoker.innerInvoker.InvokeBegin(this.serviceInstance, this.inputs, invokeCallback, this);
                    }

                    if (result.CompletedSynchronously)
                    {
                        this.returnValue = this.invoker.innerInvoker.InvokeEnd(this.serviceInstance, out this.outputs, result);
                        finishNow        = true;
                    }
                }
                catch (Exception e)
                {
                    if (Fx.IsFatal(e))
                    {
                        throw;
                    }

                    ServiceErrorHandler.MarkException(e);
                    this.completionException = e;
                    finishNow = true;
                }

                if (finishNow)
                {
                    if (DoFinish())
                    {
                        return(true);
                    }
                }

                return(false);
            }
        public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
        {
            if (serviceDescription == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceDescription");
            }

            if (serviceHostBase == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceHostBase");
            }

            if (serviceDescription.Endpoints == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("serviceDescription", SR2.GetString(SR2.NoEndpoints));
            }

            PersistenceProviderBehavior providerBehavior = null;

            if (serviceDescription.Behaviors != null)
            {
                providerBehavior = serviceDescription.Behaviors.Find<PersistenceProviderBehavior>();
            }

            if (providerBehavior == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
                    new InvalidOperationException(
                    SR2.GetString(
                    SR2.NonNullPersistenceProviderRequired,
                    typeof(PersistenceProvider).Name,
                    typeof(DurableServiceAttribute).Name)));
            }

            if (providerBehavior.PersistenceProviderFactory == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
                    new InvalidOperationException(
                    SR2.GetString(
                    SR2.NonNullPersistenceProviderRequired,
                    typeof(PersistenceProvider).Name,
                    typeof(DurableServiceAttribute).Name)));
            }

            providerBehavior.PersistenceProviderFactory.Open();
            serviceHostBase.Closed += new EventHandler(
                delegate(object sender, EventArgs args)
            {
                Fx.Assert(sender is ServiceHostBase, "The sender should be serviceHostBase.");
                // We have no way of knowing whether the service host closed or aborted
                // so we err on the side of abort for right now.
                providerBehavior.PersistenceProviderFactory.Abort();
            }
                );

            DurableInstanceContextProvider instanceContextProvider = new ServiceDurableInstanceContextProvider(
                serviceHostBase,
                false,
                serviceDescription.ServiceType,
                providerBehavior.PersistenceProviderFactory,
                this.saveStateInOperationTransaction,
                this.unknownExceptionAction,
                new DurableRuntimeValidator(this.saveStateInOperationTransaction, this.unknownExceptionAction),
                providerBehavior.PersistenceOperationTimeout);

            DurableInstanceContextProvider singleCallInstanceContextProvider = null;

            IInstanceProvider instanceProvider = new DurableInstanceProvider(instanceContextProvider);

            bool includeExceptionDetails = false;

            if (serviceDescription.Behaviors != null)
            {
                ServiceBehaviorAttribute serviceBehavior = serviceDescription.Behaviors.Find<ServiceBehaviorAttribute>();

                if (serviceBehavior != null)
                {
                    includeExceptionDetails |= serviceBehavior.IncludeExceptionDetailInFaults;
                }

                ServiceDebugBehavior serviceDebugBehavior = serviceDescription.Behaviors.Find<ServiceDebugBehavior>();

                if (serviceDebugBehavior != null)
                {
                    includeExceptionDetails |= serviceDebugBehavior.IncludeExceptionDetailInFaults;
                }
            }

            IErrorHandler errorHandler = new ServiceErrorHandler(includeExceptionDetails);

            foreach (ChannelDispatcherBase channelDispatcherBase in serviceHostBase.ChannelDispatchers)
            {
                ChannelDispatcher channelDispatcher = channelDispatcherBase as ChannelDispatcher;

                if (channelDispatcher != null && channelDispatcher.HasApplicationEndpoints())
                {
                    if (this.unknownExceptionAction == UnknownExceptionAction.AbortInstance)
                    {
                        channelDispatcher.ErrorHandlers.Add(errorHandler);
                    }

                    foreach (EndpointDispatcher endpointDispatcher in channelDispatcher.Endpoints)
                    {
                        if (endpointDispatcher.IsSystemEndpoint)
                        {
                            continue;
                        }
                        ServiceEndpoint serviceEndPoint = serviceDescription.Endpoints.Find(new XmlQualifiedName(endpointDispatcher.ContractName, endpointDispatcher.ContractNamespace));

                        if (serviceEndPoint != null)
                        {
                            if (serviceEndPoint.Contract.SessionMode != SessionMode.NotAllowed)
                            {
                                endpointDispatcher.DispatchRuntime.InstanceContextProvider = instanceContextProvider;
                            }
                            else
                            {
                                if (singleCallInstanceContextProvider == null)
                                {
                                    singleCallInstanceContextProvider = new ServiceDurableInstanceContextProvider(
                                        serviceHostBase,
                                        true,
                                        serviceDescription.ServiceType,
                                        providerBehavior.PersistenceProviderFactory,
                                        this.saveStateInOperationTransaction,
                                        this.unknownExceptionAction,
                                        new DurableRuntimeValidator(this.saveStateInOperationTransaction, this.unknownExceptionAction),
                                        providerBehavior.PersistenceOperationTimeout);
                                }
                                endpointDispatcher.DispatchRuntime.InstanceContextProvider = singleCallInstanceContextProvider;
                            }
                            endpointDispatcher.DispatchRuntime.MessageInspectors.Add(new DurableMessageDispatchInspector(serviceEndPoint.Contract.SessionMode));
                            endpointDispatcher.DispatchRuntime.InstanceProvider = instanceProvider;
                            WorkflowServiceBehavior.SetContractFilterToIncludeAllOperations(endpointDispatcher, serviceEndPoint.Contract);
                        }
                    }
                }
            }

            foreach (ServiceEndpoint endpoint in serviceDescription.Endpoints)
            {
                if (!endpoint.InternalIsSystemEndpoint(serviceDescription))
                {
                    foreach (OperationDescription opDescription in endpoint.Contract.Operations)
                    {
                        if (!opDescription.Behaviors.Contains(typeof(DurableOperationAttribute)))
                        {
                            opDescription.Behaviors.Add(DurableOperationAttribute.DefaultInstance);
                        }
                    }
                }
            }
        }