/// <summary>
/// Set the frontend info for a certain transport scheme
/// </summary>
/// <param name="info">indicating the frontend info</param>
/// <param name="scheme">indicating the transport scheme</param>
public void SetFrontendInfo(FrontendInfo info, TransportScheme scheme)
{
int index = (int)Math.Log((int)scheme, 2);
this.frontendUriList[index] = info.FrontEnd.ListenUri;
this.controllerUriList[index] = info.ControllerUri;
this.getResponseUriList[index] = info.GetResponseUri;
this.frontendList[index] = info.FrontEnd;
this.serviceHostList[index] = info.ControllerFrontend;
// If any frontend does not support addressing or not http binding,
// the session would be treated as not available for Message Details View.
if (info.Binding.MessageVersion.Addressing == AddressingVersion.None && !(info.Binding is BasicHttpBinding))
{
this.supportsMessageDetails = false;
}
if (info.MaxMessageSize > this.maxMessageSize)
{
this.maxMessageSize = info.MaxMessageSize;
}
if (this.readerQuotas == null)
{
this.readerQuotas = info.ReaderQuotas;
}
else
{
if (info.ReaderQuotas.MaxArrayLength > this.readerQuotas.MaxArrayLength)
{
this.readerQuotas.MaxArrayLength = info.ReaderQuotas.MaxArrayLength;
}
if (info.ReaderQuotas.MaxBytesPerRead > this.readerQuotas.MaxBytesPerRead)
{
this.readerQuotas.MaxBytesPerRead = info.ReaderQuotas.MaxBytesPerRead;
}
if (info.ReaderQuotas.MaxDepth > this.readerQuotas.MaxDepth)
{
this.readerQuotas.MaxDepth = info.ReaderQuotas.MaxDepth;
}
if (info.ReaderQuotas.MaxNameTableCharCount > this.readerQuotas.MaxNameTableCharCount)
{
this.readerQuotas.MaxNameTableCharCount = info.ReaderQuotas.MaxNameTableCharCount;
}
if (info.ReaderQuotas.MaxStringContentLength > this.readerQuotas.MaxStringContentLength)
{
this.readerQuotas.MaxStringContentLength = info.ReaderQuotas.MaxStringContentLength;
}
}
}
/// <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);
}