public override void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body)
{
DataContractKey dataContractKey = properties.GetDataContractKey();
SerializedBusMessage message = _messageHelper.ConstructMessage(dataContractKey, properties, body);
try
{
_monitor(message);
}
catch (Exception ex)
{
RawBusMessage raw = new RawBusMessage
{
Data = message.Data,
Namespace = message.Namespace,
Name = message.Name,
BusId = message.BusId,
CorrelationId = message.CorrelationId,
Sent = message.Sent
};
foreach (var header in message.Headers)
{
raw.Headers.Add(header);
}
_errorSubscriber.MessageDispatchException(raw, ex);
}
}
public void Bus_PublishRawMessages_MonitorReceiveNotFiltered()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (IBus bus = new RabbitMQBus())
{
List <SerializedBusMessage> actual = new List <SerializedBusMessage>();
SerializedBusMessage toFilterOut = new SerializedBusMessage
{
Name = "SomeOtherName",
Namespace = "",
Data = new byte[] { 0, 2, 31, 11, 22 },
ContentType = "binary"
};
SerializedBusMessage expected = new SerializedBusMessage
{
Name = "MyName",
Namespace = "",
Data = new byte[] { 1, 7, 11, 71 },
ContentType = "binary"
};
Action <SerializedBusMessage> action = message =>
{
actual.Add(message);
};
using (ISubscription monitor = bus.CreateMonitor(action, filterHeaders: new [] { new BusHeader("Name", "MyName") }))
{
monitor.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(toFilterOut);
publisher.Send(expected);
}
ev.WaitOne(TimeSpan.FromSeconds(10));
actual.Count.Should().Be(1);
actual[0].Name.Should().Be("MyName");
actual[0].Namespace.Should().Be("");
Assert.AreEqual(actual[0].Data, expected.Data);
}
}
}
public override Task HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body)
{
DataContractKey dataContractKey = properties.GetDataContractKey();
SerializedBusMessage message = _messageHelper.ConstructMessage(dataContractKey, properties, body);
try
{
_monitor(message);
Model.BasicAck(deliveryTag, false);
}
catch (RejectMessageException)
{
// If reject message exception is thrown -> reject message without requeue it.
// Message will be lost or transfered to dead letter exchange by broker
Model.BasicNack(deliveryTag, false, false);
}
catch (Exception ex)
{
RawBusMessage raw = new RawBusMessage
{
Data = message.Data,
Namespace = message.Namespace,
Name = message.Name,
BusId = message.BusId,
CorrelationId = message.CorrelationId,
Sent = message.Sent
};
foreach (var header in message.Headers)
{
raw.Headers.Add(header);
}
bool requeue = _exceptionFilter.Filter(ex, raw, redelivered, deliveryTag);
Model.BasicNack(deliveryTag, false, requeue);
}
return(Task.FromResult(0));
}
public void Bus_PublishRawMessage_MonitorReceive()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (IBus bus = new RabbitMQBus())
{
SerializedBusMessage actual = null;
SerializedBusMessage expected = new SerializedBusMessage
{
Name = "MyName",
Namespace = "",
Data = new byte[] { 0, 2, 31, 11, 22 },
ContentType = "binary"
};
Action <SerializedBusMessage> action = message =>
{
actual = message;
ev.Set();
};
using (ISubscription monitor = bus.CreateMonitor(action))
{
monitor.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(expected);
}
var waitOne = ev.WaitOne(TimeSpan.FromSeconds(10));
Assert.IsTrue(waitOne);
actual.Should().NotBeNull();
actual.Name.Should().Be("MyName");
actual.Namespace.Should().Be("");
Assert.AreEqual(actual.Data, expected.Data);
}
}
}
public SerializedBusMessage ConstructMessage(DataContractKey dataContractKey, IBasicProperties properties, byte[] data)
{
SerializedBusMessage message = new SerializedBusMessage
{
Data = data,
BusId = properties.AppId,
Sent = properties.Timestamp.GetDateTime(),
Name = dataContractKey.Name,
Namespace = dataContractKey.Ns,
ContentType = properties.ContentType
};
if (properties.IsCorrelationIdPresent())
{
message.CorrelationId = properties.CorrelationId;
}
ConstructHeaders(message, properties);
return(message);
}
private void SendInternal(SerializedBusMessage busMessage, bool persistant, byte?priority)
{
foreach (var header in _configuration.Headers)
{
busMessage.Headers.Add(header);
}
_sendHelper.Send(busMessage, new SendParams
{
BusId = _busId,
Model = _model,
CorrelationId = "",
Exchange = _configuration.Exchange,
MandatoryDelivery = _configuration.MandatoryDelivery,
PersistentDelivery = persistant || _configuration.PersistentDelivery,
RoutingKey = _configuration.RoutingKey,
ReplyTo = _configuration.ReplyTo,
Priority = priority
});
RawBusMessage raw = new RawBusMessage
{
Data = busMessage.Data,
Namespace = busMessage.Namespace,
Name = busMessage.Name,
BusId = busMessage.BusId,
CorrelationId = busMessage.CorrelationId,
Sent = busMessage.Sent
};
foreach (var header in busMessage.Headers)
{
raw.Headers.Add(header);
}
_configuration.Trace.MessageSent(_busId, raw);
}
public void Send(SerializedBusMessage busMessage, bool persistant, byte priority)
{
SendInternal(busMessage, persistant, priority);
}
public void Send(SerializedBusMessage busMessage, bool persistant)
{
SendInternal(busMessage, persistant, null);
}
public void Send(SerializedBusMessage busMessage)
{
SendInternal(busMessage, false, null);
}
public void Send(SerializedBusMessage message, SendParams sendParams)
{
Send(message.Data, message.ContentType, message.Name, message.Namespace, message, sendParams);
}
