public LightweightWorkerQueue(Endpoint endpoint, ITransportLogger logger, IHandlerPipeline pipeline, AdvancedSettings settings) { _logger = logger; _settings = settings; Pipeline = pipeline; _scheduler = new InMemoryScheduledJobProcessor(this); endpoint.ExecutionOptions.CancellationToken = settings.Cancellation; _receiver = new ActionBlock <Envelope>(async envelope => { try { if (envelope.ContentType.IsEmpty()) { envelope.ContentType = "application/json"; } await Pipeline.Invoke(envelope); } catch (Exception e) { // This *should* never happen, but of course it will logger.LogException(e); } }, endpoint.ExecutionOptions); }
public DurableWorkerQueue(Endpoint endpoint, IHandlerPipeline pipeline, AdvancedSettings settings, IEnvelopePersistence persistence, ITransportLogger logger) { _settings = settings; _persistence = persistence; _logger = logger; endpoint.ExecutionOptions.CancellationToken = settings.Cancellation; _receiver = new ActionBlock <Envelope>(async envelope => { try { envelope.ContentType = envelope.ContentType ?? "application/json"; await pipeline.Invoke(envelope, this); } catch (Exception e) { // This *should* never happen, but of course it will logger.LogException(e); } }, endpoint.ExecutionOptions); _policy = Policy .Handle <Exception>() .WaitAndRetryForeverAsync(i => (i * 100).Milliseconds() , (e, timeSpan) => { _logger.LogException(e); }); }
private Task receive(Envelope envelope) { envelope.Callback = _provider.BuildCallback(envelope, this); envelope.ContentType = envelope.ContentType ?? "application/json"; return(_pipeline.Invoke(envelope)); }
public Task Receive(byte[] data, IDictionary <string, string> headers, IMessageCallback callback) { if (data == null) { throw new ArgumentNullException(nameof(data)); } if (headers == null) { throw new ArgumentNullException(nameof(headers)); } if (callback == null) { throw new ArgumentNullException(nameof(callback)); } var envelope = new Envelope(data, headers, callback) { ReceivedAt = _address }; // Do keep this here then. envelope.ContentType = envelope.ContentType ?? _node.DefaultContentType ?? _graph.DefaultContentType; return(_pipeline.Invoke(envelope, _node)); }
private async Task ConsumeAsync(IHandlerPipeline pipeline) { await foreach (Message message in _consumer.Messages(_cancellation)) { Envelope envelope; try { envelope = _protocol.ReadEnvelope(new DotPulsarMessage(message.Data, message.Properties)); } catch (Exception ex) { _logger.LogException(ex, message: $"Error trying to map an incoming Pulsar {_endpoint.Topic} Topic message to an Envelope. See the Dead Letter Queue"); continue; } try { IChannelCallback channelCallback = new DotPulsarChannelCallback(message.MessageId, _consumer); await pipeline.Invoke(envelope, channelCallback); } catch (Exception e) { // DotPulsar currently doesn't support Nack so will likely just keep retrying message for now. _logger.LogException(e, envelope.Id, "Error trying to receive a message from " + Address); } } }
protected override Task send(Envelope envelope) { var callback = new StubMessageCallback(this); Callbacks.Add(callback); envelope.Callback = callback; return(_pipeline.Invoke(envelope)); }
public Task Send(Envelope envelope, Uri destination) { StubChannel tempQualifier = Channels[destination]; var callback = new StubMessageCallback(tempQualifier); tempQualifier.Callbacks.Add(callback); envelope.Callback = callback; return(_pipeline.Invoke(envelope)); }
public Task Receive(byte[] data, IDictionary <string, string> headers, IMessageCallback callback) { if (data == null) { throw new ArgumentNullException(nameof(data)); } if (headers == null) { throw new ArgumentNullException(nameof(headers)); } if (callback == null) { throw new ArgumentNullException(nameof(callback)); } var envelope = new Envelope(data, callback) { ReceivedAt = _address }; envelope.ContentType = envelope.ContentType ?? "application/json"; return(_pipeline.Invoke(envelope)); }
private Task handleJson(string socketId, string json) { if (_pipeline == null) { return(Task.CompletedTask); } var message = JsonSerialization.DeserializeMessage(json); var envelope = new Envelope(message) { Callback = new WebSocketCallback(_retries) }; return(_pipeline.Invoke(envelope)); }
private async Task ConsumeAsync(IHandlerPipeline pipeline) { while (!_cancellation.IsCancellationRequested) { ConsumeResult <byte[], byte[]> message; try { message = await Task.Run(() => _consumer.Consume(), _cancellation); } catch (Confluent.Kafka.ConsumeException cex) { if (cex.Error.Code == ErrorCode.PolicyViolation) { throw; } continue; } catch (Exception ex) { _logger.LogException(ex, message: $"Error consuming message from Kafka topic {_endpoint.TopicName}"); continue; } Envelope envelope; try { envelope = _protocol.ReadEnvelope(message.Message); } catch (Exception ex) { _logger.LogException(ex, message: $"Error trying to map an incoming Kafka {_endpoint.TopicName} Topic message to an Envelope. See the Dead Letter Queue"); continue; } try { await pipeline.Invoke(envelope, new KafkaChannelCallback(message, _consumer)); } catch (Exception e) { // TODO -- Got to either discard this or defer it back to the queue _logger.LogException(e, envelope.Id, "Error trying to receive a message from " + Address); } } }
public Task EnqueueOutgoing(Envelope envelope) { envelope.ReceivedAt = Destination; envelope.ReplyUri = envelope.ReplyUri ?? DefaultReplyUri; var callback = new StubMessageCallback(this); Callbacks.Add(callback); _stubTransport.Callbacks.Add(callback); Sent.Add(envelope); envelope.Callback = callback; envelope.ReceivedAt = Destination; return(_pipeline.Invoke(envelope)); }
protected override void executeEnvelope(ulong deliveryTag, Envelope envelope) { var callback = new RabbitMqChannelCallback(_channel, deliveryTag, _sender); _pipeline.Invoke(envelope, callback).ContinueWith(t => { if (t.IsFaulted) { _logger.LogException(t.Exception, envelope.Id, "Failure to receive an incoming message"); try { _channel.BasicNack(deliveryTag, false, true); } catch (Exception e) { _logger.LogException(e, envelope.CorrelationId, "Error when trying to Nack a Rabbit MQ message that failed in the HandlerPipeline"); } } }); }
public void AddQueue(string queueName, int parallelization) { var options = new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = parallelization, CancellationToken = _cancellationToken }; if (!_receivers.ContainsKey(queueName)) { var receiver = new ActionBlock <Envelope>(envelope => { envelope.ContentType = envelope.ContentType ?? "application/json"; return(_pipeline.Invoke(envelope)); }, options); _receivers.Add(queueName, receiver); } }
public DurableWorkerQueue(Endpoint endpoint, IHandlerPipeline pipeline, AdvancedSettings settings, IEnvelopePersistence persistence, ITransportLogger logger) { _settings = settings; _persistence = persistence; _logger = logger; endpoint.ExecutionOptions.CancellationToken = settings.Cancellation; _receiver = new ActionBlock <Envelope>(async envelope => { try { envelope.ContentType = envelope.ContentType ?? "application/json"; await pipeline.Invoke(envelope); } catch (Exception e) { // This *should* never happen, but of course it will logger.LogException(e); } }, endpoint.ExecutionOptions); }
public void Retry(Envelope envelope) { _pipeline.Invoke(envelope, this); }
public Task Enqueue(Envelope envelope) { Sent.Add(envelope); return(_pipeline?.Invoke(envelope) ?? Task.CompletedTask); }
public Task Retry() { _outstanding.Clear(); return(_pipeline.Invoke(Envelope)); }
public Task Send(Envelope envelope) { Sent.Add(envelope); return(_pipeline?.Invoke(envelope, new StubChannelCallback(this, envelope)) ?? Task.CompletedTask); }