public void Start(IReceiverCallback callback)
{
_listener = new TcpListener(new IPEndPoint(_ipaddr, _port));
_listener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_socketHandling = new ActionBlock <Socket>(async s =>
{
using (var stream = new NetworkStream(s, true))
{
await HandleStream(callback, stream);
}
}, new ExecutionDataflowBlockOptions {
CancellationToken = _cancellationToken
});
_receivingLoop = Task.Run(async() =>
{
_listener.Start();
while (!_cancellationToken.IsCancellationRequested)
{
var socket = await _listener.AcceptSocketAsync();
await _socketHandling.SendAsync(socket, _cancellationToken);
}
}, _cancellationToken);
}
private static async Task receive(Stream stream, IReceiverCallback callback, Envelope[] messages, Uri uri)
{
var status = callback.Received(uri, messages);
switch (status)
{
case ReceivedStatus.ProcessFailure:
await stream.SendBuffer(Constants.ProcessingFailureBuffer);
break;
case ReceivedStatus.QueueDoesNotExist:
await stream.SendBuffer(Constants.QueueDoesNotExistBuffer);
break;
default:
await stream.SendBuffer(Constants.ReceivedBuffer);
var ack = await stream.ReadExpectedBuffer(Constants.AcknowledgedBuffer);
if (ack)
{
callback.Acknowledged(messages);
}
else
{
callback.NotAcknowledged(messages);
}
break;
}
}
public void Start(IReceiverCallback callback)
{
_callback = callback;
var options = new SessionHandlerOptions(handleException);
var connectionString = _endpoint.ConnectionString;
var tokenProvider = _endpoint.TokenProvider;
var subscriptionName = _endpoint.Uri.SubscriptionName;
var queueName = _endpoint.Uri.QueueName;
var retryPolicy = _endpoint.RetryPolicy;
var receiveMode = _endpoint.ReceiveMode;
var transportType = _endpoint.TransportType;
var topicName = _endpoint.Uri.TopicName;
if (topicName.IsEmpty())
{
var client = tokenProvider != null
? new QueueClient(connectionString, queueName, tokenProvider, transportType, receiveMode, retryPolicy)
: new QueueClient(connectionString, queueName, receiveMode, retryPolicy);
client.RegisterSessionHandler(handleMessage, options);
_clientEntities.Add(client);
}
else if (_endpoint.Uri.IsMessageSpecificTopic())
{
if (_endpoint.Uri.SubscriptionName.IsEmpty())
{
throw new InvalidOperationException($"Invalid listener Uri '{_endpoint.Uri.ToUri()}', 'subscription' is required when listening to a topic.");
}
var topicNames = _handlers.Chains.Select(x => x.MessageType.ToMessageTypeName().ToLower());
foreach (var name in topicNames)
{
var client = tokenProvider != null
? new SubscriptionClient(connectionString, name, subscriptionName, tokenProvider,
transportType, receiveMode, retryPolicy)
: new SubscriptionClient(connectionString, name, subscriptionName,
receiveMode, retryPolicy);
client.RegisterSessionHandler(handleMessage, options);
_clientEntities.Add(client);
}
}
else
{
var client = tokenProvider != null
? new SubscriptionClient(connectionString, topicName, subscriptionName, tokenProvider,
transportType, receiveMode, retryPolicy)
: new SubscriptionClient(connectionString, topicName, subscriptionName,
receiveMode, retryPolicy);
client.RegisterSessionHandler(handleMessage, options);
_clientEntities.Add(client);
}
}
public Task HandleStream(IReceiverCallback callback, Stream stream)
{
if (Status == ListeningStatus.TooBusy)
{
return(stream.SendBuffer(WireProtocol.ProcessingFailureBuffer));
}
return(WireProtocol.Receive(stream, callback, Address));
}
public ListeningAgent(IReceiverCallback callback, int port, string protocol, CancellationToken cancellationToken)
{
Port = port;
_callback = callback;
_cancellationToken = cancellationToken;
_listener = new TcpListener(new IPEndPoint(IPAddress.Loopback, port));
_listener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_socketHandling = new ActionBlock <Socket>(s =>
{
var stream = new NetworkStream(s, true);
return(WireProtocol.Receive(stream, _callback, _uri));
});
_uri = $"{protocol}://{Environment.MachineName}:{port}/".ToUri();
}
private static async Task receive(Stream stream, IReceiverCallback callback, Envelope[] messages, Uri uri)
{
// Just a ping
if (messages.Any() && messages.First().IsPing())
{
await stream.SendBuffer(ReceivedBuffer);
// We aren't gonna use this in this case
var ack = await stream.ReadExpectedBuffer(AcknowledgedBuffer);
return;
}
var status = await callback.Received(uri, messages);
switch (status)
{
case ReceivedStatus.ProcessFailure:
await stream.SendBuffer(ProcessingFailureBuffer);
break;
case ReceivedStatus.QueueDoesNotExist:
await stream.SendBuffer(QueueDoesNotExistBuffer);
break;
default:
await stream.SendBuffer(ReceivedBuffer);
var ack = await stream.ReadExpectedBuffer(AcknowledgedBuffer);
if (ack)
{
await callback.Acknowledged(messages);
}
else
{
await callback.NotAcknowledged(messages);
}
break;
}
}
public ListeningAgent(IReceiverCallback callback, IPAddress ipaddr, int port, string protocol, CancellationToken cancellationToken)
{
Port = port;
_callback = callback;
_cancellationToken = cancellationToken;
_listener = new TcpListener(new IPEndPoint(ipaddr, port));
_listener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_socketHandling = new ActionBlock <Socket>(async s =>
{
using (var stream = new NetworkStream(s, true))
{
await WireProtocol.Receive(stream, _callback, _uri);
}
});
_uri = $"{protocol}://{ipaddr}:{port}/".ToUri();
}
public void Start(IReceiverCallback callback)
{
_callback = callback;
var options = new SessionHandlerOptions(handleException);
var connectionString = _transport.ConnectionString;
var tokenProvider = _transport.TokenProvider;
var subscriptionName = _endpoint.SubscriptionName;
var queueName = _endpoint.QueueName;
var retryPolicy = _transport.RetryPolicy;
var receiveMode = _transport.ReceiveMode;
var transportType = _transport.TransportType;
var topicName = _endpoint.TopicName;
if (topicName.IsEmpty())
{
var client = tokenProvider != null
? new QueueClient(connectionString, queueName, tokenProvider, transportType, receiveMode,
retryPolicy)
: new QueueClient(connectionString, queueName, receiveMode, retryPolicy);
client.RegisterSessionHandler(handleMessage, options);
_clientEntities.Add(client);
}
else
{
var client = tokenProvider != null
? new SubscriptionClient(connectionString, topicName, subscriptionName, tokenProvider,
transportType, receiveMode, retryPolicy)
: new SubscriptionClient(connectionString, topicName, subscriptionName,
receiveMode, retryPolicy);
client.RegisterSessionHandler(handleMessage, options);
_clientEntities.Add(client);
}
}
public static async Task Receive(Stream stream, IReceiverCallback callback, Uri uri)
{
Envelope[] messages = null;
try
{
var lengthBytes = await stream.ReadBytesAsync(sizeof(int));
var length = BitConverter.ToInt32(lengthBytes, 0);
if (length == 0)
{
return;
}
var bytes = await stream.ReadBytesAsync(length);
messages = Envelope.ReadMany(bytes);
}
catch (Exception e)
{
await callback.Failed(e, messages);
await stream.SendBuffer(SerializationFailureBuffer);
return;
}
try
{
await receive(stream, callback, messages, uri);
}
catch (Exception ex)
{
await callback.Failed(ex, messages);
await stream.SendBuffer(ProcessingFailureBuffer);
}
}
public void Start(IReceiverCallback callback)
{
_listener = new TcpListener(new IPEndPoint(IPAddress.Loopback, _port));
_listener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_socketHandling = new ActionBlock <Socket>(async s =>
{
using (var stream = new NetworkStream(s, true))
{
await WireProtocol.Receive(stream, callback, Address);
}
});
_receivingLoop = Task.Run(async() =>
{
_listener.Start();
while (!_cancellationToken.IsCancellationRequested)
{
var socket = await _listener.AcceptSocketAsync();
_socketHandling.Post(socket);
}
}, _cancellationToken);
}
