private HostedHttpTransportManager CreateTransportManager(BaseUriWithWildcard listenAddress)
{
UriPrefixTable <ITransportManagerRegistration> staticTransportManagerTable = null;
if (object.ReferenceEquals(base.Scheme, Uri.UriSchemeHttp))
{
staticTransportManagerTable = HttpChannelListener.StaticTransportManagerTable;
}
else
{
staticTransportManagerTable = SharedHttpsTransportManager.StaticTransportManagerTable;
}
HostedHttpTransportManager item = null;
lock (staticTransportManagerTable)
{
ITransportManagerRegistration registration;
if (!staticTransportManagerTable.TryLookupUri(listenAddress.BaseAddress, listenAddress.HostNameComparisonMode, out registration))
{
item = new HostedHttpTransportManager(listenAddress);
staticTransportManagerTable.RegisterUri(listenAddress.BaseAddress, listenAddress.HostNameComparisonMode, item);
}
}
return(item);
}
internal BaseUriWithWildcard FindBaseAddress(Uri uri)
{
BaseUriWithWildcard wildcard = null;
BaseUriWithWildcard wildcard2 = null;
for (int i = 0; i < this.listenAddresses.Count; i++)
{
if ((string.Compare(this.listenAddresses[i].BaseAddress.Scheme, uri.Scheme, StringComparison.OrdinalIgnoreCase) == 0) && (this.listenAddresses[i].BaseAddress.Port == uri.Port))
{
if (this.listenAddresses[i].HostNameComparisonMode == HostNameComparisonMode.StrongWildcard)
{
return(this.listenAddresses[i]);
}
if (this.listenAddresses[i].HostNameComparisonMode == HostNameComparisonMode.WeakWildcard)
{
wildcard2 = this.listenAddresses[i];
}
if ((this.listenAddresses[i].HostNameComparisonMode == HostNameComparisonMode.Exact) && (string.Compare(this.listenAddresses[i].BaseAddress.Host, uri.Host, StringComparison.OrdinalIgnoreCase) == 0))
{
wildcard = this.listenAddresses[i];
}
}
}
if (wildcard == null)
{
wildcard = wildcard2;
}
return(wildcard);
}
HostedHttpTransportManager CreateTransportManager(BaseUriWithWildcard listenAddress)
{
UriPrefixTable <ITransportManagerRegistration> table = null;
if (object.ReferenceEquals(this.Scheme, Uri.UriSchemeHttp))
{
table = HttpChannelListener.StaticTransportManagerTable;
}
else
{
table = SharedHttpsTransportManager.StaticTransportManagerTable;
}
HostedHttpTransportManager httpManager = null;
lock (table)
{
ITransportManagerRegistration registration;
if (!table.TryLookupUri(listenAddress.BaseAddress, listenAddress.HostNameComparisonMode, out registration))
{
httpManager = new HostedHttpTransportManager(listenAddress);
table.RegisterUri(listenAddress.BaseAddress, listenAddress.HostNameComparisonMode, httpManager);
}
}
return(httpManager);
}
internal BaseUriWithWildcard FindBaseAddress(Uri uri)
{
BaseUriWithWildcard foundBaseAddress = null;
BaseUriWithWildcard weakBaseAddress = null;
for (int i = 0; i < listenAddresses.Count; i++)
{
if ((string.Compare(listenAddresses[i].BaseAddress.Scheme, uri.Scheme, StringComparison.OrdinalIgnoreCase) == 0) &&
(listenAddresses[i].BaseAddress.Port == uri.Port))
{
if (listenAddresses[i].HostNameComparisonMode == HostNameComparisonMode.StrongWildcard)
{
return(listenAddresses[i]);
}
if (listenAddresses[i].HostNameComparisonMode == HostNameComparisonMode.WeakWildcard)
{
weakBaseAddress = listenAddresses[i];
}
if ((listenAddresses[i].HostNameComparisonMode == HostNameComparisonMode.Exact) &&
(string.Compare(listenAddresses[i].BaseAddress.Host, uri.Host, StringComparison.OrdinalIgnoreCase) == 0))
{
foundBaseAddress = listenAddresses[i];
}
}
}
if (foundBaseAddress == null)
{
foundBaseAddress = weakBaseAddress;
}
return(foundBaseAddress);
}
public HostedNamedPipeTransportManager(BaseUriWithWildcard baseAddress)
: base(baseAddress.BaseAddress)
{
this.HostNameComparisonMode = baseAddress.HostNameComparisonMode;
this.onViaCallback = new Action <Uri>(OnVia);
this.onDuplicatedViaCallback = new Func <Uri, int>(OnDuplicatedVia);
}
private void CreateTransportManagers()
{
Collection <HostedHttpTransportManager> collection = new Collection <HostedHttpTransportManager>();
foreach (string str in HostedTransportConfigurationManager.MetabaseSettings.GetBindings(base.Scheme))
{
BaseUriWithWildcard listenAddress = BaseUriWithWildcard.CreateHostedUri(base.Scheme, str, HostingEnvironmentWrapper.ApplicationVirtualPath);
bool flag = false;
if (ServiceHostingEnvironment.MultipleSiteBindingsEnabled)
{
listenAddress = new BaseUriWithWildcard(listenAddress.BaseAddress, HostNameComparisonMode.WeakWildcard);
flag = true;
}
HostedHttpTransportManager item = this.CreateTransportManager(listenAddress);
if (item != null)
{
collection.Add(item);
base.ListenAddresses.Add(listenAddress);
}
if (flag)
{
break;
}
}
this.transportManagerDirectory = collection;
}
private void OnOpenInternal(int queueId, Guid token)
{
lock (base.ThisLock)
{
this.queueId = queueId;
this.token = token;
BaseUriWithWildcard baseAddress = new BaseUriWithWildcard(base.ListenUri, base.HostNameComparisonMode);
this.listener = new SharedConnectionListener(baseAddress, queueId, token, this.onDuplicatedViaCallback);
}
}
public ListenerExceptionStatus Register(BaseUriWithWildcard path)
{
if (path.BaseAddress.Scheme == Uri.UriSchemeNetTcp)
{
if (transportType == TransportType.NamedPipe)
{
return(ListenerExceptionStatus.ProtocolUnsupported);
}
maxQueueSize = ListenerConfig.NetTcp.MaxPendingConnections;
transportType = TransportType.Tcp;
}
else if (path.BaseAddress.Scheme == Uri.UriSchemeNetPipe)
{
if (transportType == TransportType.Tcp)
{
return(ListenerExceptionStatus.ProtocolUnsupported);
}
maxQueueSize = ListenerConfig.NetPipe.MaxPendingConnections;
transportType = TransportType.NamedPipe;
}
else
{
return(ListenerExceptionStatus.ProtocolUnsupported);
}
ListenerExceptionStatus status;
int registrationRetries = AppSettings.ListenerRegistrationRetryCount;
do
{
status = RoutingTable.Start(this, path);
if (status == ListenerExceptionStatus.ConflictingRegistration)
{
if (registrationRetries > 0)
{
Thread.Sleep(AppSettings.ListenerRegistrationRetryDelay);
}
}
else
{
break;
}
} while (registrationRetries-- > 0);
if (status == ListenerExceptionStatus.Success)
{
paths.Add(path);
IncrementUrisRegisteredCounters();
OnRegisterCompleted();
}
return(status);
}
internal static ListenerExceptionStatus Start(MessageQueue messageQueue, BaseUriWithWildcard path)
{
if (messageQueue.TransportType == TransportType.Tcp)
{
return(TcpStart(messageQueue, path));
}
else
{
return(NamedPipeStart(messageQueue, path));
}
}
void OnOpenInternal(int queueId, Guid token)
{
lock (ThisLock)
{
this.queueId = queueId;
this.token = token;
BaseUriWithWildcard path = new BaseUriWithWildcard(this.ListenUri, this.HostNameComparisonMode);
listener = new SharedConnectionListener(path, queueId, token, this.onDuplicatedViaCallback);
}
}
public NamedPipeHostedTransportConfiguration() : base(Uri.UriSchemeNetPipe)
{
string[] bindings = HostedTransportConfigurationManager.MetabaseSettings.GetBindings(Uri.UriSchemeNetPipe);
for (int i = 0; i < bindings.Length; i++)
{
BaseUriWithWildcard baseAddress = BaseUriWithWildcard.CreateHostedPipeUri(bindings[i], HostingEnvironmentWrapper.ApplicationVirtualPath);
if (i == 0)
{
this.uniqueManager = new HostedNamedPipeTransportManager(baseAddress);
}
base.ListenAddresses.Add(baseAddress);
NamedPipeChannelListener.StaticTransportManagerTable.RegisterUri(baseAddress.BaseAddress, baseAddress.HostNameComparisonMode, this.uniqueManager);
}
}
internal static void Stop(MessageQueue messageQueue, BaseUriWithWildcard path)
{
if (messageQueue.TransportType == TransportType.Tcp)
{
IPEndPoint endPoint = GetEndPoint(path.BaseAddress);
TransportListener.Stop(endPoint);
tcpMessageQueues.UnregisterUri(path.BaseAddress, path.HostNameComparisonMode);
}
else
{
TransportListener.Stop(path);
namedPipeMessageQueues.UnregisterUri(path.BaseAddress, path.HostNameComparisonMode);
}
}
public override BaseUriWithWildcard GetBaseUri(string transportScheme, Uri listenUri)
{
BaseUriWithWildcard wildcard = null;
HostedTransportConfigurationBase configuration = HostedTransportConfigurationManager.GetConfiguration(transportScheme) as HostedTransportConfigurationBase;
if (configuration != null)
{
wildcard = configuration.FindBaseAddress(listenUri);
if (wildcard == null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.ServiceModel.Activation.SR.Hosting_TransportBindingNotFound(listenUri.ToString())));
}
}
return(wildcard);
}
internal static void Listen(BaseUriWithWildcard pipeUri)
{
lock (namedPipeInstances)
{
if (namedPipeInstances.ContainsKey(pipeUri))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(SR.GetString(SR.PipeAddressAlreadyUsed)));
}
else
{
TransportListener t = new TransportListener(pipeUri);
namedPipeInstances.Add(pipeUri, t);
}
}
}
internal static ListenerExceptionStatus Register(BaseUriWithWildcard path, WorkerProcess worker)
{
MessageQueue queue = null;
lock (registry)
{
if (registry.TryGetValue(path, out queue))
{
if (!queue.CanShare)
{
return(ListenerExceptionStatus.ConflictingRegistration);
}
}
else
{
queue = new MessageQueue();
ListenerExceptionStatus status = ListenerExceptionStatus.FailedToListen;
try
{
status = queue.Register(path);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
if (DiagnosticUtility.ShouldTraceError)
{
ListenerTraceUtility.TraceEvent(TraceEventType.Error, ListenerTraceCode.RoutingTableCannotListen, SR.GetString(SR.TraceCodeRoutingTableCannotListen), new StringTraceRecord("Path", path.ToString()), null, exception);
}
}
if (status != ListenerExceptionStatus.Success)
{
// not setting the worker.queue is not a problem, since we can't use this WorkerProcess
return(status);
}
registry.Add(path, queue);
}
}
queue.OnNewWorkerAvailable(worker);
return(ListenerExceptionStatus.Success);
}
public override BaseUriWithWildcard GetBaseUri(string transportScheme, Uri listenUri)
{
BaseUriWithWildcard baseAddress = null;
HostedTransportConfigurationBase hostedConfiguration =
HostedTransportConfigurationManager.GetConfiguration(transportScheme) as HostedTransportConfigurationBase;
if (hostedConfiguration != null)
{
baseAddress = hostedConfiguration.FindBaseAddress(listenUri);
if (baseAddress == null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.Hosting_TransportBindingNotFound(listenUri.ToString())));
}
}
return(baseAddress);
}
TransportListener(BaseUriWithWildcard pipeUri)
{
if (TD.PipeTransportListenerListeningStartIsEnabled())
{
TD.PipeTransportListenerListeningStart(this.EventTraceActivity, (pipeUri.BaseAddress != null) ? pipeUri.BaseAddress.ToString() : string.Empty);
}
transportType = TransportType.NamedPipe;
IConnectionListener connectionListener = new PipeConnectionListener(pipeUri.BaseAddress, pipeUri.HostNameComparisonMode,
ListenerConstants.SharedConnectionBufferSize, null, false, int.MaxValue);
demuxer = Go(connectionListener);
if (TD.PipeTransportListenerListeningStopIsEnabled())
{
TD.PipeTransportListenerListeningStop(this.EventTraceActivity);
}
}
public TcpHostedTransportConfiguration()
: base(Uri.UriSchemeNetTcp)
{
string[] bindings = HostedTransportConfigurationManager.MetabaseSettings.GetBindings(Uri.UriSchemeNetTcp);
for (int i = 0; i < bindings.Length; i++)
{
BaseUriWithWildcard listenAddress = BaseUriWithWildcard.CreateHostedUri(Uri.UriSchemeNetTcp, bindings[i], HostingEnvironmentWrapper.ApplicationVirtualPath);
if (i == 0)
{
Debug.Print("TcpHostedTransportConfiguration.ctor() Creating the unique TcpTransportManager with ListenUri:" + listenAddress.BaseAddress);
uniqueManager = new HostedTcpTransportManager(listenAddress);
}
this.ListenAddresses.Add(listenAddress);
Debug.Print("Registering the unique TcpTransportManager with ListenUri:" + listenAddress.BaseAddress);
TcpChannelListener.StaticTransportManagerTable.RegisterUri(listenAddress.BaseAddress, listenAddress.HostNameComparisonMode, uniqueManager);
}
}
void Unregister(BaseUriWithWildcard path)
{
Fx.Assert(paths.Contains(path), "Unregister: unregistering an unregistered path");
if (DiagnosticUtility.ShouldTraceInformation)
{
ListenerTraceUtility.TraceEvent(TraceEventType.Information, ListenerTraceCode.MessageQueueUnregisterSucceeded, SR.GetString(SR.TraceCodeMessageQueueUnregisterSucceeded), new StringTraceRecord("Path", path.ToString()), this, null);
}
if (TD.MessageQueueUnregisterSucceededIsEnabled())
{
TD.MessageQueueUnregisterSucceeded(this.EventTraceActivity, path.ToString());
}
RoutingTable.Stop(this, path);
IncrementUrisUnregisteredCounters();
OnUnregisterCompleted();
registry.Remove(path);
paths.Remove(path);
}
public ListenerExceptionStatus Register(BaseUriWithWildcard path)
{
if (path.BaseAddress.Scheme == Uri.UriSchemeNetTcp)
{
if (transportType == TransportType.NamedPipe)
{
return(ListenerExceptionStatus.ProtocolUnsupported);
}
maxQueueSize = ListenerConfig.NetTcp.MaxPendingConnections;
transportType = TransportType.Tcp;
}
else if (path.BaseAddress.Scheme == Uri.UriSchemeNetPipe)
{
if (transportType == TransportType.Tcp)
{
return(ListenerExceptionStatus.ProtocolUnsupported);
}
maxQueueSize = ListenerConfig.NetPipe.MaxPendingConnections;
transportType = TransportType.NamedPipe;
}
else
{
return(ListenerExceptionStatus.ProtocolUnsupported);
}
ListenerExceptionStatus status = RoutingTable.Start(this, path);
if (status == ListenerExceptionStatus.Success)
{
paths.Add(path);
IncrementUrisRegisteredCounters();
OnRegisterCompleted();
}
return(status);
}
static ListenerExceptionStatus TcpStart(MessageQueue messageQueue, BaseUriWithWildcard path)
{
int encodedSize = System.Text.Encoding.UTF8.GetByteCount(path.BaseAddress.AbsoluteUri);
if (encodedSize > ListenerConstants.MaxUriSize)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
ListenerTraceUtility.TraceEvent(TraceEventType.Information, ListenerTraceCode.RoutingTablePathTooLong, SR.GetString(SR.TraceCodeRoutingTablePathTooLong), new StringTraceRecord("Path", path.ToString()), null, null);
}
return(ListenerExceptionStatus.PathTooLong);
}
IPEndPoint endPoint = GetEndPoint(path.BaseAddress);
lock (tcpMessageQueues)
{
if (tcpMessageQueues.IsRegistered(path))
{
if (DiagnosticUtility.ShouldTraceInformation)
{
ListenerTraceUtility.TraceEvent(TraceEventType.Information, ListenerTraceCode.RoutingTableNamespaceConflict, SR.GetString(SR.TraceCodeRoutingTableNamespaceConflict), new StringTraceRecord("Path", path.ToString()), null, null);
}
return(ListenerExceptionStatus.ConflictingRegistration);
}
TransportListener.Listen(endPoint);
tcpMessageQueues.RegisterUri(path.BaseAddress, path.HostNameComparisonMode, new MessageQueueAndPath(messageQueue, path.BaseAddress));
}
if (DiagnosticUtility.ShouldTraceInformation)
{
ListenerTraceUtility.TraceEvent(TraceEventType.Information, ListenerTraceCode.RoutingTableRegisterSuccess, SR.GetString(SR.TraceCodeRoutingTableRegisterSuccess), new StringTraceRecord("Path", path.ToString()), null, null);
}
return(ListenerExceptionStatus.Success);
}
internal static void Stop(BaseUriWithWildcard pipeUri)
{
lock (namedPipeInstances)
{
TransportListener t = namedPipeInstances[pipeUri] as TransportListener;
if (t != null)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
ListenerTraceUtility.TraceEvent(TraceEventType.Information, ListenerTraceCode.TransportListenerStop, SR.GetString(SR.TraceCodeTransportListenerStop), t);
}
try
{
t.Stop();
}
finally
{
namedPipeInstances.Remove(pipeUri);
}
}
}
}
void CreateTransportManagers()
{
Collection <HostedHttpTransportManager> tempDirectory = new Collection <HostedHttpTransportManager>();
string[] bindings = HostedTransportConfigurationManager.MetabaseSettings.GetBindings(this.Scheme);
foreach (string binding in bindings)
{
TryDebugPrint("HttpHostedTransportConfiguration.CreateTransportManagers() adding binding: " + binding);
BaseUriWithWildcard listenAddress = BaseUriWithWildcard.CreateHostedUri(this.Scheme, binding, HostingEnvironmentWrapper.ApplicationVirtualPath);
bool done = false;
if (ServiceHostingEnvironment.MultipleSiteBindingsEnabled)
{
//In this specific mode we only create one transport manager and all the
//hosted channel listeners hang off of this transport manager
listenAddress = new BaseUriWithWildcard(listenAddress.BaseAddress, HostNameComparisonMode.WeakWildcard);
done = true;
}
HostedHttpTransportManager httpManager = CreateTransportManager(listenAddress);
//httpManager will be null when 2 site bindings differ only in ip address
if (httpManager != null)
{
tempDirectory.Add(httpManager);
ListenAddresses.Add(listenAddress);
}
if (done)
{
break;
}
}
transportManagerDirectory = tempDirectory;
}
ListenerExceptionStatus IActivatedMessageQueue.Register(BaseUriWithWildcard url)
{
return(base.Register(url));
}
ListenerExceptionStatus IConnectionRegister.Register(Version version, int processId, BaseUriWithWildcard path, int queueId, Guid token, string eventName)
{
if (TD.MessageQueueRegisterStartIsEnabled())
{
TD.MessageQueueRegisterStart(this.EventTraceActivity);
}
Debug.Print("WorkerProcess.Register() version: " + version + " processId: " + processId + " path: " + path + " queueId: " + queueId + " token: " + token + " eventName: " + eventName);
if (DiagnosticUtility.ShouldTraceInformation)
{
ListenerTraceUtility.TraceEvent(TraceEventType.Information, ListenerTraceCode.MessageQueueRegisterCalled, SR.GetString(SR.TraceCodeMessageQueueRegisterCalled), new StringTraceRecord("Path", path.ToString()), this, null);
}
// Get the callback channel
this.connectionDuplicator = OperationContext.Current.GetCallbackChannel <IConnectionDuplicator>();
// Prevent this duplicate operation from timing out, faulting the pipe, and stopping any further communication with w3wp
// we're gated by MaxPendingAccepts + MaxPendingConnection. see CSD Main bug 193390 for details
((IContextChannel)this.connectionDuplicator).OperationTimeout = TimeSpan.MaxValue;
ListenerExceptionStatus status = ListenerExceptionStatus.Success;
bool abortInstance = false;
if (path == null || eventName == null)
{
status = ListenerExceptionStatus.InvalidArgument;
abortInstance = true;
goto FAILED;
}
// Vista only: validate remote process ID
if (OSEnvironmentHelper.IsVistaOrGreater)
{
status = ListenerExceptionStatus.InvalidArgument;
object property = OperationContext.Current.IncomingMessage.Properties[ConnectionMessageProperty.Name];
Fx.Assert(property != null, "WorkerProcess.Register() ConnectionMessageProperty not found!");
IConnection connection = property as IConnection;
Fx.Assert(connection != null, "WorkerProcess.Register() ConnectionMessageProperty is not IConnection!");
PipeHandle pipe = connection.GetCoreTransport() as PipeHandle;
Fx.Assert(pipe != null, "WorkerProcess.Register() CoreTransport is not PipeHandle!");
if (processId != pipe.GetClientPid())
{
status = ListenerExceptionStatus.InvalidArgument;
abortInstance = true;
goto FAILED;
}
}
// validate version
Version ourVersion = Assembly.GetExecutingAssembly().GetName().Version;
if (version > ourVersion)
{
// VERSIONING
// in V1 we assume that we can handle earlier versions
// this might not be true when we ship later releases.
Debug.Print("WorkerProcess.Register() unsupported version ourVersion: " + ourVersion + " version: " + version);
status = ListenerExceptionStatus.VersionUnsupported;
goto FAILED;
}
if (queueId == 0 && path == null)
{
status = ListenerExceptionStatus.InvalidArgument;
abortInstance = true;
goto FAILED;
}
this.processId = processId;
this.queueId = 0;
if (queueId != 0)
{
this.queueId = queueId;
status = ActivatedMessageQueue.Register(queueId, token, this);
}
else
{
status = MessageQueue.Register(path, this);
}
if (status == ListenerExceptionStatus.Success)
{
foreach (IChannel channel in OperationContext.Current.InstanceContext.IncomingChannels)
{
channel.Faulted += new EventHandler(WorkerProcess_Faulted);
channel.Closed += new EventHandler(WorkerProcess_Closed);
}
try
{
using (EventWaitHandle securityEvent = EventWaitHandle.OpenExisting(ListenerConstants.GlobalPrefix + eventName, EventWaitHandleRights.Modify))
{
securityEvent.Set();
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
DiagnosticUtility.TraceHandledException(exception, TraceEventType.Error);
status = ListenerExceptionStatus.InvalidArgument;
abortInstance = true;
}
}
if (status != ListenerExceptionStatus.Success)
{
goto FAILED;
}
if (DiagnosticUtility.ShouldTraceInformation)
{
ListenerTraceUtility.TraceEvent(TraceEventType.Information, ListenerTraceCode.MessageQueueRegisterSucceeded, SR.GetString(SR.TraceCodeMessageQueueRegisterSucceeded), new StringTraceRecord("Path", path.ToString()), this, null);
}
if (TD.MessageQueueRegisterCompletedIsEnabled())
{
TD.MessageQueueRegisterCompleted(this.EventTraceActivity, path.ToString());
}
FAILED:
if (abortInstance)
{
if (DiagnosticUtility.ShouldTraceError)
{
ListenerTraceUtility.TraceEvent(TraceEventType.Error, ListenerTraceCode.MessageQueueRegisterFailed, SR.GetString(SR.TraceCodeMessageQueueRegisterFailed),
new StringTraceRecord("Register", SR.GetString(SR.SharingRegistrationFailedAndAbort, status.ToString())), this, null);
}
if (TD.MessageQueueRegisterAbortIsEnabled())
{
TD.MessageQueueRegisterAbort(this.EventTraceActivity,
status.ToString(),
(path != null) ? path.ToString() : string.Empty);
}
AbortServiceInstance();
}
else if (status != ListenerExceptionStatus.Success)
{
if (DiagnosticUtility.ShouldTraceError)
{
ListenerTraceUtility.TraceEvent(TraceEventType.Error, ListenerTraceCode.MessageQueueRegisterFailed, SR.GetString(SR.TraceCodeMessageQueueRegisterFailed),
new StringTraceRecord("Register", SR.GetString(SR.SharingRegistrationFailed, status.ToString())), this, null);
}
if (TD.MessageQueueRegisterFailedIsEnabled())
{
TD.MessageQueueRegisterFailed(this.EventTraceActivity,
(path != null) ? path.ToString() : string.Empty,
status.ToString());
}
InitiateClosingServiceInstance();
}
return(status);
}
internal HostedHttpTransportManager(BaseUriWithWildcard baseAddress) : base(baseAddress.BaseAddress, baseAddress.HostNameComparisonMode)
{
base.IsHosted = true;
}
public ListenerExceptionStatus Register(BaseUriWithWildcard url)
{
this.activationService.Bindings.RegisterBindingFilterIfNecessary(url.BaseAddress.Host, this.filter);
return(ListenerExceptionStatus.Success);
}
bool RegisterBindings(IActivatedMessageQueue queue, int siteId, string[] bindings, string path)
{
Debug.Print("ListenerAdapter[" + ProtocolName + "]::RegisterBindings() bindings#: " + bindings.Length);
BaseUriWithWildcard[] baseAddresses = new BaseUriWithWildcard[bindings.Length];
// first make sure all the bindings are valid for this protocol
for (int i = 0; i < bindings.Length; i++)
{
string binding = bindings[i];
int index = binding.IndexOf(':');
string protocol = binding.Substring(0, index);
if (string.Compare(this.ProtocolName, protocol, StringComparison.OrdinalIgnoreCase) != 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.LAProtocolMismatch, protocol, path, this.ProtocolName)));
}
binding = binding.Substring(index + 1);
try
{
baseAddresses[i] = BaseUriWithWildcard.CreateHostedUri(ProtocolName, binding, path);
Debug.Print("ListenerAdapter[" + ProtocolName + "]::RegisterBindings() CreateUrlFromBinding(binding: " + binding + " path: " + path + ") returned baseAddress: " + baseAddresses[i]);
}
catch (UriFormatException exception)
{
Debug.Print("ListenerAdapter[" + ProtocolName + "]::RegisterBindings() CreateUrlFromBinding(binding: " + binding + " path: " + path + ") failed with UriFormatException: " + exception.Message);
DiagnosticUtility.TraceHandledException(exception, TraceEventType.Error);
// We only log the event for the site root.
if (string.Compare(path, SiteRootPath, StringComparison.OrdinalIgnoreCase) == 0)
{
DiagnosticUtility.EventLog.LogEvent(TraceEventType.Error,
(ushort)EventLogCategory.ListenerAdapter,
(uint)EventLogEventId.BindingError,
protocol,
binding,
siteId.ToString(NumberFormatInfo.CurrentInfo),
bindings[i],
ListenerTraceUtility.CreateSourceString(this),
exception.ToString());
}
return(false);
}
}
// now make sure all the bindings can be listened on or roll back
for (int i = 0; i < bindings.Length; i++)
{
ListenerExceptionStatus status = ListenerExceptionStatus.FailedToListen;
Exception exception = null;
try
{
status = queue.Register(baseAddresses[i]);
Debug.Print("ListenerAdapter[" + ProtocolName + "]::RegisterBindings() registering baseAddress: " + baseAddresses[i] + " with queue returned: " + status);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
DiagnosticUtility.TraceHandledException(exception, TraceEventType.Error);
exception = ex;
}
if (status != ListenerExceptionStatus.Success)
{
// We only log the event for the site root.
if (string.Compare(path, SiteRootPath, StringComparison.OrdinalIgnoreCase) == 0)
{
DiagnosticUtility.EventLog.LogEvent(TraceEventType.Error,
(ushort)EventLogCategory.ListenerAdapter,
(uint)EventLogEventId.LAFailedToListenForApp,
activationService.ActivationServiceName,
ProtocolName,
siteId.ToString(NumberFormatInfo.CurrentInfo),
baseAddresses[i].ToString(),
status.ToString(),
exception == null ? string.Empty : exception.ToString());
}
queue.UnregisterAll();
return(false);
}
}
return(true);
}
public HostedTcpTransportManager(BaseUriWithWildcard baseAddress)
: base(baseAddress.BaseAddress)
{
this.HostNameComparisonMode = baseAddress.HostNameComparisonMode;
this.onViaCallback = new Action <Uri>(OnVia);
}
