public override void HandleBasicDeliver(String consumerTag, UInt64 deliveryTag, Boolean redelivered, String exchange, String routingKey, IBasicProperties properties, Byte[] body) { base.HandleBasicDeliver(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body); var args = new BasicDeliverEventArgs { ConsumerTag = consumerTag, DeliveryTag = deliveryTag, Redelivered = redelivered, Exchange = exchange, RoutingKey = routingKey, BasicProperties = properties, Body = body }; ConsumeInternalAsync(args); }
public RabbitMessageConverterTests() { _message = new BasicDeliverEventArgs(); _message.BasicProperties = new BasicProperties(); _converter = new RabbitMessageConverter(); }
public virtual void HandleMessage(IBasicConsumer consumer, BasicDeliverEventArgs eventArg) { var completionTask = _jobFactory(eventArg); completionTask.ContinueWith(task => { try { if (task.IsFaulted) { HandleError(consumer, eventArg, task.Exception); } } catch (Exception ex) { _watcher.Error(ex); } finally { // Broadcast msgs AfterHandlingMessage(consumer, eventArg); //NOTE: Only this way, the new event to interupt other consumers will override previous resume event if (HandlingComplete != null) { // Release pool + DoAck HandlingComplete(eventArg); } } }); }
protected virtual void TryReceive(BasicDeliverEventArgs message, Action<IDeliveryContext> callback) { var messageId = message.MessageId(); try { Log.Verbose("Translating wire-specific message into channel message."); this.CurrentMessage = this.adapter.Build(message); Log.Info("Routing message '{0}' received through group '{1}' to configured receiver callback.", messageId, this.configuration.GroupName); callback(this); } catch (ChannelConnectionException) { Log.Warn("The channel has become unavailable, aborting current transaction."); this.CurrentTransaction.TryDispose(); throw; } catch (PoisonMessageException e) { Log.Warn("Wire message {0} could not be deserialized; forwarding to poison message exchange.", messageId); this.ForwardToPoisonMessageExchange(message, e); } catch (DeadLetterException) { Log.Info("Wire message {0} has expired on the wire; forwarding to dead-letter exchange.", messageId); this.ForwardTo(message, this.configuration.DeadLetterExchange); } catch (Exception e) { this.RetryMessage(message, e); } }
protected virtual ChannelMessage Translate(BasicDeliverEventArgs message) { var properties = message.BasicProperties; var dispatched = properties.Timestamp.UnixTime.ToDateTime(); var expiration = properties.Expiration.ToDateTime(dispatched); expiration = expiration == DateTime.MinValue ? DateTime.MaxValue : expiration; if (expiration <= SystemTime.UtcNow) throw new DeadLetterException(expiration); var payload = this.Deserialize(message.Body, properties.Type, properties.ContentFormat(), properties.ContentEncoding); return new ChannelMessage( properties.MessageId.ToGuid(), properties.CorrelationId.ToGuid(), properties.ReplyTo.ToUri(), new Dictionary<string, string>(), payload) { Dispatched = properties.Timestamp.UnixTime.ToDateTime(), Expiration = expiration, Persistent = properties.DeliveryMode == Persistent }; }
public virtual ChannelMessage Build(BasicDeliverEventArgs message) { if (message == null) throw new ArgumentNullException("message"); try { var result = this.Translate(message); this.AppendHeaders(result, message.BasicProperties); return result; } catch (SerializationException e) { Log.Error("Unable to deserialize message '{0}'.".FormatWith(message.MessageId()), e); throw new PoisonMessageException(e.Message, e); } catch (DeadLetterException) { throw; } catch (Exception e) { Log.Error("General deserialize error for message '{0}'.".FormatWith(message.MessageId()), e); throw new PoisonMessageException(e.Message, e); } }
public void Dispose() { isConsuming = false; if (consumer != null) { consumer = null; } if (Connection != null) { Connection.Close(); } if (channel != null) { channel.Abort(); } if (connectionFactory != null) { connectionFactory = null; } if (Connection != null) { Connection.Abort(); } if (e != null) { e = null; } }
public void DeserializeThrows() { const String type = "fake-type"; const String contentType = "application/null"; var body = new Byte[] { }; var args = new BasicDeliverEventArgs { Body = body, BasicProperties = new BasicProperties { ContentType = contentType, Type = type } }; var context = ConsumedMessageContext.FromBasicDeliverEventArgs(args); var runtimeType = typeof(Foo); var serializer = new Mock<ISerializer>(); serializer.Setup(_ => _.Deserialize(body, runtimeType, new UTF8Encoding(true))) .Throws(new Exception("boom")); var serializationConfiguration = new SerializationConfigurationWrapper(serializer.Object); var resolver = new Mock<IMessageTypeResolver>(); resolver.Setup(_ => _.Resolve(context)).Returns(new MessageBinding(type, runtimeType)); var builder = new ConsumedMessageBuilder(serializationConfiguration, resolver.Object); var message = builder.Build(args); Assert.IsType<CorruptedMessage>(message); }
public static ConsumedMessageContext FromBasicDeliverEventArgs(BasicDeliverEventArgs args) { if (args == null) throw new ArgumentNullException(nameof(args)); return new ConsumedMessageContext(args); }
private void HandleMessage(BasicDeliverEventArgs result) { var data = Encoding.UTF8.GetString(result.Body); var telegram = new Telegram(data); var telegramEventArgs = new TelegramReceivedEventArgs(telegram); OnTelegramReceived(telegramEventArgs); }
public virtual Task OnResponseHandlerExceptionAsync(IRawConsumer rawConsumer, IConsumerConfiguration cfg, BasicDeliverEventArgs args, Exception exception) { _logger.LogError($"An unhandled exception was thrown in the response handler for message '{args.BasicProperties.MessageId}'.", exception); var innerException = UnwrapInnerException(exception); var rawException = new MessageHandlerException( message: $"An unhandled exception was thrown when consuming a message\n MessageId: {args.BasicProperties.MessageId}\n Queue: '{cfg.Queue.FullQueueName}'\n Exchange: '{cfg.Exchange.ExchangeName}'\nSee inner exception for more details.", inner: innerException ); _logger.LogInformation($"Sending MessageHandlerException with CorrelationId '{args.BasicProperties.CorrelationId}'"); rawConsumer.Model.BasicPublish( exchange: string.Empty, routingKey: args.BasicProperties?.ReplyTo ?? string.Empty, basicProperties: _propertiesProvider.GetProperties<MessageHandlerException>(p => { p.CorrelationId = args.BasicProperties?.CorrelationId ?? string.Empty; p.Headers.Add(PropertyHeaders.ExceptionHeader, _messageExceptionName); }), body: _serializer.Serialize(rawException) ); if (!cfg.NoAck) { _logger.LogDebug($"Nack'ing message with delivery tag '{args.DeliveryTag}'."); rawConsumer.Model.BasicNack(args.DeliveryTag, false, false); } return Task.FromResult(true); }
private static void rate_limit_notify(IBasicConsumer consumer, BasicDeliverEventArgs eargs) { string[] EMAIL_RECIPS = new string[] {"*****@*****.**"}; IBasicProperties msg_props = eargs.BasicProperties; String msg_body = Encoding.ASCII.GetString(eargs.Body); //#/(ascdn.4) Decode our message from JSON msg_body = JsonConvert.DeserializeObject <string>(msg_body); //#/(ascdn.5) Transmit e-mail to SMTP server send_mail(EMAIL_RECIPS, "RATE LIMIT ALERT!", msg_body); Console.WriteLine("Sent alert via e-mail! Alert Text: " + msg_body + " Recipients: " + string.Join(",", EMAIL_RECIPS)); //#/(ascdn.6) Acknowledge the message consumer.Model.BasicAck(eargs.DeliveryTag, false); }
public void HeaderMapping() { var content = new Foo(); const String messageId = "one-id"; const Int64 timestamp = 123456789L; const String replyExchangeType = "direct"; const String replyExchangeName = "exchange-name"; const String replyRoutingKey = "routing-key"; const String correlationId = "one-correlation-id"; var replyTo = $"{replyExchangeType}://{replyExchangeName}/{replyRoutingKey}"; var args = new BasicDeliverEventArgs { BasicProperties = new BasicProperties { MessageId = messageId, Timestamp = new AmqpTimestamp(timestamp), CorrelationId = correlationId, ReplyTo = replyTo } }; var message = new FakeConsumedMessage(content, args); var actual = message.To<Foo>(); Assert.Equal(messageId, actual.Headers.MessageId); Assert.Equal(timestamp, actual.Headers.Timestamp); Assert.Equal(correlationId, actual.Headers.CorrelationId); Assert.Equal(replyTo, actual.Headers.ReplyConfiguration.ToString()); }
internal static HeaderCollection Parse(BasicDeliverEventArgs args) { return new HeaderCollection(new Dictionary<String, Object>(StringComparer.OrdinalIgnoreCase) { { "message_id", args.BasicProperties.MessageId }, { "timestamp", args.BasicProperties.Timestamp.UnixTime } }); }
private static Encoding Encoding(BasicDeliverEventArgs args) { var encoding = args.BasicProperties.ContentEncoding; return encoding == null ? new UTF8Encoding(true) : System.Text.Encoding.GetEncoding(encoding); }
private static LogOrderQueueItem GetQueueItem(BasicDeliverEventArgs deliverEventArgs) { return deliverEventArgs.Body .ToOption() .Map(Encoding.UTF8.GetString) .Map(JsonConvert.DeserializeObject<LogOrderQueueItem>) .Value; }
private string MakePayment(BasicDeliverEventArgs ea) { var payment = (CardPayment)ea.Body.DeSerialize(typeof(CardPayment)); var response = _rnd.Next(1000, 100000000).ToString(CultureInfo.InvariantCulture); Console.WriteLine("Payment - {0} : £{1} : Auth Code <{2}> ", payment.CardNumber, payment.Amount, response); return response; }
private void OnReceived(object sender, BasicDeliverEventArgs basicDeliverEventArgs) { lock (_receivedMessages) { _receivedMessages.Add(basicDeliverEventArgs); _autoResetEvent.Set(); } }
private static void EventHandler_Received(object sender, BasicDeliverEventArgs e) { var message = Encoding.UTF8.GetString(e.Body); Console.WriteLine("Start processing - {0}", message); var sleepSeconds = message.Count(x => x == '.'); Thread.Sleep(sleepSeconds * 1000); (sender as IBasicConsumer).Model.BasicAck(e.DeliveryTag, false); Console.WriteLine("Completed - {0}", message); }
public BasicDeliveryEventArgs(BasicDeliverEventArgs args) { BasicProperties = args.BasicProperties; Body = args.Body; DeliveryTag = args.DeliveryTag; Exchange = args.Exchange; Redelivered = args.Redelivered; RoutingKey = args.RoutingKey; }
public void CannotResolve() { const String source = "urn:message:no-resolve"; var args = new BasicDeliverEventArgs { BasicProperties = new BasicProperties { Type = source } }; var context = ConsumedMessageContext.FromBasicDeliverEventArgs(args); var type = typeof(Foo); var resolver = new MessageBindingResolver(type.Assembly); Assert.IsType<EmptyMessageBinding>(resolver.Resolve(context)); }
private void ConsumerOnReceived(IBasicConsumer sender, BasicDeliverEventArgs args) { var millisecondsTimeout = m_rnd.Next(1, 10) * 1000; Console.WriteLine("Message received: {0}, sleeping for {1} seconds", Encoding.UTF8.GetString(args.Body), millisecondsTimeout/1000); Thread.Sleep(millisecondsTimeout); sender.Model.BasicAck(args.DeliveryTag, false); }
private static ConsumedMessage Content(BasicDeliverEventArgs args, ISerializer serializer, MessageType messageType) { return new ConsumedMessage(serializer.Deserialize(args.Body, messageType.RuntimeType, Encoding(args)), args); }
public RabbitMqFetchedJob(BasicDeliverEventArgs message, ref IModel channel) { if (message == null) throw new ArgumentNullException("message"); _message = message; _channel = channel; JobId = Encoding.UTF8.GetString(_message.Body); }
private void ResponseReceived(object sender, BasicDeliverEventArgs evt) { var correlationId = _correlationId; var expected = _expected; if (expected != null && !String.IsNullOrEmpty(evt.BasicProperties.CorrelationId) && evt.BasicProperties.CorrelationId == correlationId) { RPCStrategyHelpers.ReadAndSignalDelivery(expected, evt); } }
public BasicDeliverEventArgs Pop() { BasicDeliverEventArgs result; lock (_lock) { result = _lastItem; _lastItem = null; } return result; }
public void Process( IModel channel, BasicDeliverEventArgs message) { var _logMessageContext = string.Format("type header = {0}, message Id = {1}, correlation Id = {2} and delivery tag = {3}", message.BasicProperties.Type, message.BasicProperties.MessageId, message.BasicProperties.CorrelationId, message.DeliveryTag); this.c_logger.DebugFormat("Process About to handle message, {0}", _logMessageContext); if (!this.c_configuration.MessageConsumers.HasConfiguration(message.BasicProperties.Type)) { this.c_logger.DebugFormat("Process No match found for message, {0}", _logMessageContext); //pending - see errored below channel.BasicNack(message.DeliveryTag, false, false); return; } var _configuration = this.c_configuration.MessageConsumers[message.BasicProperties.Type]; var _actionResult = ConsumerHandlerResult.None; try { this.c_logger.DebugFormat("Process About to deserialze message for message, {0}", _logMessageContext); var _messageJson = Encoding.UTF8.GetString(message.Body); var _message = JsonConvert.DeserializeObject(_messageJson, _configuration.Type); this.c_logger.DebugFormat("Process About to invoke action for message, {0}", _logMessageContext); _actionResult = _configuration.Action(_message as Message); } catch (Exception exception) { this.c_logger.WarnFormat("Process Encountered error for message {0} Error: {1}", _logMessageContext, exception.InstrumentationString()); _actionResult = ConsumerHandlerResult.Errored; } this.c_logger.DebugFormat("Process Completed processing for message, {0}, result is {1}", _logMessageContext, _actionResult); if (_actionResult == ConsumerHandlerResult.Errored) { //pending - should i use configuration properties // Nack, do not requeue, dead letter the message if dead letter exchange configured for the queue channel.BasicNack(message.DeliveryTag, false, false); } else if (_actionResult == ConsumerHandlerResult.Completed) { channel.BasicAck(message.DeliveryTag, false); } else if (_actionResult == ConsumerHandlerResult.Requeue) { //pending does this make sense ? channel.BasicReject(message.DeliveryTag, true); } this.c_logger.DebugFormat("Process Completed handling message, {0}, Result is {1}", _logMessageContext, _actionResult); }
public void Resolve() { const String source = "urn:message:foo"; var args = new BasicDeliverEventArgs { BasicProperties = new BasicProperties { Type = source } }; var context = ConsumedMessageContext.FromBasicDeliverEventArgs(args); var type = typeof(Foo); var resolver = new MessageBindingResolver(type.Assembly); var binding = resolver.Resolve(context); Assert.Equal(source, binding.RawName); Assert.Equal(type, binding.RuntimeType); }
protected override Task<AggregateConsumingResult> ConsumeInternalAsync(BasicDeliverEventArgs args) { InboundChannel.Acknowledge(args.DeliveryTag); return ConsumeAsync(args).ContinueWith(_ => { var result = _.Result; result.NotifyConsumingCompletion(); return result; }); }
public override bool Dequeue(TimeSpan timeout, out BasicDeliverEventArgs message) { bool dequeue = base.Dequeue(timeout, out message); if (dequeue) { Model.BasicAck(message.DeliveryTag, false); } return dequeue; }
public void Consume() { QueueingBasicConsumer consumer = new QueueingBasicConsumer(Model); String consumerTag = Model.BasicConsume("dotNetQueue", false, consumer); while (isConsuming) { RabbitMQ.Client.Events.BasicDeliverEventArgs e = (RabbitMQ.Client.Events.BasicDeliverEventArgs)consumer.Queue.Dequeue(); IBasicProperties props = e.BasicProperties; byte[] body = e.Body; onMessageReceived(body); Model.BasicAck(e.DeliveryTag, false); } }
public void Consume() { consumer = new QueueingBasicConsumer(channel); bool autoAck = false; String consumerTag = channel.BasicConsume("", autoAck, consumer); while (isConsuming) { try { if (consumer != null) { e = (RabbitMQ.Client.Events.BasicDeliverEventArgs) consumer.Queue.Dequeue(); IBasicProperties props = e.BasicProperties; byte[] body = e.Body; string cade = System.Text.Encoding.UTF8.GetString(body); try { System.Text.Encoding.UTF8.GetString(body); onMessageReceived(body); channel.BasicAck(e.DeliveryTag, false); } catch (Exception e) { Console.WriteLine("Error: en combertir el JSON"); } } } catch (OperationInterruptedException ex) { break; } } }
public void CaRunConsumeWithNotNullMessageWithAck() { // Arrange var message = new RabbitMQ.Client.Events.BasicDeliverEventArgs() { DeliveryTag = 42 }; ulong ackId = 0; var ra = new RabbitAdapter(1, id => { ackId = id; }); // Act ra.ConsumeData(null, message); // Assert ackId.Should().Be(message.DeliveryTag); }
private void ConsumerEvent_Received(object sender, RabbitMQ.Client.Events.BasicDeliverEventArgs e) { }
private void ConsumerReceived(IBasicConsumer sender, BasicDeliverEventArgs args) { var serializer = new BinarySerializer<string>(); var message = serializer.DeSerialize(args.Body); OnMessageReceived(message); }