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>();
});
}