public override void ApplyHostedContext(TransportChannelListener listener, BindingContext context)
{
VirtualPathExtension extension = context.BindingParameters.Find<VirtualPathExtension>();
if (extension != null)
{
HostedMetadataBindingParameter parameter = context.BindingParameters.Find<HostedMetadataBindingParameter>();
listener.ApplyHostedContext(extension.VirtualPath, parameter != null);
}
}
private TransportManagerContainer(TransportManagerContainer source)
{
this.listener = source.listener;
this.tableLock = source.tableLock;
this.transportManagers = new List<TransportManager>();
for (int i = 0; i < source.transportManagers.Count; i++)
{
this.transportManagers.Add(source.transportManagers[i]);
}
}
public override void ApplyHostedContext(TransportChannelListener listener, BindingContext context)
{
VirtualPathExtension virtualPathExtension = context.BindingParameters.Find <VirtualPathExtension>();
if (virtualPathExtension != null)
{
HostedMetadataBindingParameter metadataBindingParameter = context.BindingParameters.Find <HostedMetadataBindingParameter>();
listener.ApplyHostedContext(virtualPathExtension.VirtualPath, metadataBindingParameter != null);
}
}
public override IList <TransportManager> Select(TransportChannelListener channelListener)
{
SocketConnectionChannelListener socketConnectionChannelListener = (SocketConnectionChannelListener)channelListener;
if (!this.IsCompatible(socketConnectionChannelListener))
{
return(null);
}
IList <TransportManager> transportManagers = new List <TransportManager>();
this.ProcessSelection(socketConnectionChannelListener, ref this.transportManager, transportManagers);
return(transportManagers);
}
public ChannelDispatcherModel(ChannelDispatcherBase channelDispatcher)
{
if (channelDispatcher == null)
{
return;
}
IChannelListener listener = channelDispatcher?.Listener;
if (listener != null)
{
this.ListenerUri = listener.Uri?.ToString();
this.ListenerState = listener.State;
TransportChannelListener transportListener = listener as TransportChannelListener;
if (transportListener != null)
{
this.MessageEncoder = transportListener?.MessageEncoderFactory?.Encoder.GetType().FullName;
}
}
ChannelDispatcher dispatcher = channelDispatcher as ChannelDispatcher;
if (dispatcher != null)
{
this.State = dispatcher.State;
this.BindingName = dispatcher.BindingName;
this.ServiceThrottle = new ServiceThrottleModel(dispatcher.ServiceThrottle);
this.CommunicationTimeouts = new CommunicationTimeoutsModel(dispatcher.DefaultCommunicationTimeouts);
if (dispatcher.Endpoints != null && dispatcher.Endpoints.Count > 0)
{
EndpointDispatcher endpointDispatcher = dispatcher.Endpoints[0];
if (endpointDispatcher != null)
{
this.ContractName = endpointDispatcher.ContractName;
this.IsSystemEndpoint = endpointDispatcher.IsSystemEndpoint;
this.MessageInspectors = GetMessageInspectors(endpointDispatcher);
}
}
}
}
internal override void Register(TransportChannelListener channelListener)
{
UriPrefixTable<HttpChannelListener> table;
string method = ((HttpChannelListener) channelListener).Method;
if (!this.addressTables.TryGetValue(method, out table))
{
lock (base.ThisLock)
{
if (!this.addressTables.TryGetValue(method, out table))
{
Dictionary<string, UriPrefixTable<HttpChannelListener>> dictionary = new Dictionary<string, UriPrefixTable<HttpChannelListener>>(this.addressTables);
table = new UriPrefixTable<HttpChannelListener>();
dictionary[method] = table;
this.addressTables = dictionary;
}
}
}
table.RegisterUri(channelListener.Uri, channelListener.InheritBaseAddressSettings ? this.hostNameComparisonMode : channelListener.HostNameComparisonModeInternal, (HttpChannelListener) channelListener);
}
public override IList<TransportManager> Select(TransportChannelListener channelListener)
{
bool flag = (base.ListenUri.HostNameType != UriHostNameType.IPv6) && Socket.OSSupportsIPv4;
bool flag2 = (base.ListenUri.HostNameType != UriHostNameType.IPv4) && Socket.OSSupportsIPv6;
TcpChannelListener listener = (TcpChannelListener) channelListener;
if (!this.IsCompatible(listener, flag, flag2))
{
return null;
}
IList<TransportManager> result = new List<TransportManager>();
if (flag)
{
this.ProcessSelection(listener, IPAddress.Any, UriHostNameType.IPv4, ref this.ipv4TransportManager, result);
}
if (flag2)
{
this.ProcessSelection(listener, IPAddress.IPv6Any, UriHostNameType.IPv6, ref this.ipv6TransportManager, result);
}
return result;
}
IList <TransportManager> Microsoft.ServiceBus.Channels.ITransportManagerRegistration.Select(TransportChannelListener channelListener)
{
IList <TransportManager> transportManagers = null;
if (this.IsCompatible(channelListener))
{
transportManagers = new List <TransportManager>()
{
this
};
}
return(transportManagers);
}
IList<TransportManager> ITransportManagerRegistration.Select(TransportChannelListener channelListener)
{
IList<TransportManager> result = null;
if (this.IsCompatible((HttpChannelListener)channelListener))
{
result = new List<TransportManager>();
result.Add(this);
}
return result;
}
internal override void Unregister(TransportChannelListener channelListener)
{
// Nothing to do - we never use the transport manager during normal
// operation.
}
internal override void Register(TransportChannelListener channelListener)
{
channelListener.SetMessageReceivedCallback(new Action(OnMessageReceived));
}
public override IList<TransportManager> Select(TransportChannelListener channelListener)
{
return list;
}
IList<TransportManager> ITransportManagerRegistration.Select(TransportChannelListener channelListener)
{
IList<TransportManager> list = null;
if (this.IsCompatible((HttpChannelListener) channelListener))
{
list = new List<TransportManager> {
this
};
}
return list;
}
internal override void Register(TransportChannelListener channelListener)
{
string method = ((HttpChannelListener)channelListener).Method;
UriPrefixTable<HttpChannelListener> addressTable;
if (!addressTables.TryGetValue(method, out addressTable))
{
lock (ThisLock)
{
if (!addressTables.TryGetValue(method, out addressTable))
{
Dictionary<string, UriPrefixTable<HttpChannelListener>> newAddressTables =
new Dictionary<string, UriPrefixTable<HttpChannelListener>>(addressTables);
addressTable = new UriPrefixTable<HttpChannelListener>();
newAddressTables[method] = addressTable;
addressTables = newAddressTables;
}
}
}
addressTable.RegisterUri(channelListener.Uri,
channelListener.InheritBaseAddressSettings ? hostNameComparisonMode : channelListener.HostNameComparisonModeInternal,
(HttpChannelListener)channelListener);
}
internal override void Unregister(TransportChannelListener channelListener)
{
UriPrefixTable<HttpChannelListener> addressTable;
if (!addressTables.TryGetValue(((HttpChannelListener)channelListener).Method, out addressTable))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(
SR.ListenerFactoryNotRegistered, channelListener.Uri)));
}
HostNameComparisonMode registeredMode = channelListener.InheritBaseAddressSettings ? hostNameComparisonMode : channelListener.HostNameComparisonModeInternal;
EnsureRegistered(addressTable, (HttpChannelListener)channelListener, registeredMode);
addressTable.UnregisterUri(channelListener.Uri, registeredMode);
}
public virtual void ApplyHostedContext(TransportChannelListener listener, BindingContext context)
{
// subclass will push hosted information to the transport listeners
}
protected override void OnOpening()
{
base.OnOpening();
this.transportManagerContainer = this.listener.GetTransportManagers();
this.listener = null;
}
IList<TransportManager> ITransportManagerRegistration.Select(TransportChannelListener channelListener)
{
if (!channelListener.IsScopeIdCompatible(this.hostNameComparisonMode, this.listenUri))
{
return null;
}
this.OnSelecting((TcpChannelListener) channelListener);
IList<TransportManager> list = null;
if (this.IsCompatible((TcpChannelListener) channelListener))
{
list = new List<TransportManager> {
this
};
}
return list;
}
private bool IsCompatible(TransportChannelListener channelListener)
{
return(true);
}
public virtual void ApplyHostedContext(TransportChannelListener listener, BindingContext context)
{
}
IList<TransportManager> ITransportManagerRegistration.Select(TransportChannelListener channelListener)
{
if (!channelListener.IsScopeIdCompatible(this.hostNameComparisonMode, this.listenUri))
{
return null;
}
OnSelecting((TcpChannelListener)channelListener);
IList<TransportManager> result = null;
if (this.IsCompatible((TcpChannelListener)channelListener))
{
result = new List<TransportManager>();
result.Add(this);
}
return result;
}
public TransportReplyChannelAcceptor(TransportChannelListener listener)
: base(listener)
{
this.listener = listener;
}
internal override void Register(TimeSpan timeout, TransportChannelListener channelListener)
{
this.addressTable.RegisterUri(channelListener.Uri, channelListener.HostNameComparisonModeInternal, (AmqpChannelListenerBase)channelListener);
}
public virtual void ApplyHostedContext(TransportChannelListener listener, BindingContext context)
{
}
internal override void Unregister(TimeSpan timeout, TransportChannelListener channelListener)
{
TransportManager.EnsureRegistered <AmqpChannelListenerBase>(this.addressTable, (AmqpChannelListenerBase)channelListener);
this.addressTable.UnregisterUri(channelListener.Uri, channelListener.HostNameComparisonModeInternal);
}
public TransportManagerContainer(TransportChannelListener listener)
{
this.listener = listener;
this.tableLock = listener.TransportManagerTable;
this.transportManagers = new List<TransportManager>();
}
internal override void Unregister(TransportChannelListener channelListener)
{
UriPrefixTable<HttpChannelListener> table;
if (!this.addressTables.TryGetValue(((HttpChannelListener) channelListener).Method, out table))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("ListenerFactoryNotRegistered", new object[] { channelListener.Uri })));
}
System.ServiceModel.HostNameComparisonMode registeredComparisonMode = channelListener.InheritBaseAddressSettings ? this.hostNameComparisonMode : channelListener.HostNameComparisonModeInternal;
TransportManager.EnsureRegistered<HttpChannelListener>(table, (HttpChannelListener) channelListener, registeredComparisonMode);
table.UnregisterUri(channelListener.Uri, registeredComparisonMode);
}
public virtual void ApplyHostedContext(TransportChannelListener listener, BindingContext context)
{
// subclass will push hosted information to the transport listeners
}
public abstract IList<TransportManager> Select(TransportChannelListener factory);
