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); }