Imported Upstream version 5.2.0.179

Former-commit-id: a536d4f20e27294d8bbc2184d75f3a22364f7ba1

external/referencesource/System.ServiceModel.Routing/System/ServiceModel/Routing/RoutingBehavior.cs

@@ -0,0 +1,282 @@
+//----------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//----------------------------------------------------------------
+
+namespace System.ServiceModel.Routing
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+    using System.Runtime;
+    using System.ServiceModel;
+    using System.ServiceModel.Activation;
+    using System.ServiceModel.Channels;
+    using System.ServiceModel.Description;
+    using System.ServiceModel.Dispatcher;
+
+    [Fx.Tag.XamlVisible(false)]
+    public sealed class RoutingBehavior : IServiceBehavior
+    {
+        RoutingConfiguration configuration;
+
+        public RoutingBehavior(RoutingConfiguration routingConfiguration)
+        {
+            if (routingConfiguration == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("routingConfiguration");
+            }
+
+            this.configuration = routingConfiguration;
+        }
+
+        void IServiceBehavior.AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters)
+        {
+        }
+
+        void IServiceBehavior.ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
+        {
+            RoutingExtension routingExtension = new RoutingExtension(this.configuration);
+            serviceHostBase.Extensions.Add(routingExtension);
+            for (int i = 0; i < serviceHostBase.ChannelDispatchers.Count; i++)
+            {
+                ChannelDispatcher channelDispatcher = serviceHostBase.ChannelDispatchers[i] as ChannelDispatcher;
+                if (channelDispatcher != null)
+                {
+                    foreach (EndpointDispatcher endpointDispatcher in channelDispatcher.Endpoints)
+                    {
+                        if (!endpointDispatcher.IsSystemEndpoint &&
+                            RoutingUtilities.IsRoutingServiceNamespace(endpointDispatcher.ContractNamespace))
+                        {
+                            DispatchRuntime dispatchRuntime = endpointDispatcher.DispatchRuntime;
+                            //Since we use PerSession instancing this concurrency only applies to messages
+                            //in the same session, also needed to maintain order.
+                            dispatchRuntime.ConcurrencyMode = ConcurrencyMode.Single;
+                            dispatchRuntime.EnsureOrderedDispatch = this.configuration.EnsureOrderedDispatch;
+                        }
+                    }
+                }
+            }
+        }
+
+        void IServiceBehavior.Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
+        {
+            HashSet<string> endpoints = new HashSet<string>();
+            foreach (ServiceEndpoint endpoint in serviceDescription.Endpoints)
+            {
+                if (!endpoint.IsSystemEndpoint && 
+                    RoutingUtilities.IsRoutingServiceNamespace(endpoint.Contract.Namespace))
+                {
+                    endpoint.Behaviors.Add(new RoutingEndpointBehavior(endpoint));
+                    endpoints.Add(endpoint.Name);
+                }
+            }
+            EndpointNameMessageFilter.Validate(this.configuration.InternalFilterTable.Keys, endpoints);
+        }
+
+        public static Type GetContractForDescription(ContractDescription description)
+        {
+            if (description == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("description");
+            }
+
+            if (description.CallbackContractType != null)
+            {
+                return typeof(IDuplexSessionRouter);
+            }
+
+            bool allOneWay = true;
+            foreach (OperationDescription operation in description.Operations)
+            {
+                if (!operation.IsOneWay)
+                {
+                    allOneWay = false;
+                    break;
+                }
+            }
+
+            if (allOneWay)
+            {
+                if (description.SessionMode == SessionMode.Required)
+                {
+                    return typeof(ISimplexSessionRouter);
+                }
+                else
+                {
+                    return typeof(ISimplexDatagramRouter);
+                }
+            }
+            else
+            {
+                return typeof(IRequestReplyRouter);
+            }
+        }
+
+        internal class RoutingEndpointBehavior : IEndpointBehavior, IChannelInitializer, IInputSessionShutdown
+        {
+            public RoutingEndpointBehavior(ServiceEndpoint endpoint)
+            {
+                this.Endpoint = endpoint;
+                this.EndpointName = endpoint.Name;
+            }
+
+            internal ChannelDispatcher ChannelDispatcher
+            {
+                get;
+                private set;
+            }
+
+            internal ServiceEndpoint Endpoint
+            {
+                get;
+                private set;
+            }
+
+            internal string EndpointName
+            {
+                get;
+                private set;
+            }
+
+            internal bool ImpersonationRequired
+            {
+                get;
+                private set;
+            }
+
+            internal bool ReceiveContextEnabled
+            {
+                get;
+                private set;
+            }
+
+            internal bool TransactedReceiveEnabled
+            {
+                get;
+                private set;
+            }
+
+            public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
+            {
+                //Turn on ReceiveContext here if supported
+                IReceiveContextSettings receiveContextSettings = endpoint.Binding.GetProperty<IReceiveContextSettings>(bindingParameters);
+                if (receiveContextSettings != null)
+                {
+                    receiveContextSettings.Enabled = true;
+                }
+            }
+
+            public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
+            {
+            }
+
+            public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
+            {
+                this.ChannelDispatcher = endpointDispatcher.ChannelDispatcher;
+                this.ChannelDispatcher.ChannelInitializers.Add(this);
+                endpointDispatcher.DispatchRuntime.InputSessionShutdownHandlers.Add(this);
+                endpointDispatcher.DispatchRuntime.AutomaticInputSessionShutdown = false;
+
+                if (endpointDispatcher.DispatchRuntime.ImpersonateCallerForAllOperations)
+                {
+                    this.ImpersonationRequired = true;
+                }
+                else if (AspNetEnvironment.Current.AspNetCompatibilityEnabled)
+                {
+                    this.ImpersonationRequired = true;
+                }
+
+                BindingParameterCollection bindingParams = new BindingParameterCollection();
+                if (RoutingUtilities.IsTransactedReceive(endpoint.Binding, bindingParams))
+                {
+                    foreach (OperationDescription operation in endpoint.Contract.Operations)
+                    {
+                        if (operation.Behaviors.Find<TransactedReceiveOperationBehavior>() == null)
+                        {
+                            operation.Behaviors.Add(new TransactedReceiveOperationBehavior());
+                        }
+                    }
+                    this.ChannelDispatcher.IsTransactedReceive = true;
+                    endpointDispatcher.DispatchRuntime.TransactionAutoCompleteOnSessionClose = true;
+                    this.TransactedReceiveEnabled = true;
+                }
+
+                IReceiveContextSettings rcSettings = endpoint.Binding.GetProperty<IReceiveContextSettings>(bindingParams);
+                if (rcSettings != null && rcSettings.Enabled)
+                {                   
+                    foreach (OperationDescription operation in endpoint.Contract.Operations)
+                    {
+                        ReceiveContextEnabledAttribute rcEnabled = new ReceiveContextEnabledAttribute();
+                        rcEnabled.ManualControl = true;
+                        operation.Behaviors.Add(rcEnabled);
+                    }
+                    this.ReceiveContextEnabled = true;
+
+                    //Switch TransactedReceive off, because we don't want the Dispatcher creating any Transaction
+                    endpointDispatcher.ChannelDispatcher.IsTransactedReceive = false;
+                    endpointDispatcher.DispatchRuntime.TransactionAutoCompleteOnSessionClose = false;
+                }
+            }
+
+            public void Validate(ServiceEndpoint endpoint)
+            {
+            }
+
+            void IChannelInitializer.Initialize(IClientChannel channel)
+            {
+                RoutingChannelExtension channelState = RoutingChannelExtension.Create(this);
+                channel.Extensions.Add(channelState);
+            }
+
+            void IInputSessionShutdown.ChannelFaulted(IDuplexContextChannel channel)
+            {
+                RoutingChannelExtension channelExtension = channel.Extensions.Find<RoutingChannelExtension>();
+                if (channelExtension != null)
+                {
+                    channelExtension.Fault(new CommunicationObjectFaultedException());
+                }
+                else
+                {
+                    RoutingUtilities.Abort(channel, channel.LocalAddress);
+                }
+            }
+
+            void IInputSessionShutdown.DoneReceiving(IDuplexContextChannel channel)
+            {
+                RoutingChannelExtension channelExtension = channel.Extensions.Find<RoutingChannelExtension>();
+                channelExtension.DoneReceiving(this.Endpoint.Binding.CloseTimeout);
+            }
+        }
+
+        class TransactedReceiveOperationBehavior : IOperationBehavior
+        {
+            public void AddBindingParameters(OperationDescription operationDescription, BindingParameterCollection bindingParameters)
+            {
+            }
+
+            public void ApplyClientBehavior(OperationDescription operationDescription, ClientOperation clientOperation)
+            {
+            }
+
+            public void ApplyDispatchBehavior(OperationDescription operationDescription, DispatchOperation dispatchOperation)
+            {
+                if (operationDescription.Behaviors.Find<ReceiveContextEnabledAttribute>() == null)
+                {
+                    dispatchOperation.TransactionRequired = true;
+                }
+
+                ContractDescription contract = operationDescription.DeclaringContract;
+                if (dispatchOperation.IsOneWay && contract.SessionMode == SessionMode.Required)
+                {
+                    dispatchOperation.Parent.ConcurrencyMode = ConcurrencyMode.Single;
+                    dispatchOperation.Parent.ReleaseServiceInstanceOnTransactionComplete = false;
+                    dispatchOperation.TransactionAutoComplete = false;
+                }
+            }
+
+            public void Validate(OperationDescription operationDescription)
+            {
+            }
+        }
+    }
+}