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); }