public static Func <ICommand, Task> Run(CancellationToken token, Subject <IEvent> eventSubject, Action <string> logger)
{
const string streamName = "hamsters";
var commitLog = new MessageVaultClientAdapter(new MemoryClient(), logger);
var dispatcher = new Dispatcher <ICommand, Task>();
var eventHandlers = new Dispatcher <IEvent, Task>();
var checkpointWriter = new CheckpointWriterAdapter(new MemoryCheckpointReaderWriter());
var repository = new InMemoryStateRepository <HamsterState>();
var streamProcessor = new StreamProcessor(commitLog, streamName, checkpointWriter, Serialization.Deserializer(), Console.WriteLine);
var eventLog = commitLog.ToStreamPoster(Serialization.Serializer());
dispatcher.Register <IHamsterCommand>(
command => ApplicationService.Execute(
command,
id => repository.GetOrCreateAsync(id),
state => new HamsterAggregate(state),
aggregate => aggregate.Handle(command),
eventLog.ForStream(streamName)));
eventHandlers.Register <IEvent>(@event => StateEventHandler.ForAsync(@event, repository));
eventSubject.Subscribe(@event => eventHandlers.Dispatch(@event).Wait(token), () => { }, token);
streamProcessor.Run(token, @event => eventSubject.OnNext(@event));
return(dispatcher.Dispatch);
return(Mixins.WaitForEventsPublished(dispatcher.Dispatch, eventSubject, logger));
}
public async Task WhenExecutingBasicStateActionsThenFlowCompletesSuccesfully()
{
IStateRepository stateRepository = new InMemoryStateRepository();
var originalState = new TestState
{
Field1 = "testdata",
Field2 = new List <DateTime> {
new DateTime(2018, 02, 15)
},
Field3 = true
};
await stateRepository.StoreStateAsync("key", originalState, CancellationToken.None);
var retrievedState = await stateRepository.GetStateAsync <TestState>("key", CancellationToken.None);
// validate
Assert.AreEqual(originalState.Field1, retrievedState.Field1);
CollectionAssert.AreEquivalent(originalState.Field2, retrievedState.Field2);
Assert.AreEqual(originalState.Field3, retrievedState.Field3);
Assert.AreEqual(originalState.Field4, retrievedState.Field4);
// update existing state
var updatedState = new TestState
{
Field1 = null,
Field2 = new List <DateTime> {
new DateTime(2018, 02, 15)
},
Field3 = true
};
await stateRepository.StoreStateAsync("key", updatedState, CancellationToken.None);
retrievedState = await stateRepository.GetStateAsync <TestState>("key", CancellationToken.None);
// validate
Assert.AreEqual(updatedState.Field1, retrievedState.Field1);
CollectionAssert.AreEquivalent(updatedState.Field2, retrievedState.Field2);
Assert.AreEqual(updatedState.Field3, retrievedState.Field3);
Assert.AreEqual(updatedState.Field4, retrievedState.Field4);
await stateRepository.StoreStateAsync("key2", originalState, CancellationToken.None);
await stateRepository.DeleteStateAsync("key", CancellationToken.None);
retrievedState = await stateRepository.GetStateAsync <TestState>("key", CancellationToken.None);
Assert.IsNull(retrievedState);
retrievedState = await stateRepository.GetStateAsync <TestState>("key2", CancellationToken.None);
Assert.IsNotNull(retrievedState);
}
public void WhenRunningMultipleStateActionsInParallelThenNoExceptionIsThrown()
{
var stateRepo = new InMemoryStateRepository();
Random random = new Random();
List <string> keys = Enumerable.Range(1, 10000)
.Select(num => random.Next(10).ToString())
.ToList();
Parallel.ForEach(keys, key => TestSingleRun(key).Wait());
}
static async void Bot_OnMessage(object sender, MessageEventArgs args)
{
var processingMiddleware = new ProcessingMiddlewareBuilder()
.AddTelegramClient((ITelegramBotClient)sender)
.AddComponent(new IncomingMessageLogger())
//.AddComponent(new IncomingMessageThrottler(InMemoryRateLimiter.GetInstance()))
.AddComponent(new IncomingMessageThrottler(new MemuraiDbRateLimiter(), 50))
.AddComponent(new MessageProcessingLogic(InMemoryStateRepository.GetInstance()))
.Build();
processingMiddleware.ProcessRequest(args);
await Task.CompletedTask;
}
private static async Task TestSingleRun(string key)
{
var stateRepo = new InMemoryStateRepository();
var state = new List <int> {
5, 10
};
await stateRepo.StoreStateAsync(key, state, CancellationToken.None);
await stateRepo.GetStateAsync <List <int> >(key, CancellationToken.None);
await stateRepo.StoreStateAsync(key, state, CancellationToken.None);
await stateRepo.GetStateAsync <List <int> >(key, CancellationToken.None);
await stateRepo.DeleteStateAsync(key, CancellationToken.None);
await stateRepo.GetStateAsync <List <int> >(key, CancellationToken.None);
}
public static IState CreateStateRepository()
{
string mode = ConfigurationManager.AppSettings["Mode"].ToString();
IState repo;
switch (mode.ToUpper())
{
case "TEST":
repo = new InMemoryStateRepository();
break;
case "PROD":
repo = new FileStateRepository();
break;
default:
throw new Exception("No such repository, check your settings");
}
return(repo);
}
public MessageProcessingLogic(
InMemoryStateRepository stateRepository)
{
_stateRepository = stateRepository;
}
