private async Task Send(IDeliverToEndpoint transporter, EnvelopeToClient envelopeTo)
{
try
{
await transporter.Send(envelopeTo).ConfigureFalse();
}
catch (CouldntSendMessagesException ex)
{
this.LogError(ex);
_config.DeliveryErrorsQueue.TransporterError(ex);
}
//we need the server to not crash if one transporter throws an unhandled exception
catch (Exception ex)
{
this.LogError(ex);
}
}
public async Task receive_message_from_server()
{
var to = new EnvelopeToClient() {To=Setup.TestEndpoint,Messages = new [] {new MyEvent() }};
await _sut.DeliverToLocalProcessors(to).ConfigureFalse();
await _config.Received(1).AddToProcessing(Arg.Any<MyEvent>());
}
public async Task received_but_unkown_messages_are_rejected()
{
var to = new EnvelopeToClient() { To = Setup.TestEndpoint, Messages = new IMessage[] { new MyEvent(),new LocalEvent() } };
await _sut.DeliverToLocalProcessors(to);
await _config.Received(1).AddToProcessing(Arg.Any<MyEvent>());
await _config.DidNotReceive().AddToProcessing(Arg.Any<LocalEvent>());
_err.Received(1).MessagesRejected(Setup.TestEndpoint,Arg.Any<LocalEvent>());
}
public async Task received_messages_are_not_sent_to_server()
{
var to = new EnvelopeToClient() { To = new EndpointId("other", "locat"), Messages = new[] { new MyEvent() } };
await _sut.DeliverToLocalProcessors(to).ConfigureFalse();
await _server.DidNotReceiveWithAnyArgs().SendMessages(null);
}
public async Task receiving_for_unkown_endpoint_sents_to_err_queue()
{
var to = new EnvelopeToClient() { To = new EndpointId("other","locat"), Messages = new[] { new MyEvent() } };
await _sut.DeliverToLocalProcessors(to).ConfigureFalse();
_err.Received(1).UnknownEndpoint(Arg.Any<EndpointNotFoundException>());
await _config.DidNotReceive().AddToProcessing(Arg.Any<MyEvent>());
}
protected override void MarkAsHandled(EnvelopeToClient env)
{
if (Handled != null) throw new Exception("Already handled");
Handled = env;
}
public CouldntSendMessagesException(EnvelopeToClient to,string message,Exception inner):base(message,inner)
{
To = to;
}
public async Task Send(EnvelopeToClient envelope)
{
var store = _factory();
await store.Add(_processorName, envelope.Messages).ConfigureAwait(false);
}
/// <summary>
///
/// </summary>
/// <exception cref="EndpointNotFoundException"></exception>
/// <param name="envelope"></param>
/// <returns></returns>
public async Task DeliverToLocalProcessors(EnvelopeToClient envelope)
{
if (envelope.Messages.Length == 0)
{
this.LogWarn("Received an empty envelope from server");
return;
}
var ep = _endpoints.FirstOrDefault(d => d.Id==envelope.To);
if (ep == null)
{
_errors.UnknownEndpoint(new EndpointNotFoundException(envelope.To, _hostName));
return;
}
var toSend = ep.Filter(envelope.Messages);
if (toSend.Length != envelope.Messages.Length)
{
var diff = toSend.Compare(envelope.Messages, (m1, m2) => m1.Id == m2.Id);
_errors.MessagesRejected(ep.Id, diff.Removed.ToArray());
_auditor.MessagesRejected(envelope.To,diff.Removed);
}
_auditor.DispatchStarted(_hostName,toSend);
await SendToProcessor(ep, toSend).ConfigureFalse();
_auditor.DispatchEnded(toSend);
}
protected abstract void MarkAsHandled(EnvelopeToClient env);
