//internal void ReleasePerformanceCounters()
//{
// if (PerformanceCounters.PerformanceCountersEnabled)
// {
// PerformanceCounters.ReleasePerformanceCountersForEndpoint(this.perfCounterId, this.perfCounterBaseId);
// }
//}
//internal bool SetPerfCounterId()
//{
// Uri keyUri = null;
// if (null != this.ListenUri)
// {
// keyUri = this.ListenUri;
// }
// else
// {
// EndpointAddress endpointAddress = this.EndpointAddress;
// if (null != endpointAddress)
// {
// keyUri = endpointAddress.Uri;
// }
// }
// if (null != keyUri)
// {
// this.perfCounterBaseId = keyUri.AbsoluteUri.ToUpperInvariant();
// this.perfCounterId = this.perfCounterBaseId + "/" + contractName.ToUpperInvariant();
// return true;
// }
// else
// {
// return false;
// }
//}
void ThrowIfDisposedOrImmutable()
{
ChannelDispatcher channelDispatcher = this.channelDispatcher;
if (channelDispatcher != null)
{
channelDispatcher.ThrowIfDisposedOrImmutable();
}
}
internal DispatchRuntime(ClientRuntime proxyRuntime, SharedRuntimeState shared)
: this(shared)
{
this.proxyRuntime = proxyRuntime ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(proxyRuntime));
instanceProvider = new CallbackInstanceProvider();
channelDispatcher = new ChannelDispatcher(shared);
instanceContextProvider = InstanceContextProviderBase.GetProviderForMode(InstanceContextMode.PerSession, this);
Fx.Assert(!shared.IsOnServer, "Client constructor called on server?");
}
internal void Attach(ChannelDispatcher channelDispatcher)
{
if (ChannelDispatcher != null)
{
Exception error = new InvalidOperationException(SR.SFxEndpointDispatcherMultipleChannelDispatcher0);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
}
ChannelDispatcher = channelDispatcher ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(channelDispatcher));
// TODO: Plumb through the listening Uri
//listenUri = channelDispatcher.Listener?.Uri;
}
internal ErrorHandlingAcceptor(IListenerBinder binder, ChannelDispatcher dispatcher)
{
if (binder == null)
{
Fx.Assert("binder is null");
}
if (dispatcher == null)
{
Fx.Assert("dispatcher is null");
}
this.binder = binder;
this.dispatcher = dispatcher;
}
internal ErrorBehavior(ChannelDispatcher channelDispatcher)
{
if (channelDispatcher?.ErrorHandlers == null)
{
Handlers = EmptyArray <IErrorHandler> .Allocate(0);
}
else
{
Handlers = EmptyArray <IErrorHandler> .ToArray(channelDispatcher.ErrorHandlers);
}
_debug = channelDispatcher.IncludeExceptionDetailInFaults;
//isOnServer = channelDispatcher.IsOnServer;
_isOnServer = true;
_messageVersion = channelDispatcher.MessageVersion;
}
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ServiceThrottle throttle,
ServiceDispatcher serviceDispatcher, bool wasChannelThrottled, SessionIdleManager idleManager)
{
ChannelDispatcher channelDispatcher = serviceDispatcher.ChannelDispatcher;
_serviceDispatcher = serviceDispatcher;
_messageVersion = messageVersion;
_isManualAddressing = channelDispatcher.ManualAddressing;
_binder = binder;
_throttle = throttle;
_wasChannelThrottled = wasChannelThrottled;
_host = channelDispatcher.Host;
_duplexBinder = binder as DuplexChannelBinder;
_hasSession = binder.HasSession;
_isConcurrent = ConcurrencyBehavior.IsConcurrent(channelDispatcher, _hasSession);
// TODO: Work out if MultipleReceiveBinder is necessary
//if (channelDispatcher.MaxPendingReceives > 1)
//{
// // We need to preserve order if the ChannelHandler is not concurrent.
// this.binder = new MultipleReceiveBinder(
// this.binder,
// channelDispatcher.MaxPendingReceives,
// !this.isConcurrent);
//}
if (channelDispatcher.BufferedReceiveEnabled)
{
_binder = new BufferedReceiveBinder(_binder);
}
_idleManager = idleManager;
if (_binder.HasSession)
{
_sessionOpenNotification = _binder.Channel.GetProperty <SessionOpenNotification>();
_needToCreateSessionOpenNotificationMessage = _sessionOpenNotification != null && _sessionOpenNotification.IsEnabled;
}
//_requestInfo = new RequestInfo(this);
// TODO: Wire up lifetime management in place of listener state
//if (this.listener.State == CommunicationState.Opened)
//{
_serviceDispatcher.ChannelDispatcher.Channels.IncrementActivityCount();
_incrementedActivityCountInConstructor = true;
//}
}
internal void Detach(ChannelDispatcher channelDispatcher)
{
if (channelDispatcher == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(channelDispatcher));
}
if (this.channelDispatcher != channelDispatcher)
{
Exception error = new InvalidOperationException(SR.SFxEndpointDispatcherDifferentChannelDispatcher0);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
}
//this.ReleasePerformanceCounters();
this.channelDispatcher = null;
}
void TransferChannelFromPendingList(MessageRpc rpc)
{
if (rpc.Channel.IsPending)
{
rpc.Channel.IsPending = false;
ChannelDispatcher channelDispatcher = rpc.Channel.ChannelDispatcher;
IInstanceContextProvider provider = InstanceBehavior.InstanceContextProvider;
if (!InstanceContextProviderBase.IsProviderSessionful(provider) &&
!InstanceContextProviderBase.IsProviderSingleton(provider))
{
IChannel proxy = rpc.Channel.Proxy as IChannel;
if (!rpc.InstanceContext.IncomingChannels.Contains(proxy))
{
channelDispatcher.Channels.Add(proxy);
}
}
// TODO: Do we need to keep track of pending channels with the new hosting model?
//channelDispatcher.PendingChannels.Remove(rpc.Channel.Binder.Channel);
}
}
internal ListenerHandler(IListenerBinder listenerBinder, ChannelDispatcher channelDispatcher, ServiceHostBase host, /*ServiceThrottle throttle,*/ IDefaultCommunicationTimeouts timeouts)
{
this.listenerBinder = listenerBinder;
if (!((this.listenerBinder != null)))
{
Fx.Assert("ListenerHandler.ctor: (this.listenerBinder != null)");
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(listenerBinder));
}
this.channelDispatcher = channelDispatcher;
if (!((this.channelDispatcher != null)))
{
Fx.Assert("ListenerHandler.ctor: (this.channelDispatcher != null)");
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(channelDispatcher));
}
this.host = host;
if (!((this.host != null)))
{
Fx.Assert("ListenerHandler.ctor: (this.host != null)");
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(host));
}
//this.throttle = throttle;
//if (!((this.throttle != null)))
//{
// Fx.Assert("ListenerHandler.ctor: (this.throttle != null)");
// throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(throttle));
//}
this.timeouts = timeouts;
//endpoints = channelDispatcher.EndpointDispatcherTable;
acceptor = new ErrorHandlingAcceptor(listenerBinder, channelDispatcher);
closingTokenSource = new CancellationTokenSource();
}
public ServiceDispatcher(ChannelDispatcher channelDispatcher)
{
ChannelDispatcher = channelDispatcher;
// TODO: Maybe make lazy
_requestReplyCorrelator = new RequestReplyCorrelator();
}
internal ChannelDispatcherBehaviorCollection(ChannelDispatcher outer)
: base(outer.ThisLock)
{
_outer = outer;
}
internal EndpointDispatcherCollection(ChannelDispatcher owner)
: base(owner.ThisLock)
{
_owner = owner;
}
internal ErrorHandlingReceiver(IChannelBinder binder, ChannelDispatcher dispatcher)
{
this.binder = binder;
this.dispatcher = dispatcher;
}
public object Invoke(object instance, object[] inputs, out object[] outputs)
{
outputs = EmptyArray <object> .Allocate(0);
Message message = inputs[0] as Message;
if (message == null)
{
return(null);
}
string action = message.Headers.Action;
//if (DiagnosticUtility.ShouldTraceInformation)
//{
// TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.UnhandledAction,
// SR.TraceCodeUnhandledAction,
// new StringTraceRecord("Action", action),
// this, null, message);
//}
FaultCode code = FaultCode.CreateSenderFaultCode(AddressingStrings.ActionNotSupported,
message.Version.Addressing.Namespace);
string reasonText = SR.Format(SR.SFxNoEndpointMatchingContract, action);
FaultReason reason = new FaultReason(reasonText);
FaultException exception = new FaultException(reason, code);
ErrorBehavior.ThrowAndCatch(exception);
ServiceChannel serviceChannel = OperationContext.Current.InternalServiceChannel;
OperationContext.Current.OperationCompleted +=
delegate(object sender, EventArgs e)
{
ChannelDispatcher channelDispatcher = dispatchRuntime.ChannelDispatcher;
if (!channelDispatcher.HandleError(exception) && serviceChannel.HasSession)
{
try
{
var helper = new TimeoutHelper(ChannelHandler.CloseAfterFaultTimeout);
serviceChannel.CloseAsync(helper.GetCancellationToken()).GetAwaiter().GetResult();
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
channelDispatcher.HandleError(ex);
}
}
};
if (dispatchRuntime.shared.EnableFaults)
{
MessageFault fault = MessageFault.CreateFault(code, reason, action);
return(Message.CreateMessage(message.Version, fault, message.Version.Addressing.DefaultFaultAction));
}
else
{
OperationContext.Current.RequestContext.CloseAsync().GetAwaiter().GetResult();
OperationContext.Current.RequestContext = null;
return(null);
}
}