protected override void ConfigureApplicationContainer(ILifetimeScope container) { Logger.Info("Configuring application container"); base.ConfigureApplicationContainer(container); container.Update(builder => { builder.RegisterInstance(GetConfigurationValue <Auth0Settings>()); builder.RegisterInstance(GetConfigurationValue <RedisSettings>()); builder.RegisterInstance(GetConfigurationValue <StorageSettings>()); builder.RegisterInstance(BusClientFactory.CreateDefault()) .As <IBusClient>(); builder.RegisterModule <DispatcherModule>(); builder.RegisterModule <StorageModule>(); builder.RegisterModule <FilterModule>(); builder.RegisterModule <ServiceModule>(); builder.RegisterModule <EventHandlersModule>(); builder.RegisterModule <InMemoryCacheModule>(); builder.RegisterModule(new TasksModule(typeof(Startup).GetTypeInfo().Assembly)); foreach (var component in _existingContainer.ComponentRegistry.Registrations) { builder.RegisterComponent(component); } }); LifetimeScope = container; }
private void AddRabbitMqService(IServiceCollection services, IConfigurationSection configuration) { var options = new RawRabbitConfiguration(); configuration.Bind(options); services.AddSingleton <IBusClient>(_ => BusClientFactory.CreateDefault(options)); }
public async Task Should_Successfully_Perform_Nested_Requests() { /* Setup */ var payload = Guid.NewGuid(); var requester = BusClientFactory.CreateDefault(); var firstResponder = BusClientFactory.CreateDefault(); var secondResponder = BusClientFactory.CreateDefault(); firstResponder.RespondAsync <FirstRequest, FirstResponse>(async(req, i) => { var secondResp = await firstResponder.RequestAsync <SecondRequest, SecondResponse>(new SecondRequest()); return(new FirstResponse { Infered = secondResp.Source }); }); secondResponder.RespondAsync <SecondRequest, SecondResponse>((req, i) => Task.FromResult(new SecondResponse { Source = payload }) ); /* Test */ var response = await requester.RequestAsync <FirstRequest, FirstResponse>(new FirstRequest()); /* Assert */ Assert.Equal(expected: payload, actual: response.Infered); }
public void Should_Be_Able_To_Delivery_Message_To_Multiple_Subscribers_On_Same_Host() { /* Setup */ var subscriber = BusClientFactory.CreateDefault(); var publisher = BusClientFactory.CreateDefault(); var firstTcs = new TaskCompletionSource <bool>(); var secondTcs = new TaskCompletionSource <bool>(); subscriber.SubscribeAsync <BasicMessage>((message, context) => { firstTcs.SetResult(true); return(Task.FromResult(true)); }); subscriber.SubscribeAsync <BasicMessage>((message, context) => { secondTcs.SetResult(true); return(Task.FromResult(true)); }); /* Test */ var ackTask = publisher.PublishAsync <BasicMessage>(); Task.WaitAll(ackTask, firstTcs.Task, secondTcs.Task); /* Assert */ Assert.True(true, "Published and subscribe sucessfull."); }
public async Task Should_Be_Able_To_Perform_Multiple_Pub_Subs() { /* Setup */ var subscriber = BusClientFactory.CreateDefault(); var publisher = BusClientFactory.CreateDefault(); const int numberOfCalls = 100; var recived = 0; var recievedTcs = new TaskCompletionSource <bool>(); subscriber.SubscribeAsync <BasicMessage>((message, context) => { Interlocked.Increment(ref recived); if (numberOfCalls == recived) { recievedTcs.SetResult(true); } return(Task.FromResult(true)); }); /* Test */ var sw = Stopwatch.StartNew(); for (int i = 0; i < numberOfCalls; i++) { publisher.PublishAsync <BasicMessage>(); } await recievedTcs.Task; sw.Stop(); /* Assert */ Assert.True(true, $"Completed {numberOfCalls} in {sw.ElapsedMilliseconds} ms."); }
public Startup(IHostingEnvironment env, ILogger <Startup> logger) { var builder = new ConfigurationBuilder() .SetBasePath(env.ContentRootPath) .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true) .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true) .AddEnvironmentVariables(); Configuration = builder.Build(); env.ConfigureNLog("NLog.config"); logger.LogInformation("Service started"); var busConfig = new RawRabbitConfiguration { Username = "******", Password = "******", Port = 5672, VirtualHost = "/", Hostnames = { "localhost" } }; var client = BusClientFactory.CreateDefault(busConfig); client.SubscribeAsync <string>(async(json, context) => { var msg = JsonConvert.DeserializeObject <EmailMessage>(json); logger.LogInformation($"Sending email - {msg.EmailAddress} with message {msg.Message}"); }, (cfg) => cfg.WithExchange( ex => ex.WithName("email_exchange")).WithQueue( q => q.WithName("email_queue")).WithRoutingKey("email_command")); }
public void Send(T message) { using (var client = BusClientFactory.CreateDefault()) { client.PublishAsync(message).Wait(); } }
public RabbitQueue(Settings settings) { try { if (settings == null) { throw new ArgumentNullException(nameof(settings)); } var config = new RawRabbitConfiguration() { Port = settings.QueuePortNumber, Username = settings.QueueUsername, Password = settings.QueuePassword, VirtualHost = "/", Hostnames = new List <string> { settings.QueueHostName } }; _busClient = BusClientFactory.CreateDefault(config); } catch (Exception ex) { Log.Error(ex, "Error establishing connection to Queue"); throw; } }
public async Task Should_Retry_For_Publish_Subscribe_After_Given_Timespan() { /* Setup */ var subscriber = BusClientFactory.CreateDefault <AdvancedMessageContext>(); var publisher = BusClientFactory.CreateDefault <AdvancedMessageContext>(); var subscribeTcs = new TaskCompletionSource <bool>(); var delay = TimeSpan.FromSeconds(1); var hasBeenDelayed = false; var firstRecieved = DateTime.MinValue; var secondRecieved = DateTime.MinValue; subscriber.SubscribeAsync <BasicMessage>((message, context) => { if (!hasBeenDelayed) { firstRecieved = DateTime.Now; context.RetryLater(delay); hasBeenDelayed = true; return(Task.FromResult(true)); } secondRecieved = DateTime.Now; return(Task.Delay(10).ContinueWith(t => subscribeTcs.SetResult(true))); }); /* Test */ await publisher.PublishAsync(new BasicMessage { Prop = "I'm about to be reborn!" }); await subscribeTcs.Task; var actualDelay = secondRecieved - firstRecieved; /* Assert */ Assert.Equal(expected: delay.Seconds, actual: actualDelay.Seconds); }
public async Task Should_Be_Able_To_Nack_On_Subscribe() { /* Setup */ var subscriber = BusClientFactory.CreateDefault <AdvancedMessageContext>(); var secondSubscriber = BusClientFactory.CreateDefault <AdvancedMessageContext>(); var publisher = BusClientFactory.CreateDefault <AdvancedMessageContext>(); var callcount = 0; var subscribeTcs = new TaskCompletionSource <bool>(); var secondSubscribeTcs = new TaskCompletionSource <bool>(); subscriber.SubscribeAsync <BasicMessage>((message, context) => { Interlocked.Increment(ref callcount); context?.Nack(); subscribeTcs.TrySetResult(true); return(Task.FromResult(true)); }); secondSubscriber.SubscribeAsync <BasicMessage>((message, context) => { secondSubscribeTcs.TrySetResult(true); return(Task.FromResult(true)); }); Task.WaitAll( publisher.PublishAsync <BasicMessage>(), subscribeTcs.Task, secondSubscribeTcs.Task ); TestChannel.QueueDelete("basicmessage"); Assert.Equal(expected: 1, actual: callcount); }
protected override void ConfigureApplicationContainer(ILifetimeScope container) { base.ConfigureApplicationContainer(container); container.Update(builder => { builder.RegisterInstance(_configuration.GetSettings <MongoDbSettings>()); builder.RegisterInstance(_configuration.GetSettings <FeatureSettings>()); builder.RegisterInstance(_configuration.GetSettings <PaymentPlanSettings>()); builder.RegisterModule <MongoDbModule>(); builder.RegisterModule <InMemoryCacheModule>(); builder.RegisterType <MongoDbInitializer>().As <IDatabaseInitializer>(); builder.RegisterType <DatabaseSeeder>().As <IDatabaseSeeder>(); builder.RegisterInstance(BusClientFactory.CreateDefault()).As <IBusClient>(); builder.RegisterType <UserRepository>().As <IUserRepository>(); builder.RegisterType <PaymentPlanRepository>().As <IPaymentPlanRepository>(); builder.RegisterType <UserPaymentPlanRepository>().As <IUserPaymentPlanRepository>(); builder.RegisterType <WardenChecksCounter>().As <IWardenChecksCounter>(); builder.RegisterType <UserFeaturesManager>().As <IUserFeaturesManager>(); builder.RegisterType <UserPaymentPlanService>().As <IUserPaymentPlanService>(); builder.RegisterType <UserPaymentPlanService>().As <IUserPaymentPlanService>(); builder.RegisterType <RequestNewApiKeyHandler>().As <ICommandHandler <RequestNewApiKey> >(); builder.RegisterType <ApiKeyCreatedHandler>().As <IEventHandler <ApiKeyCreated> >(); builder.RegisterType <RequestWardenCheckResultProcessingResultHandler>() .As <ICommandHandler <RequestWardenCheckResultProcessing> >(); builder.RegisterType <WardenCheckResultProcessedHandler>() .As <IEventHandler <WardenCheckResultProcessed> >(); builder.RegisterType <NewUserSignedInHandler>().As <IEventHandler <NewUserSignedIn> >(); builder.RegisterType <RequestNewWardenHandler>().As <ICommandHandler <RequestNewWarden> >(); builder.RegisterType <WardenCreatedHandler>().As <IEventHandler <WardenCreated> >(); builder.RegisterType <RequestNewOrganizationHandler>().As <ICommandHandler <RequestNewOrganization> >(); builder.RegisterType <OrganizationCreatedHandler>().As <IEventHandler <OrganizationCreated> >(); }); LifetimeScope = container; }
public RabbitWatch(string systemName, string rabbitName, bool enableHeartbeat = true, int heartbeatInteval = 5000) { _client = BusClientFactory.CreateDefault(); _timer = new Timer(); _timer.Elapsed += (state, args) => { var processedCount = Interlocked.Read(ref _processedMessages); Interlocked.Exchange(ref _processedMessages, 0); var diag = new HeartbeatMessage { MessagesProcessed = processedCount.ToString(), RecordedTime = DateTime.Now }; _client.PublishAsync(diag, Guid.NewGuid(), config => { config.WithExchange(exchange => { exchange.WithAutoDelete(false) .WithName("heartbeat") .WithType(ExchangeType.Fanout); }) .WithRoutingKey($"heartbeat.{systemName}.{rabbitName}"); }); }; _timer.Interval = heartbeatInteval; _timer.Enabled = enableHeartbeat; }
public async Task Should_Support_The_Worker_Queues_Tutorial() { /* Setup */ var sent = new BasicMessage { Prop = "Hello, world!" }; var recieved = new TaskCompletionSource <BasicMessage>(); var sender = BusClientFactory.CreateDefault(); var reciever = BusClientFactory.CreateDefault(); reciever.SubscribeAsync <BasicMessage>((message, info) => { recieved.SetResult(message); return(Task.FromResult(true)); }, configuration => configuration .WithPrefetchCount(1) .WithQueue(queue => queue .WithName("task_queue") .WithDurability() ) .WithRoutingKey("task_queue") ); /* Test */ await sender.PublishAsync(sent, configuration : builder => builder .WithRoutingKey("task_queue") ); await recieved.Task; /* Assert */ Assert.Equal(expected: sent.Prop, actual: recieved.Task.Result.Prop); }
public void Receive() { client = BusClientFactory.CreateDefault(); client.SubscribeAsync <T>(async(message, context) => { await Task.Run(() => Received?.Invoke(message)); }); }
public async Task Should_Send_Message_Context_Correctly() { /* Setup */ var subscriber = BusClientFactory.CreateDefault(); var expectedId = Guid.NewGuid(); var subscribeTcs = new TaskCompletionSource <Guid>(); var contextProvider = new MessageContextProvider <MessageContext>(new JsonSerializer(), () => new MessageContext { GlobalRequestId = expectedId }); var publisher = BusClientFactory.CreateDefault(collection => collection.AddSingleton <IMessageContextProvider <MessageContext> >(contextProvider)); subscriber.SubscribeAsync <BasicMessage>((msg, c) => { subscribeTcs.SetResult(c.GlobalRequestId); return(subscribeTcs.Task); }); /* Test */ publisher.PublishAsync <BasicMessage>(); await subscribeTcs.Task; /* Assert */ Assert.Equal(expected: expectedId, actual: subscribeTcs.Task.Result); }
public async Task Should_Retry_And_Leave_Requester_Hanging_On_Rpc() { var requester = BusClientFactory.CreateDefault <AdvancedMessageContext>(); var responder = BusClientFactory.CreateDefault <AdvancedMessageContext>(); var delay = TimeSpan.FromSeconds(1); var hasBeenDelayed = false; var firstRecieved = DateTime.MinValue; var secondRecieved = DateTime.MinValue; responder.RespondAsync <BasicRequest, BasicResponse>((request, context) => { if (!hasBeenDelayed) { firstRecieved = DateTime.Now; hasBeenDelayed = true; context.RetryLater(delay); return(Task.FromResult <BasicResponse>(null)); } secondRecieved = DateTime.Now; return(Task.FromResult(new BasicResponse())); }); /* Test */ var response = await requester.RequestAsync <BasicRequest, BasicResponse>(); var actualDelay = secondRecieved - firstRecieved; /* Assert */ Assert.Equal(expected: delay.Seconds, actual: actualDelay.Seconds); }
public async Task Should_Implicit_Forward_Context_On_Publish() { /* Setup */ var firstCtxTcs = new TaskCompletionSource <MessageContext>(); var secondCtxTcs = new TaskCompletionSource <MessageContext>(); var publisher = BusClientFactory.CreateDefault(); var firstSubscriber = BusClientFactory.CreateDefault(); var secondSubscriber = BusClientFactory.CreateDefault(); firstSubscriber.SubscribeAsync <BasicMessage>((msg, i) => { firstCtxTcs.SetResult(i); firstSubscriber.PublishAsync(new SimpleMessage()); return(firstCtxTcs.Task); }); secondSubscriber.SubscribeAsync <SimpleMessage>((msg, i) => { secondCtxTcs.SetResult(i); return(secondCtxTcs.Task); }); /* Test */ publisher.PublishAsync <BasicMessage>(); Task.WaitAll(firstCtxTcs.Task, secondCtxTcs.Task); /* Assert */ Assert.Equal(firstCtxTcs.Task.Result.GlobalRequestId, secondCtxTcs.Task.Result.GlobalRequestId); }
public IServiceProvider ConfigureServices(IServiceCollection services) { var rmqRetryPolicy = Policy .Handle <ConnectFailureException>() .Or <BrokerUnreachableException>() .Or <IOException>() .WaitAndRetry(5, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (exception, timeSpan, retryCount, context) => { //logger.LogError(new EventId(10001, "RabbitMQ Connect Error"), exception, $"Cannot connect to RabbitMQ. retryCount:{retryCount}, duration:{timeSpan}"); } ); var builder = new ContainerBuilder(); builder.Populate(services); var rawRabbitConfiguration = Configuration.GetSettings <RawRabbitConfiguration>(); builder.RegisterInstance(rawRabbitConfiguration).SingleInstance(); rmqRetryPolicy.Execute(() => builder .RegisterInstance(BusClientFactory.CreateDefault(rawRabbitConfiguration)) .As <IBusClient>() ); var assembly = typeof(Startup).GetTypeInfo().Assembly; builder.RegisterAssemblyTypes(assembly).AsClosedTypesOf(typeof(IEventHandler <>)); builder.RegisterAssemblyTypes(assembly).AsClosedTypesOf(typeof(ICommandHandler <>)); builder.RegisterType <Handler>().As <IHandler>(); LifetimeScope = builder.Build().BeginLifetimeScope(); return(new AutofacServiceProvider(LifetimeScope)); }
public async Task Should_Just_Work() { /* Setup */ const int numberOfCalls = 10000; var array = new Task[numberOfCalls]; var requester = BusClientFactory.CreateDefault(); var responder = BusClientFactory.CreateDefault(); responder.RespondAsync <FirstRequest, FirstResponse>((req, i) => Task.FromResult(new FirstResponse { Infered = Guid.NewGuid() }) ); /* Test */ var sw = new Stopwatch(); sw.Start(); for (var i = 0; i < numberOfCalls; i++) { var response = requester.RequestAsync <FirstRequest, FirstResponse>(); array[i] = response; } Task.WaitAll(array); sw.Stop(); var ids = array .OfType <Task <FirstResponse> >() .Select(b => b.Result.Infered) .Where(id => id != Guid.Empty) .Distinct() .ToList(); /* Assert */ Assert.Equal(expected: numberOfCalls, actual: ids.Count); }
public static void InitializeContainer(this IApplicationBuilder app, Container container, IHostingEnvironment env) { container.RegisterMvcControllers(app); container.RegisterSingleton(() => { var sched = new StdSchedulerFactory().GetScheduler().Result; sched.JobFactory = new SimpleInjectiorJobFactory(container); return(sched); }); container.RegisterSingleton <IBusClient>(() => { var busConfig = new RawRabbitConfiguration { Username = "******", Password = "******", Port = 5672, VirtualHost = "/", Hostnames = { "localhost" } }; var client = BusClientFactory.CreateDefault(busConfig); return(client); }); container.RegisterSingleton <CoreRabbitService>(); container.Verify(); }
//public async Task<IActionResult> RealtimeDashboard() //{ // return View(); //} public async Task ProcessRabbitMsg() { //var busClient = BusClientFactory.CreateDefault(rabbitmq); busClient = BusClientFactory.CreateDefault(new RabbitMqOptions()); //ReaderWriterLockSlim lockSlim = new ReaderWriterLockSlim(); Func <string, MessageContext, Task> func = async delegate(string x, MessageContext y) { Task tk = Task.Factory.StartNew(() => { //boardmsgs.AddOrUpdate(y.GlobalRequestId,key=>x,(key,oldvalue)=>x); //boardmsgsque.Append<BoardMessage>(new BoardMessage { MsgID = y.GlobalRequestId, MsgContent = x }); listbm.Add(new BoardMessage { MsgID = y.GlobalRequestId, MsgContent = x }); //boardmsgsque.Enqueue(new BoardMessage { MsgID = y.GlobalRequestId, MsgContent = x }); }); //tk.Wait(); await tk; }; //lockSlim.EnterWriteLock(); //ViewData["result“] Task tkout = Task.Run( () => { //lockSlim.EnterWriteLock(); busClient.SubscribeAsync <string>((msg, context) => func(msg, context)); //lockSlim.ExitWriteLock(); } ); await tkout; }
public async void TestAddReceive() { var client = BusClientFactory.CreateDefault(); client.SubscribeAsync <SpelGestartEvent>(async(msg, context) => { Assert.AreEqual(1, msg.SpelId); }); Thread.Sleep(500); Spel spel = new Spel() { SpelId = 1, SpelerIds = new List <Speler> { new Speler() { SpelerId = 1 }, new Speler() { SpelerId = 2 }, new Speler() { SpelerId = 3 } }, SpelNaam = "lala" }; await client.PublishAsync(new SpelGestartEvent { SpelerIds = spel.SpelerIds.Select(x => x.SpelerId).ToArray(), SpelId = spel.SpelId }); }
public void Should_Be_Able_To_Deliver_Messages_To_Unique_Subscribers() { /* Setup */ var firstSubscriber = BusClientFactory.CreateDefault(); var secondSubscriber = BusClientFactory.CreateDefault(); var publisher = BusClientFactory.CreateDefault(); var firstTcs = new TaskCompletionSource <bool>(); var secondTcs = new TaskCompletionSource <bool>(); firstSubscriber.SubscribeAsync <BasicMessage>((message, context) => { firstTcs.SetResult(true); return(Task.FromResult(true)); }, cfg => cfg.WithSubscriberId("first_subscriber")); secondSubscriber.SubscribeAsync <BasicMessage>((message, context) => { secondTcs.SetResult(true); return(Task.FromResult(true)); }, cfg => cfg.WithSubscriberId("second_subscriber")); /* Test */ var ackTask = publisher.PublishAsync <BasicMessage>(); Task.WaitAll(ackTask, firstTcs.Task, secondTcs.Task); /* Assert */ Assert.True(true, "Published and subscribe sucessfull."); }
public RabbitManager Connect() { bool isConnected = false; _logger.LogInformation("Connecting to RabbitMQ"); do { try { _busClient = BusClientFactory.CreateDefault(new RawRabbitConfiguration { Hostnames = { _rabbitMqConfiguration.Hostname }, Port = _rabbitMqConfiguration.Port, AutomaticRecovery = true, PersistentDeliveryMode = true, AutoCloseConnection = true, TopologyRecovery = true }); isConnected = true; } catch (ConnectFailureException) { _logger.LogWarning("Failed to connect to RabbitMQ, reconnecting..."); Task.Delay(2000).Wait(); } }while (!isConnected); return(this); }
public void Should_Be_Able_To_Perform_Subscribe_For_Multiple_Types() { /* Setup */ var subscriber = BusClientFactory.CreateDefault(); var publisher = BusClientFactory.CreateDefault(); var basicTcs = new TaskCompletionSource <BasicMessage>(); var simpleTcs = new TaskCompletionSource <SimpleMessage>(); subscriber.SubscribeAsync <BasicMessage>((message, context) => { basicTcs.SetResult(message); return(Task.FromResult(true)); }); subscriber.SubscribeAsync <SimpleMessage>((message, context) => { simpleTcs.SetResult(message); return(Task.FromResult(true)); }); /* Test */ publisher.PublishAsync <BasicMessage>(); publisher.PublishAsync <SimpleMessage>(); Task.WaitAll(basicTcs.Task, simpleTcs.Task); /* Assert */ Assert.True(true, "Successfully recieved messages."); }
public async Task Should_Forward_Context_On_Rpc() { /* Setup */ var tcs = new TaskCompletionSource <bool>(); MessageContext firstContext = null; MessageContext secondContext = null; var requester = BusClientFactory.CreateDefault(); var firstResponder = BusClientFactory.CreateDefault(); var secondResponder = BusClientFactory.CreateDefault(); firstResponder.RespondAsync <FirstRequest, FirstResponse>(async(req, c) => { firstContext = c; var resp = await firstResponder.RequestAsync <SecondRequest, SecondResponse>(new SecondRequest(), c.GlobalRequestId); return(new FirstResponse { Infered = resp.Source }); }); secondResponder.RespondAsync <SecondRequest, SecondResponse>((req, c) => { secondContext = c; tcs.SetResult(true); return(Task.FromResult(new SecondResponse { Source = Guid.NewGuid() })); }); /* Test */ requester.RequestAsync <FirstRequest, FirstResponse>(); await tcs.Task; /* Assert */ Assert.Equal(firstContext.GlobalRequestId, secondContext.GlobalRequestId); }
protected override void ConfigureApplicationContainer(ILifetimeScope container) { base.ConfigureApplicationContainer(container); container.Update(builder => { builder.RegisterInstance(_configuration.GetSettings <MongoDbSettings>()); builder.RegisterInstance(_configuration.GetSettings <ProviderSettings>()); builder.RegisterModule <MongoDbModule>(); builder.RegisterType <MongoDbInitializer>().As <IDatabaseInitializer>(); builder.RegisterInstance(BusClientFactory.CreateDefault()).As <IBusClient>(); builder.RegisterType <ApiKeyRepository>().As <IApiKeyRepository>(); builder.RegisterType <UserRepository>().As <IUserRepository>(); builder.RegisterType <OperationRepository>().As <IOperationRepository>(); builder.RegisterType <OrganizationRepository>().As <IOrganizationRepository>(); builder.RegisterType <WardenCheckResultRootRepository>().As <IWardenCheckResultRootRepository>(); builder.RegisterType <WardenService>().As <IWardenService>(); builder.RegisterType <WardenCheckResultRootService>().As <IWardenCheckResultRootService>(); builder.RegisterType <CustomHttpClient>().As <IHttpClient>(); builder.RegisterType <ServiceClient>().As <IServiceClient>(); builder.RegisterType <ProviderClient>().As <IProviderClient>(); builder.RegisterType <ApiKeyProvider>().As <IApiKeyProvider>(); builder.RegisterType <OperationProvider>().As <IOperationProvider>(); builder.RegisterType <UserProvider>().As <IUserProvider>(); builder.RegisterModule <MapperModule>(); builder.RegisterModule <EventHandlersModule>(); }); LifetimeScope = container; }
public async Task Should_Forward_Context_On_Rpc_To_Publish() { /* Setup */ var tcs = new TaskCompletionSource <bool>(); MessageContext firstContext = null; MessageContext secondContext = null; var requester = BusClientFactory.CreateDefault(); var firstResponder = BusClientFactory.CreateDefault(); var firstSubscriber = BusClientFactory.CreateDefault(); firstResponder.RespondAsync <FirstRequest, FirstResponse>(async(req, c) => { firstContext = c; await firstResponder.PublishAsync(new BasicMessage(), c.GlobalRequestId); return(new FirstResponse()); }); firstSubscriber.SubscribeAsync <BasicMessage>((req, c) => { secondContext = c; tcs.SetResult(true); return(tcs.Task); }); /* Test */ requester.RequestAsync <FirstRequest, FirstResponse>(); await tcs.Task; /* Assert */ Assert.Equal(firstContext.GlobalRequestId, secondContext.GlobalRequestId); }
public async Task Should_Work_When_Not_Awaiting_One_Response_At_A_Time() { /* Setup */ const int numberOfCalls = 10; var tasks = new Task[numberOfCalls]; var requester = BusClientFactory.CreateDefault(); var responder = BusClientFactory.CreateDefault(); responder.RespondAsync <FirstRequest, FirstResponse>((req, i) => Task.FromResult(new FirstResponse { Infered = Guid.NewGuid() })); /* Test */ for (int i = 0; i < numberOfCalls; i++) { var responseTask = requester.RequestAsync <FirstRequest, FirstResponse>(); tasks[i] = responseTask; } Task.WaitAll(tasks); var ids = tasks .OfType <Task <FirstResponse> >() .Select(t => t.Result.Infered) .Distinct() .ToList(); /* Assert */ Assert.Equal(expected: numberOfCalls, actual: ids.Count); }
protected ProxyWorker() { _client = BusClientFactory.CreateDefault(config => { config.AddTransient <IErrorHandlingStrategy, CustomErrorHandling>(); }); }