protected override TChannel OnEndAcceptChannel (IAsyncResult result)
{
if (typeof (TChannel) == typeof (IReplyChannel))
return (TChannel) (object) new InterceptorReplyChannel (
(InterceptorChannelListener<IReplyChannel>) (object) this,
(IReplyChannel) (object) inner.EndAcceptChannel (result));
throw new NotImplementedException ();
}
public void AcceptChannel(IAsyncResult ar)
{
IChannelListener <IReplyChannel> listener = ar.AsyncState as IChannelListener <IReplyChannel>;
IReplyChannel channel = listener.EndAcceptChannel(ar);
channel.Open();
channel.BeginReceiveRequest(AcceptRequest, channel);
}
public IChannelBinder EndAccept(IAsyncResult result)
{
IReplySessionChannel channel = _listener.EndAcceptChannel(result);
if (channel == null)
{
return(null);
}
return(new ReplyChannelBinder(channel, _listener.Uri));
}
public IChannelBinder EndAccept(IAsyncResult result)
{
IDuplexSessionChannel channel = _listener.EndAcceptChannel(result);
if (channel == null)
{
return(null);
}
return(new DuplexChannelBinder(channel, _correlator, _listener.Uri));
}
public IReplyChannel EndAcceptChannel(IAsyncResult result)
{
var inner = _innerListener.EndAcceptChannel(result);
if (inner != null)
{
return(new BasicAuthenticationChannel(this, inner));
}
return(null);
}
public override TChannel EndAcceptChannel(IAsyncResult result)
{
TInnerChannel innerChannel = _innerListener.EndAcceptChannel(result);
if (innerChannel == null)
{
return(null);
}
else
{
return(OnAcceptChannel(innerChannel));
}
}
protected override TChannel OnEndAcceptChannel(IAsyncResult result)
{
return(inner.EndAcceptChannel(result));
}
protected override IDuplexSessionChannel OnEndAcceptChannel(IAsyncResult result)
{
IDuplexSessionChannel innerChannel = innerListener.EndAcceptChannel(result);
return(WrapChannel(innerChannel));
}
protected override IReplyChannel OnEndAcceptChannel(IAsyncResult result)
{
IReplyChannel innerChannel = _innerChannelListener.EndAcceptChannel(result);
return(WrapInnerChannel(innerChannel));
}
protected override TChannel OnEndAcceptChannel(IAsyncResult result)
{
return(CreateSecurityWrapper(inner.EndAcceptChannel(result)));
}
private void AcceptChannelAndReceive(IChannelListener<IInputChannel> listener)
{
IInputChannel channel;
TransactionScope transactionToAbortOnAccept = null;
if (this.Parameters.AbortTxDatagramAccept)
{
transactionToAbortOnAccept = new TransactionScope(TransactionScopeOption.RequiresNew);
}
if (this.Parameters.AsyncAccept)
{
IAsyncResult result = listener.BeginAcceptChannel(null, null);
channel = listener.EndAcceptChannel(result);
}
else
{
channel = listener.AcceptChannel();
}
if (this.Parameters.AbortTxDatagramAccept)
{
transactionToAbortOnAccept.Dispose();
}
channel.Open();
Message message;
if (this.Parameters.CloseListenerEarly)
{
listener.Close();
}
try
{
using (TransactionScope ts = new TransactionScope(TransactionScopeOption.RequiresNew))
{
Message firstMessage = channel.Receive(this.Parameters.ReceiveTimeout);
lock (this.Results)
{
this.Results.Add(String.Format("Received message with Action '{0}'", firstMessage.Headers.Action));
}
ts.Complete();
}
}
catch (TimeoutException)
{
lock (this.Results)
{
this.Results.Add("Receive timed out.");
}
channel.Abort();
return;
}
AutoResetEvent doneReceiving = new AutoResetEvent(false);
int threadsCompleted = 0;
for (int i = 0; i < this.Parameters.NumberOfThreads; ++i)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object unused)
{
do
{
if (this.Parameters.ReceiverShouldAbort)
{
this.ReceiveMessage(channel, false);
Thread.Sleep(200);
}
message = this.ReceiveMessage(channel, true);
}
while (message != null);
if (Interlocked.Increment(ref threadsCompleted) == this.Parameters.NumberOfThreads)
{
doneReceiving.Set();
}
}));
}
TimeSpan threadTimeout = TimeSpan.FromMinutes(2.0);
if (!doneReceiving.WaitOne(threadTimeout, false))
{
this.Results.Add(String.Format("Threads did not complete within {0}.", threadTimeout));
}
channel.Close();
}
private void AcceptChannelAndReceive(IChannelListener <IInputChannel> listener)
{
IInputChannel channel;
TransactionScope transactionToAbortOnAccept = null;
if (this.Parameters.AbortTxDatagramAccept)
{
transactionToAbortOnAccept = new TransactionScope(TransactionScopeOption.RequiresNew);
}
if (this.Parameters.AsyncAccept)
{
IAsyncResult result = listener.BeginAcceptChannel(null, null);
channel = listener.EndAcceptChannel(result);
}
else
{
channel = listener.AcceptChannel();
}
if (this.Parameters.AbortTxDatagramAccept)
{
transactionToAbortOnAccept.Dispose();
}
channel.Open();
Message message;
if (this.Parameters.CloseListenerEarly)
{
listener.Close();
}
try
{
using (TransactionScope ts = new TransactionScope(TransactionScopeOption.RequiresNew))
{
Message firstMessage = channel.Receive(this.Parameters.ReceiveTimeout);
lock (this.Results)
{
this.Results.Add(String.Format("Received message with Action '{0}'", firstMessage.Headers.Action));
}
ts.Complete();
}
}
catch (TimeoutException)
{
lock (this.Results)
{
this.Results.Add("Receive timed out.");
}
channel.Abort();
return;
}
AutoResetEvent doneReceiving = new AutoResetEvent(false);
int threadsCompleted = 0;
for (int i = 0; i < this.Parameters.NumberOfThreads; ++i)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object unused)
{
do
{
if (this.Parameters.ReceiverShouldAbort)
{
this.ReceiveMessage(channel, false);
Thread.Sleep(200);
}
message = this.ReceiveMessage(channel, true);
}while (message != null);
if (Interlocked.Increment(ref threadsCompleted) == this.Parameters.NumberOfThreads)
{
doneReceiving.Set();
}
}));
}
TimeSpan threadTimeout = TimeSpan.FromMinutes(2.0);
if (!doneReceiving.WaitOne(threadTimeout, false))
{
this.Results.Add(String.Format("Threads did not complete within {0}.", threadTimeout));
}
channel.Close();
}
