public void Close()
{
if (_socket == null)
{
return;
}
_active = false;
try
{
_socket.Shutdown(SocketShutdown.Both);
}
catch
{
}
finally
{
_socket.Close();
_socket = null;
_receiver = null;
if (ClosedHandler != null)
{
ClosedHandler(this);
}
}
}
public Session(string name)
{
_name = name ?? string.Empty;
_sessionType = SessionType.Unknown;
_socket = null;
_receiver = null;
_active = false;
_disposed = false;
ConnectedHandler = null;
ClosedHandler = null;
ErrorHandler = null;
CustomErrorHandler = null;
ReceiveHandler = null;
SendHandler = null;
}
async Task IFilter <NamespaceContext> .Send(NamespaceContext context, IPipe <NamespaceContext> next)
{
var clientContext = context.GetPayload <ClientContext>();
var clientSettings = context.GetPayload <ClientSettings>();
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Creating message receiver for {0}", clientContext.InputAddress);
}
using (var scope = context.CreateScope($"{TypeMetadataCache<MessageReceiverFilter>.ShortName} - {clientContext.InputAddress}"))
{
var receiver = new SessionReceiver(clientContext, _receivePipe, clientSettings, scope, _topology);
await receiver.Start(context).ConfigureAwait(false);
await scope.Ready.ConfigureAwait(false);
await context.Ready(new ReceiveTransportReadyEvent(clientContext.InputAddress)).ConfigureAwait(false);
scope.SetReady();
try
{
await scope.Completed.ConfigureAwait(false);
}
finally
{
var metrics = receiver.GetDeliveryMetrics();
await context.Completed(new ReceiveTransportCompletedEvent(clientContext.InputAddress, metrics)).ConfigureAwait(false);
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Consumer {0}: {1} received, {2} concurrent", clientContext.InputAddress,
metrics.DeliveryCount,
metrics.ConcurrentDeliveryCount);
}
}
}
await next.Send(context).ConfigureAwait(false);
}
private void Initialize(AddressFamily addressFamily)
{
if (_socket != null)
{
Close();
_socket = null;
}
switch (addressFamily)
{
case AddressFamily.InterNetwork:
_sessionType = SessionType.IPv4;
break;
case AddressFamily.InterNetworkV6:
_sessionType = SessionType.IPv6;
break;
default:
throw new Exception(string.Format("Not supported address family '{0}'.", addressFamily.ToString()));
}
_socket = new Socket(addressFamily, SocketType.Stream, ProtocolType.Tcp);
_receiver = new SessionReceiver(_defaultMaxPacketLength);
_receiver.Reset(_defaultPacketLength);
}
async Task IFilter <ConnectionContext> .Send(ConnectionContext context, IPipe <ConnectionContext> next)
{
var receiveSettings = context.GetPayload <ReceiveSettings>();
var queuePath = context.GetQueuePath(receiveSettings.QueueDescription);
var inputAddress = context.GetQueueAddress(receiveSettings.QueueDescription);
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Creating message receiver for {0}", inputAddress);
}
QueueClient queueClient = null;
try
{
var messagingFactory = await context.SessionMessagingFactory.ConfigureAwait(false);
queueClient = messagingFactory.CreateQueueClient(queuePath);
queueClient.PrefetchCount = receiveSettings.PrefetchCount;
using (var scope = _supervisor.CreateScope($"{TypeMetadataCache<MessageReceiverFilter>.ShortName} - {inputAddress}"))
{
var receiver = new SessionReceiver(context, queueClient, inputAddress, _receivePipe, receiveSettings, _receiveObserver, scope);
await scope.Ready.ConfigureAwait(false);
await _endpointObserver.Ready(new Ready(inputAddress)).ConfigureAwait(false);
scope.SetReady();
try
{
await scope.Completed.ConfigureAwait(false);
}
finally
{
ReceiverMetrics metrics = receiver;
await _endpointObserver.Completed(new Completed(inputAddress, metrics)).ConfigureAwait(false);
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Consumer {0}: {1} received, {2} concurrent", queuePath,
metrics.DeliveryCount,
metrics.ConcurrentDeliveryCount);
}
}
}
}
finally
{
if (queueClient != null && !queueClient.IsClosed)
{
await queueClient.CloseAsync().ConfigureAwait(false);
}
}
await next.Send(context).ConfigureAwait(false);
}
