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