protected override void MarkAsHandled(EnvelopeFromClient envs) { if (Handled != null) { throw new Exception("Already handled"); } Handled = envs; }
public async Task messages_arent_sent_back_to_origin() { var myEvent = new MyEvent(); var env = new EnvelopeFromClient() { From = Setup.TestEndpoint.Host, Messages = new IMessage[] { myEvent, new OtherEvent() } }; await _sut.Route(env); await _transporter.DidNotReceiveWithAnyArgs().Send(null); }
public async Task transporter_error_goes_to_err_queue() { var exception = new CouldntSendMessagesException(new EnvelopeToClient(), "", new Exception()); _transporter.Send(Arg.Any <EnvelopeToClient>()).Throws(exception); var env = new EnvelopeFromClient() { From = "other", Messages = new IMessage[] { new MyEvent(), new OtherEvent() } }; await _sut.Route(env); _err.Received(1).TransporterError(exception); }
public EnvelopeToClient[] GetEnvelopes(EnvelopeFromClient envelope) { IEnumerable <KeyValuePair <EndpointId, string[]> > items = Items; return(items .Where(d => d.Key.Host != envelope.From) .Select(kv => new EnvelopeToClient() { To = kv.Key, Messages = FilterEndpointMessages(kv.Value, envelope.Messages).ToArray() }) .Where(e => e.Messages.Any()) .ToArray()); }
public Task Route(EnvelopeFromClient envelope) { var delivery = _state.GetEnvelopes(envelope) .Select(d => { var transporter = _config.Transporters.GetTransporter(d.To); if (transporter == null) { this.LogError($"There is no transporter defined for {d.To}"); return(TasksUtils.EmptyTask()); } return(Send(transporter, d)); }).ToArray(); return(Task.WhenAll(delivery)); }
public async Task messages_are_sent_local_and_server() { var myEvent = new MyEvent(); var command = new MyCommand(); EnvelopeFromClient env = null; await _server.SendMessages(Arg.Do <EnvelopeFromClient>(e => env = e)); await _sut.Dispatch(myEvent, command); await _config.Received(1).AddToProcessing(Arg.Any <MyEvent>(), Arg.Any <MyCommand>()); await _server.ReceivedWithAnyArgs(1).SendMessages(null); env.From.Should().Be(Setup.TestEndpoint.Host); env.Messages.ShouldAllBeEquivalentTo(new IMessage[] { myEvent, command }); }
public async Task if_transport_doesnt_exist_nothing_happens() { var env = new EnvelopeFromClient() { From = Setup.TestEndpoint.Host, Messages = new IMessage[] { new MyEvent(), new OtherEvent() } }; _sut.ReceiveConfigurations(new [] { new EndpointMessagesConfig() { Endpoint = new EndpointId("other", "local") , MessageTypes = new [] { typeof(OtherEvent).AsMessageName() } } }); await _sut.Route(env); }
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 }); }
/// <exception cref="CouldntSendMessagesException"></exception> public async Task SendMessages(EnvelopeFromClient envelope) { try { await _db.HandleTransientErrorsAsync(CancellationToken.None, (db, tok) => db.InsertAsync(new ClientToServerRow() { DataId = envelope.Id.ToString(), Type = ClientMessageType.Envelope, Data = envelope.Serialize().ToByteArray() }, tok), wait : 200).ConfigureFalse(); } catch (DbException ex) { throw new CouldntSendMessagesException(envelope, "Error adding to storage", ex); } }
public async Task send_receive_client_messages() { var envelope = new EnvelopeFromClient() { From = "local", Id = Guid.NewGuid(), Messages = new[] { new MyEvent() } }; await _clientToServer.SendMessages(envelope); _cfg.MessageNotifier.Start(); await Task.Delay(100).ConfigureFalse(); await _serverRoute.ReceivedWithAnyArgs(1).Route(null); _serverRoute.ReceivedCalls().First().GetArguments()[0].ShouldBeEquivalentTo(envelope); }
public Task SendMessages(EnvelopeFromClient envelope) => TasksUtils.EmptyTask();
protected override void MarkAsHandled(EnvelopeFromClient envs) { _db.HandleTransientErrors( db => db.DeleteFrom <ClientToServerRow>(t => t.DataId == envs.Id.ToString() && t.Type == ClientMessageType.Envelope)); }
public Task Route(EnvelopeFromClient envelope) { envelope.MustNotBeNull(); Routed++; return(Task.WhenAll()); }