public SendBenchmark() { _context = new ThroughputTestContext(Guid.NewGuid(), "Payload"); _emptyPipe = Pipe.Empty <TestContext>(); _retryPipe = Pipe.New <TestContext>(x => { x.UseRetry(r => r.Immediate(1)); x.UseFilter(new BenchmarkFilter()); }); _concurrencyPipe = Pipe.New <TestContext>(x => { x.UseConcurrencyLimit(Environment.ProcessorCount); x.UseFilter(new BenchmarkFilter()); }); _doublePipe = Pipe.New <TestContext>(x => { x.UseConcurrencyLimit(Environment.ProcessorCount); x.UseRetry(r => r.Immediate(1)); x.UseFilter(new BenchmarkFilter()); }); _faultPipe = Pipe.New <TestContext>(x => { x.UseRetry(r => r.Immediate(1)); x.UseFilter(new FaultFilter()); }); var dispatchPipe = new PipeRouter(); _dispatchPipe = dispatchPipe; dispatchPipe.ConnectPipe(Pipe.Empty <CommandContext <SetConcurrencyLimit> >()); var doubleDispatchPipe = new PipeRouter(); _doubleDispatchPipe = doubleDispatchPipe; doubleDispatchPipe.ConnectPipe(Pipe.Empty <CommandContext <SetConcurrencyLimit> >()); doubleDispatchPipe.ConnectPipe(Pipe.Empty <CommandContext <SetRateLimit> >()); var tripleDispatchPipe = new PipeRouter(); _tripleDispatchPipe = tripleDispatchPipe; tripleDispatchPipe.ConnectPipe(Pipe.Empty <CommandContext <SetConcurrencyLimit> >()); tripleDispatchPipe.ConnectPipe(Pipe.Empty <CommandContext <SetRateLimit> >()); tripleDispatchPipe.ConnectPipe(Pipe.Empty <CommandContext <CircuitBreakerOpened> >()); }
public void Should_be_called_when_send_faulted() { IPipeRouter router = new PipeRouter(); router.ConnectPipe(Pipe.New <CommandContext <SetConcurrencyLimit> >(cfg => { cfg.UseExecute(cxt => { throw new IntentionalTestException("Wow!"); }); })); var observer = new Observer <CommandContext <SetConcurrencyLimit> >(); router.ConnectObserver(observer); var observer2 = new Observer(); router.ConnectObserver(observer2); Assert.That(async() => await router.SetConcurrencyLimit(32), Throws.TypeOf <IntentionalTestException>()); Assert.That(async() => await observer.SendFaulted, Throws.TypeOf <IntentionalTestException>()); Assert.That(async() => await observer2.SendFaulted, Throws.TypeOf <IntentionalTestException>()); }
public async Task Should_be_called_pre_send() { IPipeRouter router = new PipeRouter(); router.ConnectPipe(Pipe.Empty <CommandContext <SetConcurrencyLimit> >()); var observer = new Observer <CommandContext <SetConcurrencyLimit> >(); router.ConnectObserver(observer); var observer2 = new Observer(); router.ConnectObserver(observer2); await router.SetConcurrencyLimit(32); await observer.PreSent; Assert.That(async() => await observer2.PreSent, Is.InstanceOf <CommandContext <SetConcurrencyLimit> >()); }
public async Task Should_support_interaction_between_filters() { var myFilter = new MyFilter(); IPipeRouter router = new PipeRouter(); IPipe <InputContext> pipe = Pipe.New <InputContext>(cfg => { cfg.UseConcurrencyLimit(10, router); cfg.UseCircuitBreaker(cb => { cb.ActiveThreshold = 5; cb.TrackingPeriod = TimeSpan.FromSeconds(60); cb.TripThreshold = 25; cb.ResetInterval = TimeSpan.FromSeconds(30); cb.Router = router; }); cfg.UseRetry(x => x.Immediate(1)); cfg.UseFilter(myFilter); }); myFilter.Throw = true; router.ConnectPipe(Pipe.New <EventContext <CircuitBreakerOpened> >(x => x.UseFilter(new MyController(router)))); await Task.WhenAll(Enumerable.Range(0, 140).Select(async index => { try { await pipe.Send(new InputContext("Hello")); } catch (Exception ex) { await Console.Out.WriteLineAsync($"{DateTime.Now:mm:ss:fff} - Faulted: {ex.Message}"); } })); }
public async Task Should_allow_the_first_call() { var router = new PipeRouter(); var count = 0; IPipe <TestContext> pipe = Pipe.New <TestContext>(x => { x.UseCircuitBreaker(v => { v.ResetInterval = TimeSpan.FromSeconds(60); v.Router = router; }); x.UseExecute(payload => { Interlocked.Increment(ref count); throw new IntentionalTestException(); }); }); TaskCompletionSource <CircuitBreakerOpened> opened = TaskUtil.GetTask <CircuitBreakerOpened>(); IPipe <EventContext <CircuitBreakerOpened> > observeCircuitBreaker = Pipe.Execute <EventContext <CircuitBreakerOpened> >(x => opened.TrySetResult(x.Event)); router.ConnectPipe(observeCircuitBreaker); var context = new TestContext(); for (var i = 0; i < 100; i++) { Assert.That(async() => await pipe.Send(context).ConfigureAwait(false), Throws.TypeOf <IntentionalTestException>()); } Assert.That(count, Is.EqualTo(6)); await opened.Task; }