public void Receive(Func <IReceiveContext, Action <IReceiveContext> > callback, TimeSpan timeout)
{
AddManagementBinding();
AddReceiverBinding();
_connectionHandler.Use(connection =>
{
BrokeredMessage message = _receiver.Get(timeout);
if (message == null)
{
return;
}
using (var body = new MemoryStream(message.GetBody <MessageEnvelope>().ActualBody, false))
{
ReceiveContext context = ReceiveContext.FromBodyStream(body);
context.SetMessageId(message.MessageId);
context.SetInputAddress(Address);
context.SetCorrelationId(message.CorrelationId);
context.SetContentType(message.ContentType);
if (_logger.IsDebugEnabled)
{
TraceMessage(context);
}
Action <IReceiveContext> receive = callback(context);
if (receive == null)
{
Address.LogSkipped(message.MessageId);
return;
}
receive(context);
try
{
message.Complete();
}
catch (MessageLockLostException ex)
{
if (_logger.IsErrorEnabled)
{
_logger.Error("Message Lock Lost on message Complete()", ex);
}
}
catch (MessagingException ex)
{
if (_logger.IsErrorEnabled)
{
_logger.Error("Generic MessagingException thrown", ex);
}
}
}
});
}
public void Receive(Func <IReceiveContext, Action <IReceiveContext> > lookupSinkChain, TimeSpan timeout)
{
AddConsumerBinding();
_connectionHandler.Use(connection =>
{
BasicGetResult result = null;
try
{
result = _consumer.Get();
if (result == null)
{
Thread.Sleep(10);
return;
}
using (var body = new MemoryStream(result.Body, false))
{
ReceiveContext context = ReceiveContext.FromBodyStream(body);
context.SetMessageId(result.BasicProperties.MessageId ?? result.DeliveryTag.ToString());
result.BasicProperties.MessageId = context.MessageId;
context.SetInputAddress(_address);
byte[] contentType = result.BasicProperties.IsHeadersPresent()
? (byte[])result.BasicProperties.Headers["Content-Type"]
: null;
if (contentType != null)
{
context.SetContentType(Encoding.UTF8.GetString(contentType));
}
Action <IReceiveContext> receive = lookupSinkChain(context);
if (receive == null)
{
Address.LogSkipped(result.BasicProperties.MessageId);
_consumer.MessageSkipped(result);
}
else
{
receive(context);
_consumer.MessageCompleted(result);
}
}
}
catch (AlreadyClosedException ex)
{
throw new InvalidConnectionException(_address.Uri, "Connection was already closed", ex);
}
catch (EndOfStreamException ex)
{
throw new InvalidConnectionException(_address.Uri, "Connection was closed", ex);
}
catch (OperationInterruptedException ex)
{
throw new InvalidConnectionException(_address.Uri, "Operation was interrupted", ex);
}
catch (Exception ex)
{
_log.Error("Failed to consume message from endpoint", ex);
if (result != null)
{
_consumer.MessageFailed(result);
}
throw;
}
});
}
public void Receive(Func <IReceiveContext, Action <IReceiveContext> > callback, TimeSpan timeout)
{
AddConsumerBinding();
_connectionHandler.Use(connection =>
{
BrokeredMessage message = _consumer.Get(timeout);
if (message == null)
{
return;
}
using (var stream = message.GetBody <Stream>())
{
ReceiveContext context = ReceiveContext.FromBodyStream(stream);
context.SetMessageId(message.MessageId);
context.SetInputAddress(Address);
context.SetCorrelationId(message.CorrelationId);
context.SetContentType(message.ContentType);
Action <IReceiveContext> receive = callback(context);
if (receive == null)
{
Address.LogSkipped(message.MessageId);
return;
}
try
{
receive(context);
}
catch (Exception ex)
{
if (_logger.IsErrorEnabled)
{
_logger.Error("Consumer threw an exception", ex);
}
message.Abandon();
}
try
{
message.Complete();
}
catch (MessageLockLostException ex)
{
if (_logger.IsErrorEnabled)
{
_logger.Error("Message Lock Lost on message Complete()", ex);
}
}
catch (MessagingException ex)
{
if (_logger.IsErrorEnabled)
{
_logger.Error("Generic MessagingException thrown", ex);
}
}
}
});
}
