/// <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 override void MarkAsHandled(EnvelopeToClient env)
{
if (Handled != null)
{
throw new Exception("Already handled");
}
Handled = env;
}
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 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 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>());
}
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>());
}
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 routing_messages_for_each_endpoint()
{
var myEvent = new MyEvent();
var env = new EnvelopeFromClient()
{
From = "some host",
Messages = new IMessage[] { myEvent, new OtherEvent() }
};
EnvelopeToClient dest = null;
await _transporter.Send(Arg.Do <EnvelopeToClient>(e => dest = e));
await _sut.Route(env);
dest.To.Should().Be(Setup.TestEndpoint);
dest.Messages.ShouldAllBeEquivalentTo(new[] { myEvent });
}
