public async Task run_parent_child_scenario()
        {
            var hostBuilder = CreateHostBuilder();

            var message = new StartParentSaga(Guid.NewGuid(), Guid.NewGuid());

            var received    = false;
            var tokenSource = new CancellationTokenSource(TimeSpan.FromMinutes(2));

            Action <ParentSagaCompleted> onMessage = msg =>
            {
                received = true;
                tokenSource.Cancel();
            };

            hostBuilder.ConfigureServices((ctx, services) => { services.AddSingleton(onMessage); });

            var host = hostBuilder.Build();

            await host.SetupInfrastructureAsync();

            using var scope = host.Services.CreateScope();
            var bus = scope.ServiceProvider.GetRequiredService <IMessageBus>();

            await Task.WhenAll(new[]
            {
                host.RunAsync(token: tokenSource.Token),
                bus.PublishAsync(message, tokenSource.Token)
            });

            received.Should().BeTrue();
        }
Exemplo n.º 2
0
        public async Task run_parent_child_scenario(int hostsCount)
        {
            var message = new StartParentSaga(Guid.NewGuid(), Guid.NewGuid());

            var receivedCount = 0;
            var tokenSource   = new CancellationTokenSource(TimeSpan.FromMinutes(2));

            Action <IMessageContext <ParentSagaCompleted> > onMessage = ctx =>
            {
                receivedCount++;
                tokenSource.CancelAfter(TimeSpan.FromSeconds(10));

                ctx.Message.CorrelationId.Should().Be(message.CorrelationId);
            };

            var createHostTasks = Enumerable.Range(1, hostsCount)
                                  .Select(async i =>
            {
                var host = await SetupHost(onMessage);
                await host.StartAsync(tokenSource.Token);
                return(host);
            }).ToArray();

            await Task.WhenAll(createHostTasks);

            if (tokenSource.IsCancellationRequested)
            {
                throw new Exception("a timeout occurred during hosts initialization.");
            }

            var producerHost = createHostTasks.First().Result;

            using var scope = producerHost.Services.CreateScope();
            var bus = scope.ServiceProvider.GetRequiredService <IMessageBus>();
            await bus.PublishAsync(message, tokenSource.Token);

            while (!tokenSource.IsCancellationRequested)
            {
                await Task.Delay(10);
            }

            foreach (var t in createHostTasks)
            {
                try
                {
                    t.Result.Dispose();
                }
                catch {}
            }

            receivedCount.Should().Be(1);
        }
Exemplo n.º 3
0
        static async Task Main(string[] args)
        {
            var hostBuilder = CreateHostBuilder(args);
            var host        = hostBuilder.Build();

            using var scope = host.Services.CreateScope();
            var bus     = scope.ServiceProvider.GetRequiredService <IMessageBus>();
            var message = new StartParentSaga(Guid.NewGuid(), Guid.NewGuid());

            await Task.WhenAll(new[]
            {
                host.RunAsync(),
                bus.PublishAsync(message)
            });
        }