internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ServiceChannel channel)
{
ClientRuntime clientRuntime = channel.ClientRuntime;
this.messageVersion = messageVersion;
this.isManualAddressing = clientRuntime.ManualAddressing;
this.binder = binder;
this.channel = channel;
this.isConcurrent = true;
this.duplexBinder = binder as DuplexChannelBinder;
this.hasSession = binder.HasSession;
this.isCallback = true;
DispatchRuntime dispatchRuntime = clientRuntime.DispatchRuntime;
if (dispatchRuntime == null)
{
this.receiver = new ErrorHandlingReceiver(binder, null);
}
else
{
this.receiver = new ErrorHandlingReceiver(binder, dispatchRuntime.ChannelDispatcher);
}
this.requestInfo = new RequestInfo(this);
}
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ServiceChannel channel)
{
ClientRuntime clientRuntime = channel.ClientRuntime;
_messageVersion = messageVersion;
_isManualAddressing = clientRuntime.ManualAddressing;
_binder = binder;
_channel = channel;
_isConcurrent = true;
_duplexBinder = binder as DuplexChannelBinder;
_hasSession = binder.HasSession;
_isCallback = true;
DispatchRuntime dispatchRuntime = clientRuntime.DispatchRuntime;
if (dispatchRuntime == null)
{
_receiver = new ErrorHandlingReceiver(binder, null);
}
else
{
_receiver = new ErrorHandlingReceiver(binder, dispatchRuntime.ChannelDispatcher);
}
_requestInfo = new RequestInfo(this);
}
public async Task <IServiceChannelDispatcher> CreateServiceChannelDispatcherAsync(IChannel channel)
{
var sessionIdleManager = channel.GetProperty <ServiceChannel.SessionIdleManager>();
IChannelBinder binder = null;
if (channel is IReplyChannel)
{
var rcbinder = channel.GetProperty <ReplyChannelBinder>();
rcbinder.Init(channel as IReplyChannel, BaseAddress);
binder = rcbinder;
}
else if (channel is IDuplexSessionChannel)
{
var dcbinder = channel.GetProperty <DuplexChannelBinder>();
dcbinder.Init(channel as IDuplexSessionChannel, _requestReplyCorrelator, BaseAddress);
binder = dcbinder;
}
else if (channel is IInputChannel)
{
var icbinder = channel.GetProperty <InputChannelBinder>();
icbinder.Init(channel as IInputChannel, BaseAddress);
binder = icbinder;
}
// TODO: Wire up wasChannelThrottled
var channelHandler = new ChannelHandler(Binding.MessageVersion, binder, channel.GetProperty <ServiceThrottle>(),
this, /*wasChannelThrottled*/ false, sessionIdleManager);
var channelDispatcher = channelHandler.GetDispatcher();
channel.ChannelDispatcher = channelDispatcher;
await channelHandler.OpenAsync();
return(channelDispatcher);
}
bool TransactedAccept(out Transaction tx)
{
tx = null;
try
{
tx = TransactionBehavior.CreateTransaction(this.ChannelDispatcher.TransactionIsolationLevel, this.ChannelDispatcher.TransactionTimeout);
IChannelBinder binder = null;
using (TransactionScope scope = new TransactionScope(tx))
{
TimeSpan acceptTimeout = TimeoutHelper.Min(this.ChannelDispatcher.TransactionTimeout, this.ChannelDispatcher.DefaultCommunicationTimeouts.ReceiveTimeout);
if (!this.acceptor.TryAccept(TransactionBehavior.NormalizeTimeout(acceptTimeout), out binder))
{
return(false);
}
scope.Complete();
}
if (null != binder)
{
this.channel = new ListenerChannel(binder);
this.idleManager = SessionIdleManager.CreateIfNeeded(this.channel.Binder, this.channelDispatcher.DefaultCommunicationTimeouts.ReceiveTimeout);
return(true);
}
else
{
this.AcceptedNull();
tx = null;
return(false);
}
}
catch (CommunicationException e)
{
if (null != tx)
{
try
{
tx.Rollback();
}
catch (TransactionException ex)
{
DiagnosticUtility.TraceHandledException(ex, TraceEventType.Information);
}
}
tx = null;
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
return(false);
}
catch (TransactionException e)
{
tx = null;
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
return(false);
}
}
internal bool EndTryAccept(IAsyncResult result, out IChannelBinder channelBinder)
{
ErrorHandlingCompletedAsyncResult handlerResult = result as ErrorHandlingCompletedAsyncResult;
if (handlerResult != null)
{
channelBinder = null;
return(ErrorHandlingCompletedAsyncResult.End(handlerResult));
}
else
{
try
{
channelBinder = this.binder.EndAccept(result);
if (channelBinder != null)
{
this.dispatcher.PendingChannels.Add(channelBinder.Channel);
}
return(true);
}
catch (CommunicationObjectAbortedException)
{
channelBinder = null;
return(true);
}
catch (CommunicationObjectFaultedException)
{
channelBinder = null;
return(true);
}
catch (TimeoutException)
{
channelBinder = null;
return(false);
}
catch (CommunicationException e)
{
this.HandleError(e);
channelBinder = null;
return(false);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.HandleErrorOrAbort(e);
channelBinder = null;
return(false);
}
}
}
public virtual ServiceChannel CreateServiceChannel(EndpointAddress address, Uri via)
{
IChannelBinder binder = this.CreateInnerChannelBinder(address, via);
ServiceChannel channel = new ServiceChannel(this, binder);
if (binder is DuplexChannelBinder)
{
DuplexChannelBinder binder2 = binder as DuplexChannelBinder;
binder2.ChannelHandler = new ChannelHandler(this.messageVersion, binder, channel);
binder2.DefaultCloseTimeout = this.DefaultCloseTimeout;
binder2.DefaultSendTimeout = this.DefaultSendTimeout;
binder2.IdentityVerifier = this.clientRuntime.IdentityVerifier;
}
return(channel);
}
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;
//}
}
public virtual ServiceChannel CreateServiceChannel(EndpointAddress address, Uri via)
{
IChannelBinder binder = CreateInnerChannelBinder(address, via);
ServiceChannel serviceChannel = new ServiceChannel(this, binder);
if (binder is DuplexChannelBinder)
{
DuplexChannelBinder duplexChannelBinder = binder as DuplexChannelBinder;
duplexChannelBinder.ChannelHandler = new ChannelHandler(MessageVersion, binder, serviceChannel);
duplexChannelBinder.DefaultCloseTimeout = DefaultCloseTimeout;
duplexChannelBinder.DefaultSendTimeout = DefaultSendTimeout;
duplexChannelBinder.IdentityVerifier = _clientRuntime.IdentityVerifier;
}
return(serviceChannel);
}
internal ChannelHandler(ChannelHandler handler, TransactedBatchContext context)
{
this.messageVersion = handler.messageVersion;
this.isManualAddressing = handler.isManualAddressing;
this.binder = handler.binder;
this.listener = handler.listener;
this.wasChannelThrottled = handler.wasChannelThrottled;
this.host = handler.host;
this.receiveSynchronously = true;
this.receiveWithTransaction = true;
this.duplexBinder = handler.duplexBinder;
this.hasSession = handler.hasSession;
this.isConcurrent = handler.isConcurrent;
this.receiver = handler.receiver;
this.sharedTransactedBatchContext = context.Shared;
this.transactedBatchContext = context;
this.requestInfo = new RequestInfo(this);
}
internal bool TryAccept(TimeSpan timeout, out IChannelBinder channelBinder)
{
try
{
channelBinder = this.binder.Accept(timeout);
if (channelBinder != null)
{
this.dispatcher.PendingChannels.Add(channelBinder.Channel);
}
return(true);
}
catch (CommunicationObjectAbortedException)
{
channelBinder = null;
return(true);
}
catch (CommunicationObjectFaultedException)
{
channelBinder = null;
return(true);
}
catch (TimeoutException)
{
channelBinder = null;
return(false);
}
catch (CommunicationException exception)
{
this.HandleError(exception);
channelBinder = null;
return(false);
}
catch (Exception exception2)
{
if (Fx.IsFatal(exception2))
{
throw;
}
this.HandleErrorOrAbort(exception2);
channelBinder = null;
return(false);
}
}
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder,
ListenerHandler listener, SessionIdleManager idleManager)
{
ChannelDispatcher channelDispatcher = listener.ChannelDispatcher;
_messageVersion = messageVersion;
_isManualAddressing = channelDispatcher.ManualAddressing;
_binder = binder;
_listener = listener;
_receiveSynchronously = channelDispatcher.ReceiveSynchronously;
_sendAsynchronously = channelDispatcher.SendAsynchronously;
_duplexBinder = binder as DuplexChannelBinder;
_hasSession = binder.HasSession;
_isConcurrent = ConcurrencyBehavior.IsConcurrent(channelDispatcher, _hasSession);
if (channelDispatcher.MaxPendingReceives > 1)
{
throw NotImplemented.ByDesign;
}
if (channelDispatcher.BufferedReceiveEnabled)
{
_binder = new BufferedReceiveBinder(_binder);
}
_receiver = new ErrorHandlingReceiver(_binder, channelDispatcher);
_idleManager = idleManager;
Fx.Assert((_idleManager != null) == (_binder.HasSession && _listener.ChannelDispatcher.DefaultCommunicationTimeouts.ReceiveTimeout != TimeSpan.MaxValue), "idle manager is present only when there is a session with a finite receive timeout");
_requestInfo = new RequestInfo(this);
if (_listener.State == CommunicationState.Opened)
{
_listener.ChannelDispatcher.Channels.IncrementActivityCount();
_incrementedActivityCountInConstructor = true;
}
}
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder,
ListenerHandler listener, SessionIdleManager idleManager)
{
ChannelDispatcher channelDispatcher = listener.ChannelDispatcher;
_messageVersion = messageVersion;
_isManualAddressing = channelDispatcher.ManualAddressing;
_binder = binder;
_listener = listener;
_receiveSynchronously = channelDispatcher.ReceiveSynchronously;
_sendAsynchronously = channelDispatcher.SendAsynchronously;
_duplexBinder = binder as DuplexChannelBinder;
_hasSession = binder.HasSession;
_isConcurrent = ConcurrencyBehavior.IsConcurrent(channelDispatcher, _hasSession);
if (channelDispatcher.MaxPendingReceives > 1)
{
throw NotImplemented.ByDesign;
}
if (channelDispatcher.BufferedReceiveEnabled)
{
_binder = new BufferedReceiveBinder(_binder);
}
_receiver = new ErrorHandlingReceiver(_binder, channelDispatcher);
_idleManager = idleManager;
Fx.Assert((_idleManager != null) == (_binder.HasSession && _listener.ChannelDispatcher.DefaultCommunicationTimeouts.ReceiveTimeout != TimeSpan.MaxValue), "idle manager is present only when there is a session with a finite receive timeout");
_requestInfo = new RequestInfo(this);
if (_listener.State == CommunicationState.Opened)
{
_listener.ChannelDispatcher.Channels.IncrementActivityCount();
_incrementedActivityCountInConstructor = true;
}
}
public ListenerChannel(IChannelBinder binder)
{
this.binder = binder;
}
public ListenerChannel(IChannelBinder binder)
{
_binder = binder;
}
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ServiceThrottle throttle,
ListenerHandler listener, bool wasChannelThrottled, WrappedTransaction acceptTransaction, SessionIdleManager idleManager)
{
ChannelDispatcher channelDispatcher = listener.ChannelDispatcher;
this.messageVersion = messageVersion;
this.isManualAddressing = channelDispatcher.ManualAddressing;
this.binder = binder;
this.throttle = throttle;
this.listener = listener;
this.wasChannelThrottled = wasChannelThrottled;
this.host = listener.Host;
this.receiveSynchronously = channelDispatcher.ReceiveSynchronously;
this.sendAsynchronously = channelDispatcher.SendAsynchronously;
this.duplexBinder = binder as DuplexChannelBinder;
this.hasSession = binder.HasSession;
this.isConcurrent = ConcurrencyBehavior.IsConcurrent(channelDispatcher, this.hasSession);
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)
{
this.binder = new BufferedReceiveBinder(this.binder);
}
this.receiver = new ErrorHandlingReceiver(this.binder, channelDispatcher);
this.idleManager = idleManager;
Fx.Assert((this.idleManager != null) == (this.binder.HasSession && this.listener.ChannelDispatcher.DefaultCommunicationTimeouts.ReceiveTimeout != TimeSpan.MaxValue), "idle manager is present only when there is a session with a finite receive timeout");
if (channelDispatcher.IsTransactedReceive && !channelDispatcher.ReceiveContextEnabled)
{
receiveSynchronously = true;
receiveWithTransaction = true;
if (channelDispatcher.MaxTransactedBatchSize > 0)
{
int maxConcurrentBatches = 1;
if (null != throttle && throttle.MaxConcurrentCalls > 1)
{
maxConcurrentBatches = throttle.MaxConcurrentCalls;
foreach (EndpointDispatcher endpointDispatcher in channelDispatcher.Endpoints)
{
if (ConcurrencyMode.Multiple != endpointDispatcher.DispatchRuntime.ConcurrencyMode)
{
maxConcurrentBatches = 1;
break;
}
}
}
this.sharedTransactedBatchContext = new SharedTransactedBatchContext(this, channelDispatcher, maxConcurrentBatches);
this.isMainTransactedBatchHandler = true;
this.throttle = null;
}
}
else if (channelDispatcher.IsTransactedReceive && channelDispatcher.ReceiveContextEnabled && channelDispatcher.MaxTransactedBatchSize > 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.IncompatibleBehaviors)));
}
if (this.binder.HasSession)
{
this.sessionOpenNotification = this.binder.Channel.GetProperty<SessionOpenNotification>();
this.needToCreateSessionOpenNotificationMessage = this.sessionOpenNotification != null && this.sessionOpenNotification.IsEnabled;
}
this.acceptTransaction = acceptTransaction;
this.requestInfo = new RequestInfo(this);
if (this.listener.State == CommunicationState.Opened)
{
this.listener.ChannelDispatcher.Channels.IncrementActivityCount();
this.incrementedActivityCountInConstructor = true;
}
}
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ServiceThrottle throttle, ListenerHandler listener, bool wasChannelThrottled, WrappedTransaction acceptTransaction, ServiceChannel.SessionIdleManager idleManager)
{
ChannelDispatcher channelDispatcher = listener.ChannelDispatcher;
this.messageVersion = messageVersion;
this.isManualAddressing = channelDispatcher.ManualAddressing;
this.binder = binder;
this.throttle = throttle;
this.listener = listener;
this.wasChannelThrottled = wasChannelThrottled;
this.host = listener.Host;
this.receiveSynchronously = channelDispatcher.ReceiveSynchronously;
this.duplexBinder = binder as DuplexChannelBinder;
this.hasSession = binder.HasSession;
this.isConcurrent = ConcurrencyBehavior.IsConcurrent(channelDispatcher, this.hasSession);
if (channelDispatcher.MaxPendingReceives > 1)
{
this.binder = new MultipleReceiveBinder(this.binder, channelDispatcher.MaxPendingReceives, !this.isConcurrent);
}
if (channelDispatcher.BufferedReceiveEnabled)
{
this.binder = new BufferedReceiveBinder(this.binder);
}
this.receiver = new ErrorHandlingReceiver(this.binder, channelDispatcher);
this.idleManager = idleManager;
if (!channelDispatcher.IsTransactedReceive || channelDispatcher.ReceiveContextEnabled)
{
if ((channelDispatcher.IsTransactedReceive && channelDispatcher.ReceiveContextEnabled) && (channelDispatcher.MaxTransactedBatchSize > 0))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("IncompatibleBehaviors")));
}
}
else
{
this.receiveSynchronously = true;
this.receiveWithTransaction = true;
if (channelDispatcher.MaxTransactedBatchSize > 0)
{
int maxConcurrentBatches = 1;
if ((throttle != null) && (throttle.MaxConcurrentCalls > 1))
{
maxConcurrentBatches = throttle.MaxConcurrentCalls;
foreach (EndpointDispatcher dispatcher2 in channelDispatcher.Endpoints)
{
if (ConcurrencyMode.Multiple != dispatcher2.DispatchRuntime.ConcurrencyMode)
{
maxConcurrentBatches = 1;
break;
}
}
}
this.sharedTransactedBatchContext = new SharedTransactedBatchContext(this, channelDispatcher, maxConcurrentBatches);
this.isMainTransactedBatchHandler = true;
this.throttle = null;
}
}
this.acceptTransaction = acceptTransaction;
this.requestInfo = new RequestInfo(this);
if (!this.hasSession && (this.listener.State == CommunicationState.Opened))
{
this.listener.ChannelDispatcher.Channels.IncrementActivityCount();
this.incrementedActivityCountInConstructor = true;
}
}
internal ChannelHandler(ChannelHandler handler, TransactedBatchContext context)
{
this.messageVersion = handler.messageVersion;
this.isManualAddressing = handler.isManualAddressing;
this.binder = handler.binder;
this.listener = handler.listener;
this.wasChannelThrottled = handler.wasChannelThrottled;
this.host = handler.host;
this.receiveSynchronously = true;
this.receiveWithTransaction = true;
this.duplexBinder = handler.duplexBinder;
this.hasSession = handler.hasSession;
this.isConcurrent = handler.isConcurrent;
this.receiver = handler.receiver;
this.sharedTransactedBatchContext = context.Shared;
this.transactedBatchContext = context;
this.requestInfo = new RequestInfo(this);
this.sendAsynchronously = handler.sendAsynchronously;
this.sessionOpenNotification = handler.sessionOpenNotification;
this.needToCreateSessionOpenNotificationMessage = handler.needToCreateSessionOpenNotificationMessage;
this.shouldRejectMessageWithOnOpenActionHeader = handler.shouldRejectMessageWithOnOpenActionHeader;
}
public ListenerChannel(IChannelBinder binder)
{
_binder = binder;
}
public BufferedReceiveBinder(IChannelBinder channelBinder)
{
_channelBinder = channelBinder;
_inputQueue = new InputQueue<RequestContextWrapper>();
}
private Task DispatchAsyncCore(RequestContext request, IChannel channel, EndpointDispatcher endpointDispatcher, CancellationToken token)
{
var dispatchRuntime = endpointDispatcher.DispatchRuntime;
//EndpointDispatcher endpoint = dispatchRuntime.EndpointDispatcher;
//bool releasedPump = false;
ServiceChannel serviceChannel = null;
var sessionIdleManager = channel.GetProperty <ServiceChannel.SessionIdleManager>();
IChannelBinder binder = null;
if (channel is IReplyChannel)
{
var rcbinder = channel.GetProperty <ReplyChannelBinder>();
rcbinder.Init(channel as IReplyChannel, BaseAddress);
binder = rcbinder;
}
else if (channel is IDuplexSessionChannel)
{
var dcbinder = channel.GetProperty <DuplexChannelBinder>();
dcbinder.Init(channel as IDuplexSessionChannel, _requestReplyCorrelator, BaseAddress);
binder = dcbinder;
}
serviceChannel = new ServiceChannel(
binder,
endpointDispatcher,
Binding,
sessionIdleManager.UseIfNeeded(binder, Binding.ReceiveTimeout));
Message message = request.RequestMessage;
DispatchOperationRuntime operation = dispatchRuntime.GetOperation(ref message);
if (operation == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "No DispatchOperationRuntime found to process message.")));
}
// TODO: Wire in session open notification
//if (shouldRejectMessageWithOnOpenActionHeader && message.Headers.Action == OperationDescription.SessionOpenedAction)
//{
// throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxNoEndpointMatchingAddressForConnectionOpeningMessage, message.Headers.Action, "Open")));
//}
// TODO: Session lifetime
//if (operation.IsTerminating && requestInfo.HasSession)
//{
// isChannelTerminated = true;
//}
// TODO: Fix up whatever semantics OperationContext places on a host being passed
var currentOperationContext = new OperationContext(request, message, serviceChannel, /*host*/ null);
currentOperationContext.EndpointDispatcher = endpointDispatcher;
var existingInstanceContext = dispatchRuntime.InstanceContextProvider.GetExistingInstanceContext(request.RequestMessage, serviceChannel.Proxy as IContextChannel);
// TODO: Investigate consequences of cleanThread parameter
MessageRpc rpc = new MessageRpc(request, message, operation, serviceChannel, /*host*/ null,
/*cleanThread*/ true, currentOperationContext, existingInstanceContext /*, eventTraceActivity*/);
return(operation.Parent.DispatchAsync(ref rpc, /*hasOperationContextBeenSet*/ false));
// TODO : Fix error handling
//catch (Exception e)
//{
// if (Fx.IsFatal(e))
// {
// throw;
// }
// return HandleError(e, request, channel);
//}
}
public BufferedReceiveBinder(IChannelBinder channelBinder)
{
this.channelBinder = channelBinder;
this.inputQueue = new InputQueue <RequestContextWrapper>();
}
public MultipleReceiveBinder(IChannelBinder channelBinder, int size, bool ordered)
{
this.ordered = ordered;
this.channelBinder = channelBinder;
this.pendingResults = new ReceiveScopeQueue(size);
}
public ListenerChannel(IChannelBinder binder)
{
this.binder = binder;
}
internal ErrorHandlingReceiver(IChannelBinder binder, ChannelDispatcher dispatcher)
{
_binder = binder;
_dispatcher = dispatcher;
}
public MultipleReceiveBinder(IChannelBinder channelBinder, int size, bool ordered)
{
this.ordered = ordered;
this.channelBinder = channelBinder;
}