protected internal void DeployAppConfig()
{
IOUtil.FindAndWriteResourceToFile(this.GetType().Assembly, "app.config", ExecutablePath + ".config");
Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ExecutablePath);
#if !ClientSKUFramework
if (AstoriaTestProperties.Host == Host.WebServiceHost)
{
BindingsSection bindingsSection = config.GetSection("system.serviceModel/bindings") as BindingsSection;
WebHttpBindingCollectionElement webHttpBindingCollectionElement;
WebHttpBindingElement webHttpBindingElement;
foreach (BindingCollectionElement bindingCollectionElement in bindingsSection.BindingCollections)
{
// find WebHttpBinding element "higherMessageSize" and modify its settings
if (bindingCollectionElement.BindingType.ToString().Equals("System.ServiceModel.WebHttpBinding"))
{
webHttpBindingCollectionElement = bindingCollectionElement as WebHttpBindingCollectionElement;
webHttpBindingElement = webHttpBindingCollectionElement.Bindings["higherMessageSize"];
if (webHttpBindingElement != null)
{
// webHttpBinding -> binding -> security ->transport
WebHttpSecurityElement webHttpSecurityElement = webHttpBindingElement.Security;
switch (AstoriaTestProperties.HostAuthenicationMethod.ToLower())
{
case "windows":
webHttpSecurityElement.Transport.ClientCredentialType = System.ServiceModel.HttpClientCredentialType.Windows;
webHttpSecurityElement.Transport.ProxyCredentialType = System.ServiceModel.HttpProxyCredentialType.Windows;
break;
default:
webHttpSecurityElement.Transport.ClientCredentialType = System.ServiceModel.HttpClientCredentialType.None;
webHttpSecurityElement.Transport.ProxyCredentialType = System.ServiceModel.HttpProxyCredentialType.None;
break;
}
}
}
}
}
#endif
if (Database != null)
{
// fixup config files
config.ConnectionStrings.ConnectionStrings.Clear();
config.ConnectionStrings.ConnectionStrings.Add(this.Workspace.GetConnectionStringSettingsForProvider(this, this.Database.DatabaseConnectionString));
}
config.Save();
if (AstoriaTestProperties.WebServiceHostTargetFramework != null)
{
//Would rather do this through the API but unsure how
string contents = File.ReadAllText(ExecutablePath + ".config");
int configurationPos = contents.IndexOf("<configuration>");
string startupStr = string.Format("<startup><supportedRuntime version=\"{0}\"/></startup>", AstoriaTestProperties.WebServiceHostTargetFramework);
contents = contents.Insert(configurationPos + 16, startupStr);
File.WriteAllText(ExecutablePath + ".config", contents);
}
}
public BasicHttpBinding(string configurationName) : this()
{
BindingsSection bindingsSection = Configuration.ConfigUtil.BindingsSection;
BasicHttpBindingElement el = bindingsSection.BasicHttpBinding.Bindings[configurationName];
el.ApplyConfiguration(this);
}
internal static BindingCollectionElement UnsafeGetAssociatedBindingCollectionElement(ContextInformation evaluationContext, string bindingCollectionName)
{
BindingCollectionElement item = null;
BindingsSection bindingsSection = (BindingsSection)Microsoft.ServiceBus.Configuration.ConfigurationHelpers.UnsafeGetAssociatedSection(evaluationContext, Microsoft.ServiceBus.Configuration.ConfigurationStrings.BindingsSectionGroupPath);
if (bindingsSection != null)
{
try
{
item = bindingsSection[bindingCollectionName];
}
catch (KeyNotFoundException keyNotFoundException)
{
ExceptionUtility exceptionUtility = Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility;
string configBindingExtensionNotFound = Resources.ConfigBindingExtensionNotFound;
object[] bindingsSectionPath = new object[] { Microsoft.ServiceBus.Configuration.ConfigurationHelpers.GetBindingsSectionPath(bindingCollectionName) };
throw exceptionUtility.ThrowHelperError(new ConfigurationErrorsException(Microsoft.ServiceBus.SR.GetString(configBindingExtensionNotFound, bindingsSectionPath)));
}
catch (NullReferenceException nullReferenceException)
{
ExceptionUtility exceptionUtility1 = Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility;
string str = Resources.ConfigBindingExtensionNotFound;
object[] objArray = new object[] { Microsoft.ServiceBus.Configuration.ConfigurationHelpers.GetBindingsSectionPath(bindingCollectionName) };
throw exceptionUtility1.ThrowHelperError(new ConfigurationErrorsException(Microsoft.ServiceBus.SR.GetString(str, objArray)));
}
}
return(item);
}
internal ConfigWriter(System.Configuration.Configuration configuration)
{
this.bindingsSection = BindingsSection.GetSection(configuration);
ServiceModelSectionGroup sectionGroup = ServiceModelSectionGroup.GetSectionGroup(configuration);
this.channels = sectionGroup.Client.Endpoints;
this.config = configuration;
}
public static Binding GetFromConfig(string configurationName)
{
var bingingsSection = BindingsSection.GetSection(ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None));
var bindingType = (from b in bingingsSection.BindingCollections
where b.ConfiguredBindings.Count > 0 && b.ContainsKey(configurationName)
select b.BindingType).FirstOrDefault();
var binding = bindingType != null?Activator.CreateInstance(bindingType, configurationName) : null;
return((Binding)binding);
}
internal ConfigWriter(Configuration configuration)
{
this.bindingTable = new Dictionary <Binding, BindingDictionaryValue>();
this.bindingsSection = BindingsSection.GetSection(configuration);
ServiceModelSectionGroup serviceModelSectionGroup = ServiceModelSectionGroup.GetSectionGroup(configuration);
this.channels = serviceModelSectionGroup.Client.Endpoints;
this.config = configuration;
}
/// <summary>
/// 获取绑定信息节点
/// </summary>
/// <param name="configName">配置名</param>
/// <returns></returns>
private static BindingsSection GetBindingsSection(string configName)
{
BindingsSection bindingsSection = null;
SetConfigFile(configName);
if (config != null)
{
bindingsSection = config.GetSection("system.serviceModel/bindings") as BindingsSection;
}
return(bindingsSection);
}
static void Main(string[] args)
{
var config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
var bingingsSection = BindingsSection.GetSection(config);
string netTcpSource = bingingsSection.NetTcpBinding.ElementInformation.Source;
string basicHttpSource = bingingsSection.BasicHttpBinding.ElementInformation.Source;
Console.WriteLine("Net TCP Binding came from \"{0}\"", netTcpSource);
Console.WriteLine("Basic HTTP Binding came from \"{0}\"", basicHttpSource);
}
private BasicHttpBinding CreateBindingFromConfig()
{
ServiceModelSectionGroup config = (ServiceModelSectionGroup)ConfigurationManager.OpenExeConfiguration("Test/config/basicHttpBinding").GetSectionGroup("system.serviceModel");
BindingsSection section = (BindingsSection)config.Bindings;
BasicHttpBindingElement el = section.BasicHttpBinding.Bindings ["BasicHttpBinding2_Service"];
BasicHttpBinding b = new BasicHttpBinding();
el.ApplyConfiguration(b);
return(b);
}
internal static WSStreamedHttpBindingCollectionElement GetCollectionElement()
{
WSStreamedHttpBindingCollectionElement retVal = null;
BindingsSection bindingsSection = (BindingsSection)ConfigurationManager.GetSection("system.serviceModel/bindings");
if (null != bindingsSection)
{
retVal = bindingsSection[WSStreamedHttpBindingConstants.WSStreamedHttpBindingCollectionElementName] as WSStreamedHttpBindingCollectionElement;
}
return(retVal);
}
public static AssertEncryptionHttpBindingCollectionElement GetBindingCollectionElement()
{
AssertEncryptionHttpBindingCollectionElement bindingCollectionElement = null;
BindingsSection bindingsSection = ConfigurationManager.GetSection("system.serviceModel/bindings") as BindingsSection;
if (bindingsSection != null)
{
bindingCollectionElement = bindingsSection[AssertEncryptionHttpBindingCollectionElement.BindingCollectionElementName] as AssertEncryptionHttpBindingCollectionElement;
}
return(bindingCollectionElement);
}
/// <summary>
/// Get Bindings Section
/// </summary>
/// <param name="configName"></param>
/// <returns></returns>
private static BindingsSection moGetBindingsSection(string configName)
{
BindingsSection loBindingSection = null;
moSetConfigFile(configName);
if (moConfig != null)
{
loBindingSection = moConfig.GetSection("system.serviceModel/bindings") as BindingsSection;
}
return(loBindingSection);
}
public static RouterBindingCollectionElement GetBindingCollectionElement()
{
RouterBindingCollectionElement retval = null;
BindingsSection bindingsSection = (BindingsSection)ConfigurationManager.GetSection("system.serviceModel/bindings");
if (null != bindingsSection)
{
retval = bindingsSection["routerBinding"] as RouterBindingCollectionElement;
}
return(retval);
}
private void ApplyConfiguration(string configurationName)
{
BindingsSection bindings = ((BindingsSection)(ConfigurationManager.GetSection("system.serviceModel/bindings")));
NetHttpBindingCollectionElement section = (NetHttpBindingCollectionElement)bindings["netHttpBinding"];
NetHttpBindingElement element = section.Bindings[configurationName];
if ((element == null))
{
throw new System.Configuration.ConfigurationErrorsException(string.Format(CultureInfo.CurrentCulture, "There is no binding named {0} at {1}.", configurationName, section.BindingName));
}
else
{
element.ApplyConfiguration(this);
}
}
protected internal static Binding ResolveBinding(BindingsSection section, string bindingName, string name)
{
var bindingCollection = section.BindingCollections.FirstOrDefault(x => x.BindingName == bindingName);
var bindingElement = bindingCollection?.ConfiguredBindings?.FirstOrDefault(x => x.Name == name);
if (bindingElement == null)
{
return(null);
}
var binding = (Binding)Activator.CreateInstance(bindingCollection.BindingType);
binding.Name = bindingElement.Name;
bindingElement.ApplyConfiguration(binding);
return(binding);
}
private static BindingCollectionElement GetBindingCollectionElement(string bindingCollectionName)
{
BindingCollectionElement element = null;
BindingsSection section = (BindingsSection)ConfigurationManager.GetSection("system.serviceModel/bindings");
try
{
element = section.BindingCollections.Find(new Predicate <BindingCollectionElement>(delegate(BindingCollectionElement target) { return(target.BindingName == "bindingCollectionName"); }));
}
catch (KeyNotFoundException)
{
throw new ConfigurationErrorsException();
}
return(element);
}
/// <summary>
/// Applies the current configuration to the WCFMockAdapterBindingCollectionElement
/// </summary>
/// <param name="configurationName">The configuration name to be used to configure the adapter binding instance with</param>
private void ApplyConfiguration(string configurationName)
{
BindingsSection bindingsSection = (BindingsSection)System.Configuration.ConfigurationManager.GetSection("system.serviceModel/bindings");
MockAdapterBindingCollectionElement bindingCollectionElement = (MockAdapterBindingCollectionElement)bindingsSection["mockBinding"];
MockAdapterBindingElement element = bindingCollectionElement.Bindings[configurationName];
if (element != null)
{
MockAdapterUtilities.Trace.Trace(
System.Diagnostics.TraceEventType.Information,
"1007",
"Applying binding configuration");
element.ApplyConfiguration(this);
}
}
private BindingDictionaryValue CreateBindingConfig(Binding binding)
{
BindingDictionaryValue value2;
if (!this.bindingTable.TryGetValue(binding, out value2))
{
string str2;
string name = NamingHelper.GetUniqueName(NamingHelper.CodeName(binding.Name), new NamingHelper.DoesNameExist(this.CheckIfBindingNameInUse), null);
if (!BindingsSection.TryAdd(name, binding, this.config, out str2))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.ServiceModel.SR.GetString("ConfigBindingCannotBeConfigured"), "endpoint.Binding"));
}
value2 = new BindingDictionaryValue(name, str2);
this.bindingTable.Add(binding, value2);
}
return(value2);
}
internal static HttpBindingCollectionElement GetBindingCollectionElement()
{
BindingsSection bindings = AspNetEnvironment.Current.GetConfigurationSection(SectionPath) as BindingsSection;
if (bindings != null)
{
foreach (BindingCollectionElement bindingCollection in bindings.BindingCollections)
{
if (bindingCollection.BindingName == HttpBinding.CollectionElementName)
{
return(bindingCollection as HttpBindingCollectionElement);
}
}
}
return(null);
}
public void UserConfiguration()
{
ServiceModelSectionGroup config = (ServiceModelSectionGroup)ConfigurationManager.OpenExeConfiguration("Test/config/userBinding").GetSectionGroup("system.serviceModel");
BindingsSection section = config.Bindings;
BindingCollectionElement collectionElement = section ["userBinding"];
Assert.AreEqual(typeof(UserBindingCollectionElement), collectionElement.GetType(), "type");
StandardBindingElementCollection <UserBindingElement> userBindings = ((UserBindingCollectionElement)collectionElement).Bindings;
Assert.AreEqual(2, userBindings.Count, "Count");
Assert.AreEqual("UserBinding_1", userBindings [0].Name, "Name_1");
Assert.AreEqual("UserBinding_2", userBindings [1].Name, "Name_2");
}
/// <summary>
/// Initializes a new instance of the DispatcherManager class
/// </summary>
/// <param name="bindings">indicating the bindings section</param>
/// <param name="observer">indicating the observer</param>
/// <param name="queueFactory">indicating the queue factory</param>
/// <param name="sharedData">indicating the shared data</param>
/// <param name="frontendResult">indicating the frontend result</param>
public DispatcherManager(BindingsSection bindings, SharedData sharedData, BrokerObserver observer, ServiceJobMonitorBase monitor, BrokerQueueFactory queueFactory, ITelepathyContext context)
{
this.dispatcherDic = new Dictionary <string, Dispatcher>();
this.failedDispatcherList = new List <string>();
this.blockedDispatcherDic = new Dictionary <string, DispatcherInfo>();
this.blockedDispatcherQueue = new Queue <DispatcherInfo>();
this.sharedData = sharedData;
this.observer = observer;
this.monitor = monitor;
this.queueFactory = queueFactory;
this.context = context;
this.defaultCapacity = this.sharedData.ServiceConfig.MaxConcurrentCalls;
this.blockTimeSpan = TimeSpan.FromMilliseconds(this.sharedData.Config.LoadBalancing.EndpointNotFoundRetryPeriod);
this.unblockTimer = new Timer(new ThreadHelper <object>(new TimerCallback(this.CallbackToQueryBlockedDispatcherList)).CallbackRoot, null, -1, -1);
this.defaultBinding = BindingHelper.GetBackEndBinding(bindings);
this.isHttp = this.defaultBinding.CreateBindingElements().Find <HttpTransportBindingElement>() != null;
// Update binding's maxMessageSize settings with global maxMessageSize if its enabled (> 0)
int maxMessageSize = sharedData.ServiceConfig.MaxMessageSize;
if (maxMessageSize > 0)
{
BindingHelper.ApplyMaxMessageSize(this.defaultBinding, maxMessageSize);
}
// get soa burst protocol info
this.httpsBurst = sharedData.BrokerInfo.HttpsBurst;
if (this.httpsBurst)
{
this.azureQueueManager = new AzureQueueManager(sharedData.BrokerInfo.SessionId, this.sharedData.BrokerInfo.ClusterName, this.sharedData.BrokerInfo.ClusterId);
}
this.supportsMessageDetails = this.defaultBinding.MessageVersion.Addressing != AddressingVersion.None || this.defaultBinding is BasicHttpBinding;
BrokerTracing.TraceEvent(TraceEventType.Information, 0, "[DispatcherManager] Init backend binding: OperatiomTimeout = {0}, DefaultCapacity = {1}", this.sharedData.Config.LoadBalancing.ServiceOperationTimeout, this.defaultCapacity);
BrokerTracing.EtwTrace.LogBackendBindingLoaded(
sharedData.BrokerInfo.SessionId,
"Backend",
maxMessageSize,
this.defaultBinding.ReceiveTimeout.Ticks,
this.defaultBinding.SendTimeout.Ticks,
this.defaultBinding.MessageVersion.ToString(),
this.defaultBinding.Scheme);
}
void ApplyConfiguration(string configurationName)
{
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
ServiceModelSectionGroup sectionGroup = ServiceModelSectionGroup.GetSectionGroup(config);
BindingsSection bindings = sectionGroup.Bindings;
NetNamedPipeContextBindingCollectionElement section = (NetNamedPipeContextBindingCollectionElement)bindings[SectionName];
NetNamedPipeContextBindingElement element = section.Bindings[configurationName];
if (element == null)
{
throw new ConfigurationErrorsException("There is no binding named " + configurationName + " at " + section.BindingName);
}
else
{
element.ApplyConfiguration(this);
}
}
private void TestAmfBinding()
{
try
{
Configuration servicesConfig = WebConfigurationManager.OpenWebConfiguration("~/services");
ServiceModelSectionGroup serviceModel = ServiceModelSectionGroup.GetSectionGroup(servicesConfig);
BindingsSection bindings = serviceModel.Bindings;
CustomBindingElement amfBinding = bindings.CustomBinding.Bindings.Cast <CustomBindingElement>().FirstOrDefault(cb => cb.Name == "amfBinding");
if (amfBinding == null)
{
MarkAsFail(AmfBindingLabel, "Custom binding with name=\"amfBinding\" not found.", null);
return;
}
string config = File.ReadAllText(Server.MapPath("~/Content/swf/config/paths.properties"));
bool sfwUsesHttps = config.Replace(" ", string.Empty).Contains("gateway=https:");
var http = amfBinding.FirstOrDefault(x => x is HttpTransportElement);
var https = amfBinding.FirstOrDefault(x => x is HttpsTransportElement);
if (sfwUsesHttps)
{
if (https == null)
{
MarkAsFail(AmfBindingLabel, "httpsTransport section not found", "Use <httpsTransport /> within <binding name=\"amfBinding\"> (services/web.config)");
}
}
else
{
if (http == null)
{
MarkAsFail(AmfBindingLabel, "httpTransport section not found", "Use <httpTransport /> within <binding name=\"amfBinding\">. (services/web.config)");
}
}
MarkAsPass(AmfBindingLabel);
}
catch (Exception ex)
{
MarkAsFail(AmfBindingLabel, "EXCEPTION DURING TEST: " + ex.Message, null);
}
}
BindingDictionaryValue CreateBindingConfig(Binding binding)
{
BindingDictionaryValue bindingDV;
if (!bindingTable.TryGetValue(binding, out bindingDV))
{
// [....]: review: Use decoded form to preserve the user-given friendly name, however, beacuse our Encoding algorithm
// does not touch ASCII names, a name that looks like encoded name will not roundtrip(Example: "_x002C_" will turned into ",")
string bindingName = NamingHelper.GetUniqueName(NamingHelper.CodeName(binding.Name), this.CheckIfBindingNameInUse, null);
string bindingSectionName;
if (!BindingsSection.TryAdd(bindingName, binding, config, out bindingSectionName))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.ConfigBindingCannotBeConfigured), "endpoint.Binding"));
}
bindingDV = new BindingDictionaryValue(bindingName, bindingSectionName);
bindingTable.Add(binding, bindingDV);
}
return(bindingDV);
}
private void ApplyConfiguration(string configurationName)
{
BindingsSection wcfBindings = (BindingsSection)ConfigurationManager.GetSection("system.serviceModel/bindings");
// wcfBindings contains system defined bindings and bindingExtensions
AmqpBindingCollectionElement section = (AmqpBindingCollectionElement)wcfBindings["amqpBinding"];
if (section == null)
{
throw new ConfigurationErrorsException("Missing \"amqpBinding\" configuration section.");
}
AmqpBindingConfigurationElement element = section.Bindings[configurationName];
if (element == null)
{
throw new ConfigurationErrorsException(string.Format(System.Globalization.CultureInfo.CurrentCulture,
"There is no binding named {0} at {1}.", configurationName, section.BindingName));
}
else
{
element.ApplyConfiguration(this);
}
}
/// <summary>
/// Load the configuration from the configuration file
/// If no configuration is found or some part is missing, we will fill the blank with default value
/// </summary>
/// <param name="brokerSettings">indicate the broker settings from the session start info, this settings will override the settings load from the configuration file</param>
/// <param name="brokerInfo">indicating the broker info</param>
/// <param name="brokerConfig">out the broker configurations</param>
/// <param name="serviceConfig">out the service configurations</param>
/// <param name="bindings">output the bindings</param>
public static void LoadConfiguration(SessionStartInfoContract brokerSettings, BrokerStartInfo brokerInfo, out BrokerConfigurations brokerConfig, out ServiceConfiguration serviceConfig, out BindingsSection bindings)
{
// Init config file
string filename = brokerInfo.ConfigurationFile;
BrokerTracing.TraceVerbose("[ConfigurationHelper] LoadConfiguration. Step 1: Load configuration file name: {0}", filename);
brokerConfig = null;
serviceConfig = null;
bindings = null;
try
{
ExeConfigurationFileMap map = new ExeConfigurationFileMap();
map.ExeConfigFilename = filename;
Configuration config = null;
RetryManager.RetryOnceAsync(
() => config = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None),
TimeSpan.FromSeconds(1),
ex => ex is ConfigurationErrorsException)
.GetAwaiter()
.GetResult();
brokerConfig = BrokerConfigurations.GetSectionGroup(config);
serviceConfig = ServiceRegistration.GetSectionGroup(config).Service;
bindings = (BindingsSection)config.GetSection(BindingsSectionName);
}
catch (ConfigurationErrorsException e)
{
ThrowHelper.ThrowSessionFault(SOAFaultCode.ConfigFile_Invalid,
"{0}",
e.ToString());
}
if (brokerConfig == null)
{
// Set the default value
brokerConfig = defaultBrokerConfiguration;
BrokerTracing.TraceEvent(TraceEventType.Information, 0, "[ConfigurationHelper] Didn't find the broker config from the configuration file, use the default configuration");
}
else
{
// Set the default configuration if the very section is not found
if (brokerConfig.Monitor == null)
{
brokerConfig.Monitor = defaultBrokerConfiguration.Monitor;
BrokerTracing.TraceEvent(TraceEventType.Information, 0, "[ConfigurationHelper] Didn't find the monitor config from the configuration file, use the default configuration");
}
if (brokerConfig.Services == null)
{
brokerConfig.Services = defaultBrokerConfiguration.Services;
BrokerTracing.TraceEvent(TraceEventType.Information, 0, "[ConfigurationHelper] Didn't find the services config from the configuration file, use the default configuration");
}
if (brokerConfig.LoadBalancing == null)
{
brokerConfig.LoadBalancing = defaultBrokerConfiguration.LoadBalancing;
BrokerTracing.TraceEvent(TraceEventType.Information, 0, "[ConfigurationHelper] Didn't find the load balancing config from the configuration file, use the default configuration");
}
}
BrokerTracing.TraceVerbose("[ConfigurationHelper] LoadConfiguration. Step 2: Load broker config and service config succeeded.");
if (brokerConfig.Monitor.AllocationAdjustInterval < MinAllocationAdjustTime && brokerConfig.Monitor.AllocationAdjustInterval != System.Threading.Timeout.Infinite)
{
brokerConfig.Monitor.AllocationAdjustInterval = MinAllocationAdjustTime;
}
// Update the broker config using the session start info
if (brokerSettings.ClientIdleTimeout.HasValue)
{
brokerConfig.Monitor.ClientIdleTimeout = brokerSettings.ClientIdleTimeout.Value;
BrokerTracing.TraceEvent(TraceEventType.Verbose, 0, "[ConfigurationHelper] Modified default ClientIdleTimeout to {0}", brokerConfig.Monitor.ClientIdleTimeout);
}
if (brokerSettings.ClientConnectionTimeout.HasValue)
{
brokerConfig.Monitor.ClientConnectionTimeout = brokerSettings.ClientConnectionTimeout.Value;
BrokerTracing.TraceEvent(TraceEventType.Verbose, 0, "[ConfigurationHelper] Modified default ClientConnectionTimeout to {0}", brokerConfig.Monitor.ClientConnectionTimeout);
}
if (brokerSettings.SessionIdleTimeout.HasValue)
{
brokerConfig.Monitor.SessionIdleTimeout = brokerSettings.SessionIdleTimeout.Value;
BrokerTracing.TraceEvent(TraceEventType.Verbose, 0, "[ConfigurationHelper] Modified default SessionIdleTimeout to {0}", brokerConfig.Monitor.SessionIdleTimeout);
}
if (brokerSettings.MessagesThrottleStartThreshold.HasValue)
{
brokerConfig.Monitor.MessageThrottleStartThreshold = brokerSettings.MessagesThrottleStartThreshold.Value;
BrokerTracing.TraceEvent(TraceEventType.Verbose, 0, "[ConfigurationHelper] Modified default MessageThrottleStartThreshold to {0}", brokerConfig.Monitor.MessageThrottleStartThreshold);
}
if (brokerSettings.MessagesThrottleStopThreshold.HasValue)
{
brokerConfig.Monitor.MessageThrottleStopThreshold = brokerSettings.MessagesThrottleStopThreshold.Value;
BrokerTracing.TraceEvent(TraceEventType.Verbose, 0, "[ConfigurationHelper] Modified default MessageThrottleStopThreshold to {0}", brokerConfig.Monitor.MessageThrottleStopThreshold);
}
if (brokerSettings.ClientBrokerHeartbeatRetryCount.HasValue)
{
brokerConfig.Monitor.ClientBrokerHeartbeatRetryCount = brokerSettings.ClientBrokerHeartbeatRetryCount.Value;
BrokerTracing.TraceEvent(TraceEventType.Verbose, 0, "[ConfigurationHelper] Modified default ClientBrokerHeartbeatRetryCount to {0}", brokerConfig.Monitor.ClientBrokerHeartbeatRetryCount);
}
if (brokerSettings.ClientBrokerHeartbeatInterval.HasValue)
{
brokerConfig.Monitor.ClientBrokerHeartbeatInterval = brokerSettings.ClientBrokerHeartbeatInterval.Value;
BrokerTracing.TraceEvent(TraceEventType.Verbose, 0, "[ConfigurationHelper] Modified default ClientBrokerHeartbeatInterval to {0}", brokerConfig.Monitor.ClientBrokerHeartbeatInterval);
}
if (brokerSettings.ServiceOperationTimeout.HasValue)
{
brokerConfig.LoadBalancing.ServiceOperationTimeout = brokerSettings.ServiceOperationTimeout.Value;
BrokerTracing.TraceEvent(TraceEventType.Verbose, 0, "[ConfigurationHelper] Modified default ServiceOperationTimeout to {0}", brokerConfig.LoadBalancing.ServiceOperationTimeout);
}
if (brokerSettings.DispatcherCapacityInGrowShrink.HasValue)
{
brokerConfig.LoadBalancing.DispatcherCapacityInGrowShrink = brokerSettings.DispatcherCapacityInGrowShrink.Value;
BrokerTracing.TraceEvent(TraceEventType.Verbose, 0, "[ConfigurationHelper] Modified default DispatcherCapacityInGrowShrink to {0}", brokerConfig.LoadBalancing.DispatcherCapacityInGrowShrink);
}
if (brokerSettings.MaxMessageSize.HasValue)
{
serviceConfig.MaxMessageSize = brokerSettings.MaxMessageSize.Value;
BrokerTracing.TraceEvent(TraceEventType.Verbose, 0, "[ConfigurationHelper] Modified default MaxMessageSize to {0}", serviceConfig.MaxMessageSize);
}
BrokerTracing.TraceVerbose("[ConfigurationHelper] LoadConfiguration. Step 3: Override broker settings using session start info succeeded.");
// Validate the config section
string configError;
bool validateSucceeded;
try
{
validateSucceeded = brokerConfig.Validate(out configError);
}
catch (ConfigurationErrorsException e)
{
validateSucceeded = false;
configError = e.Message;
}
if (!validateSucceeded)
{
BrokerTracing.TraceEvent(TraceEventType.Error, 0, "[ConfigurationHelper] Invalid broker configuration section. Error {0}", configError);
ThrowHelper.ThrowSessionFault(SOAFaultCode.Broker_InvalidConfiguration, configError);
}
BrokerTracing.TraceVerbose("[ConfigurationHelper] LoadConfiguration. Step 4: Validate broker configuration succeeded.");
StringBuilder sb = new StringBuilder();
sb.AppendLine("[Monitor]");
BrokerTracing.WriteProperties(sb, brokerConfig.Monitor, 3, typeof(int), typeof(string));
sb.AppendLine("[BaseAddress]");
sb.AppendFormat(" Http = {0}\n", brokerConfig.Services.GetBrokerBaseAddress("http"));
sb.AppendFormat(" Https = {0}\n", brokerConfig.Services.GetBrokerBaseAddress("https"));
sb.AppendFormat(" NetTcp = {0}\n", brokerConfig.Services.GetBrokerBaseAddress("net.tcp"));
sb.AppendLine("[LoadBalancing]");
BrokerTracing.WriteProperties(sb, brokerConfig.LoadBalancing, 3, typeof(int), typeof(string));
BrokerTracing.TraceVerbose("[ConfigurationHelper] BrokerConfiguration: \n{0}", sb.ToString());
sb = new StringBuilder();
sb.AppendLine("[Service]");
BrokerTracing.WriteProperties(sb, serviceConfig, 3, typeof(int), typeof(string));
BrokerTracing.TraceVerbose("[ConfigurationHelper] ServiceConfiguration: \n{0}", sb.ToString());
}
/// <summary>
/// Build the frontend
/// </summary>
/// <param name="sharedData">indicating the shared data</param>
/// <param name="observer">indicating the broker observer</param>
/// <param name="clientManager">indicating the client manager</param>
/// <param name="brokerAuth">indicating the broker authorization</param>
/// <param name="bindings">indicating the bindings</param>
/// <param name="azureQueueProxy">indicating the Azure storage proxy</param>
/// <returns>frontend result</returns>
public static FrontendResult BuildFrontEnd(SharedData sharedData, BrokerObserver observer, BrokerClientManager clientManager, BrokerAuthorization brokerAuth, BindingsSection bindings, AzureQueueProxy azureQueueProxy)
{
FrontendResult result = new FrontendResult();
// Bug 9514: Do not open frontend for inprocess broker
if (sharedData.StartInfo.UseInprocessBroker)
{
return(result);
}
bool flag = false;
// Open frontend for different scheme
// TODO: Separate HTTP frontend and Queue frontend
if (azureQueueProxy != null)
{
flag = true;
result.SetFrontendInfo(BuildHttpFrontend(sharedData, observer, clientManager, brokerAuth, bindings, azureQueueProxy), TransportScheme.Http);
}
else
{
if ((sharedData.StartInfo.TransportScheme & TransportScheme.Custom) == TransportScheme.Custom)
{
flag = true;
result.SetFrontendInfo(BuildCustomFrontend(sharedData, observer, clientManager, brokerAuth, bindings), TransportScheme.Custom);
}
if ((sharedData.StartInfo.TransportScheme & TransportScheme.Http) == TransportScheme.Http)
{
flag = true;
result.SetFrontendInfo(BuildHttpFrontend(sharedData, observer, clientManager, brokerAuth, bindings, azureQueueProxy), TransportScheme.Http);
}
if ((sharedData.StartInfo.TransportScheme & TransportScheme.NetTcp) == TransportScheme.NetTcp)
{
flag = true;
result.SetFrontendInfo(BuildNetTcpFrontend(sharedData, observer, clientManager, brokerAuth, bindings), TransportScheme.NetTcp);
}
if ((sharedData.StartInfo.TransportScheme & TransportScheme.NetHttp) == TransportScheme.NetHttp)
{
flag = true;
result.SetFrontendInfo(BuildNetHttpFrontend(sharedData, observer, clientManager, brokerAuth, bindings), TransportScheme.NetHttp);
}
}
if (!flag)
{
BrokerTracing.TraceEvent(TraceEventType.Critical, 0, "[FrontEndBuilder] Invalid transport scheme: {0}", sharedData.StartInfo.TransportScheme);
ThrowHelper.ThrowSessionFault(SOAFaultCode.Broker_NotSupportedTransportScheme, SR.NotSupportedTransportScheme, sharedData.StartInfo.TransportScheme.ToString());
}
return(result);
}
/// <summary>
/// Build the custom frontend
/// </summary>
/// <param name="sharedData">indicating the shared data</param>
/// <param name="observer">indicating the broker observer</param>
/// <param name="clientManager">indicating the client manager</param>
/// <param name="brokerAuth">indicating the broker authorization</param>
/// <param name="bindings">indicating the bindings</param>
/// <returns>frontend info</returns>
private static FrontendInfo BuildCustomFrontend(SharedData sharedData, BrokerObserver observer, BrokerClientManager clientManager, BrokerAuthorization brokerAuth, BindingsSection bindings)
{
FrontendInfo result = new FrontendInfo();
BrokerTracing.TraceVerbose("[FrontEndBuilder] Start building custom frontend...");
// Get binding from configuration file
Binding binding = BindingHelper.GetBinding(TransportScheme.Custom, sharedData.StartInfo.Secure, bindings);
// Get message size and reader quotas
BindingElementCollection collection = binding.CreateBindingElements();
// Sync frontend binding.receiveTimeout with loadBalancing.ServiceOperationTimeout if its enabled (>0)
int serviceOperationTimeout = sharedData.Config.LoadBalancing.ServiceOperationTimeout;
if (serviceOperationTimeout > 0)
{
binding.SendTimeout = TimeSpan.FromMilliseconds(serviceOperationTimeout);
}
// Set frontend binding.ReceiveTimeout to max
binding.ReceiveTimeout = TimeSpan.MaxValue;
TransportBindingElement transportBindingElement = collection.Find <TransportBindingElement>();
XmlDictionaryReaderQuotas quotas = binding.GetProperty <XmlDictionaryReaderQuotas>(new BindingParameterCollection());
if (sharedData.ServiceConfig.MaxMessageSize > 0)
{
transportBindingElement.MaxReceivedMessageSize = sharedData.Config.LoadBalancing.ServiceOperationTimeout;
quotas.MaxBytesPerRead = XmlDictionaryReaderQuotas.Max.MaxBytesPerRead;
quotas.MaxDepth = XmlDictionaryReaderQuotas.Max.MaxDepth;
quotas.MaxNameTableCharCount = XmlDictionaryReaderQuotas.Max.MaxNameTableCharCount;
quotas.MaxStringContentLength = Convert.ToInt32(sharedData.ServiceConfig.MaxMessageSize);
quotas.MaxArrayLength = Convert.ToInt32(sharedData.ServiceConfig.MaxMessageSize);
}
result.MaxMessageSize = transportBindingElement.MaxReceivedMessageSize;
result.ReaderQuotas = quotas;
// Check if the custom binding supports duplex binding
bool duplex = false;
if (binding.CanBuildChannelListener <IDuplexSessionChannel>())
{
duplex = true;
}
StringBuilder sb = new StringBuilder();
BrokerTracing.WriteProperties(sb, result.ReaderQuotas, 3, typeof(int));
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 1: Load binding data:\nMaxMessageSize = {0}\n[ReaderQuotas]\n{1}\nDuplex = {2}", result.MaxMessageSize, sb.ToString(), duplex);
result.Binding = binding;
BrokerTracing.EtwTrace.LogFrontendBindingLoaded(
sharedData.BrokerInfo.SessionId,
"Custom",
result.MaxMessageSize,
binding.ReceiveTimeout.Ticks,
binding.SendTimeout.Ticks,
binding.MessageVersion.ToString(),
binding.Scheme);
// Generate the net.tcp uri
Uri baseUri = sharedData.Config.Services.GetBrokerBaseAddress(binding.Scheme);
if (baseUri == null)
{
baseUri = GetDefaultUriByScheme(binding.Scheme);
}
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 2: Load base address: {0}", baseUri);
Uri brokerUri = ApplySessionId(baseUri, sharedData.BrokerInfo.SessionId, "Custom", sharedData.BrokerInfo.EnableFQDN);
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 3: Generate broker uri: {0}", brokerUri);
// Build the frontend
if (duplex)
{
result.FrontEnd = new DuplexFrontEnd(brokerUri, binding, observer, clientManager, brokerAuth, sharedData);
}
else
{
if (binding.CanBuildChannelListener <IReplySessionChannel>())
{
result.FrontEnd = new RequestReplyFrontEnd <IReplySessionChannel>(brokerUri, binding, observer, clientManager, brokerAuth, sharedData);
}
else if (binding.CanBuildChannelListener <IReplyChannel>())
{
result.FrontEnd = new RequestReplyFrontEnd <IReplyChannel>(brokerUri, binding, observer, clientManager, brokerAuth, sharedData);
}
else
{
ThrowHelper.ThrowSessionFault(SOAFaultCode.Broker_BindingNotSupported, SR.BindingNotSupported, binding.Name);
}
}
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 4: Build broker frontend succeeded.");
BrokerTracing.EtwTrace.LogFrontendCreated(
sharedData.BrokerInfo.SessionId,
"Custom",
result.FrontEnd.ListenUri);
Uri controllerUri = ApplySessionId(baseUri, sharedData.BrokerInfo.SessionId, "Custom", sharedData.BrokerInfo.EnableFQDN);
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 5: Generate controller base address: {0}", controllerUri);
result.ControllerFrontend = new ServiceHost(typeof(BrokerController), controllerUri);
BindingHelper.ApplyDefaultThrottlingBehavior(result.ControllerFrontend);
ServiceEndpoint controllerEndpoint = result.ControllerFrontend.AddServiceEndpoint(typeof(IController), binding, DefaultControllerPostfix);
controllerEndpoint.Behaviors.Add(new ControllerFrontendProvider(false, clientManager, brokerAuth, observer, null));
result.ControllerUri = controllerEndpoint.ListenUri.AbsoluteUri;
// Check if the binding supports duplex channel
// If so, create GetResponse frontend
if (binding.CanBuildChannelListener <IDuplexChannel>() || binding.CanBuildChannelListener <IDuplexSessionChannel>())
{
ServiceEndpoint getResponseEndpoint = result.ControllerFrontend.AddServiceEndpoint(typeof(IResponseService), binding, DefaultGetResponsePostfix);
getResponseEndpoint.Behaviors.Add(new ControllerFrontendProvider(false, clientManager, brokerAuth, observer, null));
result.GetResponseUri = getResponseEndpoint.ListenUri.AbsoluteUri;
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 6: Build controller frontend succeeded: ControllerUri = {0}, GetResponseUri = {1}", result.ControllerUri, result.GetResponseUri);
}
else
{
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 6: Build controller frontend succeeded: ControllerUri = {0}", result.ControllerUri);
}
BrokerTracing.TraceVerbose("[FrontEndBuilder] Building custom frontend succeeded.");
BrokerTracing.EtwTrace.LogFrontendControllerCreated(
sharedData.BrokerInfo.SessionId,
"Custom",
result.ControllerUri,
result.GetResponseUri ?? String.Empty);
return(result);
}
/// <summary>
/// Build the http frontend
/// </summary>
/// <param name="sharedData">indicating the shared data</param>
/// <param name="observer">indicating the broker observer</param>
/// <param name="clientManager">indicating the client manager</param>
/// <param name="brokerAuth">indicating the broker authorization</param>
/// <param name="bindings">indicating the bindings</param>
/// <returns>frontend info</returns>
private static FrontendInfo BuildHttpFrontend(SharedData sharedData, BrokerObserver observer, BrokerClientManager clientManager, BrokerAuthorization brokerAuth, BindingsSection bindings, AzureQueueProxy azureQueueProxy)
{
FrontendInfo result = new FrontendInfo();
BrokerTracing.TraceVerbose("[FrontEndBuilder] Start building http frontend...");
// Get binding from configuration file
Binding binding = BindingHelper.GetBinding(TransportScheme.Http, sharedData.StartInfo.Secure, bindings);
// Sync frontend binding.receiveTimeout with loadBalancing.ServiceOperationTimeout if its enabled (>0)
int serviceOperationTimeout = sharedData.Config.LoadBalancing.ServiceOperationTimeout;
if (serviceOperationTimeout > 0)
{
binding.SendTimeout = TimeSpan.FromMilliseconds(serviceOperationTimeout);
}
// Set frontend binding.ReceiveTimeout to max
binding.ReceiveTimeout = TimeSpan.MaxValue;
// Get message size and reader quotas
int maxMessageSize = sharedData.ServiceConfig.MaxMessageSize;
if (maxMessageSize > 0)
{
BindingHelper.ApplyMaxMessageSize(binding, maxMessageSize);
result.MaxMessageSize = maxMessageSize;
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 1: Apply global MaxMessageSize:{0}\n", result.MaxMessageSize);
}
else
{
BindingElementCollection collection = binding.CreateBindingElements();
result.MaxMessageSize = collection.Find <TransportBindingElement>().MaxReceivedMessageSize;
result.ReaderQuotas = binding.GetProperty <XmlDictionaryReaderQuotas>(new BindingParameterCollection());
StringBuilder sb = new StringBuilder();
BrokerTracing.WriteProperties(sb, result.ReaderQuotas, 3, typeof(int));
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 1: Load binding data:\nMaxMessageSize = {0}\n[ReaderQuotas]\n{1}", result.MaxMessageSize, sb.ToString());
}
result.Binding = binding;
BrokerTracing.EtwTrace.LogFrontendBindingLoaded(
sharedData.BrokerInfo.SessionId,
"Http",
result.MaxMessageSize,
binding.ReceiveTimeout.Ticks,
binding.SendTimeout.Ticks,
binding.MessageVersion.ToString(),
binding.Scheme);
// Generate the http uri
Uri basehttpUri = sharedData.Config.Services.GetBrokerBaseAddress(sharedData.StartInfo.Secure ? HttpsScheme : HttpScheme);
if (basehttpUri == null)
{
basehttpUri = new Uri(sharedData.StartInfo.Secure ? DefaultHttpsFrontEndServiceUri : DefaultHttpFrontEndServiceUri);
}
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 2: Load base address: {0}", basehttpUri);
Uri brokerHttpUri = ApplySessionId(basehttpUri, sharedData.BrokerInfo.SessionId, "Http", sharedData.BrokerInfo.EnableFQDN);
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 3: Generate broker uri: {0}", brokerHttpUri);
// Build the frontend
if (sharedData.StartInfo.UseAzureStorage == true)
{
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: AzureQueueFrontEnd");
result.FrontEnd = new AzureQueueFrontEnd(azureQueueProxy, brokerHttpUri, observer, clientManager, brokerAuth, sharedData);
}
else
{
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: HttpFrontEnd");
result.FrontEnd = new RequestReplyFrontEnd <IReplyChannel>(brokerHttpUri, binding, observer, clientManager, brokerAuth, sharedData);
//result.FrontEnd = new OutputInputFrontEnd<IInputChannel>(brokerHttpUri, binding, observer, clientManager, brokerAuth, sharedData);
}
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 4: Build broker frontend succeeded.");
BrokerTracing.EtwTrace.LogFrontendCreated(
sharedData.BrokerInfo.SessionId,
"Http",
result.FrontEnd.ListenUri);
Uri controllerHttpUri = ApplySessionId(basehttpUri, sharedData.BrokerInfo.SessionId, "Http", sharedData.BrokerInfo.EnableFQDN);
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 5: Generate controller base address: {0}", controllerHttpUri);
// Bug 3012: Force the http frontend using the singleton instance
result.ControllerFrontend = new ServiceHost(typeof(BrokerController), controllerHttpUri);
BindingHelper.ApplyDefaultThrottlingBehavior(result.ControllerFrontend);
ServiceBehaviorAttribute behavior = result.ControllerFrontend.Description.Behaviors.Find <ServiceBehaviorAttribute>();
Debug.Assert(behavior != null, "BrokerController must have a behavior.");
behavior.InstanceContextMode = InstanceContextMode.Single;
ServiceEndpoint endpoint = result.ControllerFrontend.AddServiceEndpoint(typeof(IController), binding, DefaultControllerPostfix);
if (sharedData.StartInfo.UseAzureStorage == true)
{
endpoint.Behaviors.Add(new ControllerFrontendProvider(true, clientManager, brokerAuth, observer, azureQueueProxy));
}
else
{
endpoint.Behaviors.Add(new ControllerFrontendProvider(true, clientManager, brokerAuth, observer, null));
}
result.ControllerUri = endpoint.ListenUri.AbsoluteUri;
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 6: Build controller frontend succeeded: ControllerUri = {0}", result.ControllerUri);
result.GetResponseUri = null;
BrokerTracing.TraceVerbose("[FrontEndBuilder] Building http frontend succeeded.");
BrokerTracing.EtwTrace.LogFrontendControllerCreated(
sharedData.BrokerInfo.SessionId,
"Http",
result.ControllerUri,
String.Empty);
return(result);
}
/// <summary>
/// Build the NetHttp frontend
/// </summary>
/// <param name="sharedData">indicating the shared data</param>
/// <param name="observer">indicating the broker observer</param>
/// <param name="clientManager">indicating the client manager</param>
/// <param name="brokerAuth">indicating the broker authorization</param>
/// <param name="bindings">indicating the bindings</param>
/// <returns>frontend info</returns>
private static FrontendInfo BuildNetHttpFrontend(SharedData sharedData, BrokerObserver observer, BrokerClientManager clientManager, BrokerAuthorization brokerAuth, BindingsSection bindings)
{
FrontendInfo result = new FrontendInfo();
BrokerTracing.TraceVerbose("[FrontEndBuilder] Start building NetHttp frontend...");
// Get binding from configuration file
Binding binding = BindingHelper.GetBinding(TransportScheme.NetHttp, sharedData.StartInfo.Secure, bindings);
// Sync frontend binding.receiveTimeout with loadBalancing.ServiceOperationTimeout if its enabled (>0)
int serviceOperationTimeout = sharedData.Config.LoadBalancing.ServiceOperationTimeout;
if (serviceOperationTimeout > 0)
{
binding.SendTimeout = TimeSpan.FromMilliseconds(serviceOperationTimeout);
}
// Set frontend binding.ReceiveTimeout to max
binding.ReceiveTimeout = TimeSpan.MaxValue;
// Update backend binding's maxMessageSize settings with global maxMessageSize if its enabled (> 0)
int maxMessageSize = sharedData.ServiceConfig.MaxMessageSize;
if (maxMessageSize > 0)
{
BindingHelper.ApplyMaxMessageSize(binding, maxMessageSize);
result.MaxMessageSize = maxMessageSize;
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 1: Apply global MaxMessageSize:{0}\n", result.MaxMessageSize);
}
else
{
// Get message size and reader quotas
BindingElementCollection collection = binding.CreateBindingElements();
result.MaxMessageSize = collection.Find <TransportBindingElement>().MaxReceivedMessageSize;
result.ReaderQuotas = binding.GetProperty <XmlDictionaryReaderQuotas>(new BindingParameterCollection());
StringBuilder sb = new StringBuilder();
BrokerTracing.WriteProperties(sb, result.ReaderQuotas, 3, typeof(int));
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 1: Load binding data:\nMaxMessageSize = {0}\n[ReaderQuotas]\n{1}", result.MaxMessageSize, sb.ToString());
}
result.Binding = binding;
BrokerTracing.EtwTrace.LogFrontendBindingLoaded(
sharedData.BrokerInfo.SessionId,
"NetHttp",
result.MaxMessageSize,
binding.ReceiveTimeout.Ticks,
binding.SendTimeout.Ticks,
binding.MessageVersion.ToString(),
binding.Scheme);
// Generate the http uri
Uri basehttpUri = sharedData.Config.Services.GetBrokerBaseAddress(sharedData.StartInfo.Secure ? HttpsScheme : HttpScheme);
if (basehttpUri == null)
{
basehttpUri = new Uri(sharedData.StartInfo.Secure ? DefaultHttpsFrontEndServiceUri : DefaultHttpFrontEndServiceUri);
}
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 2: Load base address: {0}", basehttpUri);
Uri brokerNetHttpUri = ApplySessionId(basehttpUri, sharedData.BrokerInfo.SessionId, "NetHttp", sharedData.BrokerInfo.EnableFQDN);
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 3: Generate broker uri: {0}", brokerNetHttpUri);
// Build the frontend
result.FrontEnd = new DuplexFrontEnd(brokerNetHttpUri, binding, observer, clientManager, brokerAuth, sharedData);
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 4: Build broker frontend succeeded.");
BrokerTracing.EtwTrace.LogFrontendCreated(
sharedData.BrokerInfo.SessionId,
"NetHttp",
result.FrontEnd.ListenUri);
Uri controllerNetHttpUri = ApplySessionId(basehttpUri, sharedData.BrokerInfo.SessionId, "NetHttp", sharedData.BrokerInfo.EnableFQDN);
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 5: Generate controller base address: {0}", controllerNetHttpUri);
result.ControllerFrontend = new ServiceHost(typeof(BrokerController), controllerNetHttpUri);
BindingHelper.ApplyDefaultThrottlingBehavior(result.ControllerFrontend);
ServiceEndpoint controllerEndpoint = result.ControllerFrontend.AddServiceEndpoint(typeof(IController), binding, DefaultControllerPostfix);
controllerEndpoint.Behaviors.Add(new ControllerFrontendProvider(false, clientManager, brokerAuth, observer, null));
result.ControllerUri = controllerEndpoint.ListenUri.AbsoluteUri;
ServiceEndpoint getResponseEndpoint = result.ControllerFrontend.AddServiceEndpoint(typeof(IResponseService), binding, DefaultGetResponsePostfix);
getResponseEndpoint.Behaviors.Add(new ControllerFrontendProvider(false, clientManager, brokerAuth, observer, null));
result.GetResponseUri = getResponseEndpoint.ListenUri.AbsoluteUri;
BrokerTracing.TraceVerbose("[FrontEndBuilder] Build frontend: Step 6: Build controller frontend succeeded: ControllerUri = {0}, GetResponseUri = {1}", result.ControllerUri, result.GetResponseUri);
BrokerTracing.TraceVerbose("[FrontEndBuilder] Building NetHttp frontend succeeded.");
BrokerTracing.EtwTrace.LogFrontendControllerCreated(
sharedData.BrokerInfo.SessionId,
"NetHttp",
result.ControllerUri,
result.GetResponseUri);
return(result);
}
