Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/ServiceConfiguration.cs

@@ -0,0 +1,348 @@
+// <copyright>
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+
+namespace System.ServiceModel
+{
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+    using System.IdentityModel.Configuration;
+    using System.Linq;
+    using System.ServiceModel.Channels;
+    using System.ServiceModel.Description;
+
+    /// <summary>
+    /// Facade over ServiceHost to use in programmatic configuration.
+    /// </summary>
+    public class ServiceConfiguration
+    {
+        private ServiceHost host;
+
+        // ServiceConfiguration is a facade over a ServiceHost
+        internal ServiceConfiguration(ServiceHost host)
+        {
+            CheckArgument(host, "host");
+            this.host = host;
+        }
+
+        /// <summary>
+        /// Gets a complete, in-memory description of the service being configured, including all the endpoints for the service and specifications for their respective addresses, bindings, contracts and behaviors.
+        /// </summary>
+        public ServiceDescription Description
+        {
+            get
+            {
+                return this.host.Description;
+            }
+        }
+
+        /// <summary>
+        /// Gets the ServiceAuthenticationBehavior currently enabled on the service's Description.
+        /// </summary>
+        public ServiceAuthenticationBehavior Authentication
+        {
+            get
+            {
+                return this.host.Authentication;
+            }
+        }
+
+        /// <summary>
+        /// Gets the ServiceAuthorizationBehavior currently enabled on the service's Description.
+        /// </summary>
+        public ServiceAuthorizationBehavior Authorization
+        {
+            get
+            {
+                return this.host.Authorization;
+            }
+        }
+
+        /// <summary>
+        /// Gets the ServiceCredentials currently enabled on the service's Description.
+        /// </summary>
+        public ServiceCredentials Credentials
+        {
+            get
+            {
+                return this.host.Credentials;
+            }
+        }
+
+        /// <summary>
+        /// Gets the base addresses for the service as specified by the underlying ServiceHost.
+        /// </summary>
+        public ReadOnlyCollection<Uri> BaseAddresses
+        {
+            get
+            {
+                return this.host.BaseAddresses;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets OpenTimeout for the underlying ServiceHost
+        /// </summary>
+        public TimeSpan OpenTimeout
+        {
+            get
+            {
+                return this.host.OpenTimeout;
+            }
+
+            set
+            {
+                this.host.OpenTimeout = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets CloseTimeout for the underlying ServiceHost
+        /// </summary>
+        public TimeSpan CloseTimeout
+        {
+            get
+            {
+                return this.host.CloseTimeout;
+            }
+
+            set
+            {
+                this.host.CloseTimeout = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to use token handlers
+        /// </summary>
+        public bool UseIdentityConfiguration
+        {
+            get
+            {
+                return this.Credentials.UseIdentityConfiguration;
+            }
+
+            set
+            {
+                this.Credentials.UseIdentityConfiguration = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets IdentityConfiguration for the underlying ServiceHost
+        /// </summary>
+        public IdentityConfiguration IdentityConfiguration
+        {
+            get
+            {
+                return this.Credentials.IdentityConfiguration;
+            }
+            
+            set
+            {
+                this.Credentials.IdentityConfiguration = value;
+            }
+        }
+
+        /// <summary>
+        /// Validate a service endpoint and add it to Description
+        /// </summary>
+        /// <param name="endpoint">endpoint to add</param>
+        public void AddServiceEndpoint(ServiceEndpoint endpoint)
+        {
+            CheckArgument(endpoint, "endpoint");
+
+            // Do some other checks to match ServiceHostBase.AddServiceEndpoint
+            if ((this.host.State != CommunicationState.Created) && (this.host.State != CommunicationState.Opening))
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString("SFxServiceHostBaseCannotAddEndpointAfterOpen")));
+            }
+
+            if (this.Description == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString("SFxServiceHostBaseCannotAddEndpointWithoutDescription")));
+            }
+
+            if (endpoint.Address == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString("SFxEndpointAddressNotSpecified"));
+            }
+
+            if (endpoint.Contract == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString("SFxEndpointContractNotSpecified"));
+            }
+
+            if (endpoint.Binding == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString("SFxEndpointBindingNotSpecified"));
+            }
+
+            if (!endpoint.IsSystemEndpoint || (endpoint.Contract.ContractType == typeof(IMetadataExchange)))
+            {
+                // Throw if contract is not valid for this service
+                //   i.e. if contract is not implemented by service, unless endpoint is a standard endpoint 
+                //   note: (metadata endpoints require metadata behavior to implement IMetadataExchange even though it's a standard endpoint)            
+                IContractResolver resolver = this.host.GetContractResolver(this.host.ImplementedContracts);
+                ConfigLoader configLoader = new ConfigLoader(resolver);
+                configLoader.LookupContract(endpoint.Contract.ConfigurationName, this.Description.Name); // throws on failure
+            }
+
+            this.Description.Endpoints.Add(endpoint);
+        }
+
+        /// <summary>
+        /// Create a new service endpoint and add it to Description
+        /// </summary>
+        /// <param name="contractType">interface annotated with [ServiceContract]</param>
+        /// <param name="binding">protocol to use for communication</param>
+        /// <param name="address">absolute address for service, or address relative to base address for supplied binding</param>
+        /// <returns>The endpoint which was created</returns>
+        public ServiceEndpoint AddServiceEndpoint(Type contractType, Binding binding, string address)
+        {
+            CheckArgument(address, "address");
+            return this.AddServiceEndpoint(contractType, binding, new Uri(address, UriKind.RelativeOrAbsolute));
+        }
+
+        /// <summary>
+        /// Create a new service endpoint and add it to Description
+        /// </summary>
+        /// <param name="contractType">interface annotated with [ServiceContract]</param>
+        /// <param name="binding">protocol to use for communication</param>
+        /// <param name="address">absolute address for service, or address relative to base address for supplied binding</param>
+        /// <returns>The endpoint which was created</returns>
+        public ServiceEndpoint AddServiceEndpoint(Type contractType, Binding binding, Uri address)
+        {
+            CheckArgument(contractType, "contractType");
+            CheckArgument(binding, "binding");
+            CheckArgument(address, "address");
+
+            ContractDescription contract = this.host.ImplementedContracts == null
+                ? null
+                : this.host.ImplementedContracts.Values.FirstOrDefault(implementedContract => implementedContract.ContractType == contractType);
+            if (contract == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("contractType", SR.GetString(SR.SFxMethodNotSupportedByType2, this.host.Description.ServiceType, contractType));
+            }
+
+            ServiceEndpoint endpoint = new ServiceEndpoint(contract, binding, new EndpointAddress(ServiceHost.MakeAbsoluteUri(address, binding, this.host.InternalBaseAddresses)));
+            this.AddServiceEndpoint(endpoint);
+            return endpoint;
+        }
+
+        /// <summary>
+        /// Create a new service endpoint and add it to Description
+        /// </summary>
+        /// <param name="contractType">interface annotated with [ServiceContract]</param>
+        /// <param name="binding">protocol to use for communication</param>
+        /// <param name="address">absolute logical address for service, or address relative to base address for supplied binding</param>
+        /// <param name="listenUri">absolute physical address for service, or address relative to base address for supplied binding</param>
+        /// <returns>The endpoint which was created</returns>
+        public ServiceEndpoint AddServiceEndpoint(Type contractType, Binding binding, string address, Uri listenUri)
+        {
+            CheckArgument(listenUri, "listenUri");
+
+            ServiceEndpoint endpoint = this.AddServiceEndpoint(contractType, binding, address);
+            this.SetListenUri(endpoint, binding, listenUri);
+            return endpoint;
+        }
+
+        /// <summary>
+        /// Create a new service endpoint and add it to Description
+        /// </summary>
+        /// <param name="contractType">interface annotated with [ServiceContract]</param>
+        /// <param name="binding">protocol to use for communication</param>
+        /// <param name="address">absolute logical address for service, or address relative to base address for supplied binding</param>
+        /// <param name="listenUri">absolute physical address for service, or address relative to base address for supplied binding</param>
+        /// <returns>The endpoint which was created</returns>
+        public ServiceEndpoint AddServiceEndpoint(Type contractType, Binding binding, Uri address, Uri listenUri)
+        {
+            CheckArgument(listenUri, "listenUri");
+
+            ServiceEndpoint endpoint = this.AddServiceEndpoint(contractType, binding, address);
+            this.SetListenUri(endpoint, binding, listenUri);
+            return endpoint;
+        }
+
+        /// <summary>
+        /// Convenience method to compute and set endpoint's address
+        /// </summary>
+        /// <param name="endpoint">endpoint to set</param>
+        /// <param name="relativeAddress">address relative to the ServiceHost's base address, if any, for endpoint's current binding</param>
+        public void SetEndpointAddress(ServiceEndpoint endpoint, string relativeAddress)
+        {
+            CheckArgument(endpoint, "endpoint");
+            CheckArgument(relativeAddress, "relativeAddress");
+
+            this.host.SetEndpointAddress(endpoint, relativeAddress);
+        }
+
+        /// <summary>
+        /// Automatically add endpoints for all of a service's enabled contracts, for all of its enabled base addresses that match the specified binding.
+        /// </summary>
+        /// <param name="protocol">Binding to add endpoints for</param>
+        /// <returns>Endpoints created</returns>
+        public Collection<ServiceEndpoint> EnableProtocol(Binding protocol)
+        {
+            CheckArgument(protocol, "protocol");
+            Collection<ServiceEndpoint> generatedEndpoints = new Collection<ServiceEndpoint>();
+
+            if (this.host.ImplementedContracts != null)
+            {
+                // don't generate endpoints for contracts that serve as the base type for other reflected contracts            
+                IEnumerable<ContractDescription> contracts = this.host.ImplementedContracts.Values;
+                IEnumerable<ContractDescription> mostSpecificContracts = contracts.Where(contract
+                    => contracts.All(otherContract
+                        => object.ReferenceEquals(contract, otherContract)
+                            || !contract.ContractType.IsAssignableFrom(otherContract.ContractType)));
+
+                foreach (var uri in this.host.BaseAddresses)
+                {
+                    if (uri.Scheme.Equals(protocol.Scheme))
+                    {
+                        foreach (ContractDescription contract in mostSpecificContracts)
+                        {
+                            ServiceEndpoint endpoint = new ServiceEndpoint(contract, protocol, new EndpointAddress(uri));
+                            this.AddServiceEndpoint(endpoint);
+                            generatedEndpoints.Add(endpoint);
+                        }
+                    }
+                }
+            }
+
+            return generatedEndpoints;
+        }
+
+        /// <summary>
+        /// Load endpoints and behaviors into service Description from current AppDomain's configuration
+        /// </summary>
+        public void LoadFromConfiguration()
+        {
+            this.host.LoadFromConfiguration();
+        }
+
+        /// <summary>
+        /// Load endpoints and behaviors into service Description from supplied configuration
+        /// </summary>
+        /// <param name="configuration">configuration to load from</param>
+        public void LoadFromConfiguration(System.Configuration.Configuration configuration)
+        {
+            CheckArgument(configuration, "configuration");
+            this.host.LoadFromConfiguration(configuration);
+        }
+
+        private static void CheckArgument<T>(T argument, string argumentName)
+        {
+            if (argument == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(argumentName);
+            }
+        }
+
+        private void SetListenUri(ServiceEndpoint endpoint, Binding binding, Uri listenUri)
+        {
+            endpoint.UnresolvedListenUri = listenUri;
+            endpoint.ListenUri = ServiceHost.MakeAbsoluteUri(listenUri, binding, this.host.InternalBaseAddresses);
+        }
+    }
+}