public void messages_for_one_batch_should_have_one_write()
{
var storage = new InMemoryEventStorage();
var writer = new EventStorageWriter(10, TimeSpan.FromMinutes(1), storage);
var task1 = writer.Store(new CommitForStorage("foo", "stream1",
new EventForStorage(Guid.NewGuid(), 1, DateTime.Now, "type", null, "body")));
var task2 = writer.Store(new CommitForStorage("foo", "stream2",
new EventForStorage(Guid.NewGuid(), 1, DateTime.Now, "type", null, "body")));
writer.Start(_token.Token);
Task.WhenAll(task1, task2).Wait(1000);
Assert.AreEqual(1, storage.WriteCount);
}
public PublishEndpoint(EventStorageWriter eventStorageWriter, ResConfiguration config)
{
var ctx = NetMQContext.Create();
_ctx = ctx;
var outBuffer = new OutBuffer(config.PublishEndpoint.BufferSize);
var dispatcher = new TcpMessageDispatcher();
dispatcher.Register(ResCommands.AppendCommit, new CommitHandler(eventStorageWriter, outBuffer));
MessageProcessor messageProcessor = new TcpIncomingMessageProcessor(dispatcher);
messageProcessor = new ErrorHandlingMessageProcessor(messageProcessor);
//important...the factory method parameter must "create" the gateway, threading issue otherwise.
Logger.Debug("[CommitEndpoint] Initialising Transceiver. Endpoint: {0}", config.PublishEndpoint.Endpoint);
_transceiver = new Transceiver(() => new TcpGateway(ctx, config.PublishEndpoint.Endpoint, messageProcessor), outBuffer);
}
public void should_be_able_to_write_max_commits_in_one_batch()
{
var storage = new InMemoryEventStorage();
var writer = new EventStorageWriter(3000, TimeSpan.FromMinutes(5), storage,3000);
var listOfTasks = new List<Task>();
for(var i=0;i<3000;i++)
{
listOfTasks.Add(writer.Store(new CommitForStorage("foo", "stream1",
new EventForStorage(Guid.NewGuid(), i+1, DateTime.Now, "type", null, "body"))));
}
writer.Start(_token.Token);
Task.WhenAll(listOfTasks).Wait();
Assert.That(storage.WriteCount,Is.EqualTo(1),"The commits are written in multiple batches.");
}
public void Start(ResConfiguration config)
{
Logger.Info("[ResHost] Starting...Geronimo....");
_cancellationToken = new CancellationTokenSource();
var eventStorage = getEventStorage(config.ConnectionStringName);
var storageWriter = new EventStorageWriter(config.Writer.BufferSize, config.Writer.TimeoutBeforeDrop,
eventStorage, config.Writer.BatchSize);
storageWriter.Start(_cancellationToken.Token);
var storageReader = new EventStorageReader(config.Reader.BufferSize, config.Reader.TimeoutBeforeDrop,
eventStorage, config.Reader.BatchSize);
_publishEndpoint = new PublishEndpoint(storageWriter, config);
_publishEndpoint.Start(_cancellationToken.Token);
_queryEndpoint = new QueryEndpoint(storageReader, config);
_queryEndpoint.Start(_cancellationToken.Token);
var queueStorage = getQueueStorage(config.ConnectionStringName, eventStorage);
_queueEndpoint = new QueueEndpoint(queueStorage, config);
_queueEndpoint.Start(_cancellationToken.Token);
Logger.Info("[ResHost] Started. All systems go...");
}
public void should_drop_commits_older_than_timeout()
{
var storage = new InMemoryEventStorage();
var writer = new EventStorageWriter(10, TimeSpan.FromMilliseconds(1), storage, 2);
var task1 = writer.Store(new CommitForStorage("foo", "stream1",
new EventForStorage(Guid.NewGuid(), 1, DateTime.Now, "type", null, "body")));
var task2 = writer.Store(new CommitForStorage("foo", "stream2",
new EventForStorage(Guid.NewGuid(), 1, DateTime.Now, "type", null, "body")));
Task.Delay(1).Wait();
writer.Start(_token.Token);
try
{
Task.WhenAll(task1, task2).Wait(1000);
}
catch (AggregateException e)
{
throw e.Flatten().InnerException;
}
}
public void storage_exception_should_get_sent_to_task()
{
var storage = A.Fake<EventStorage>();
A.CallTo(storage).Throws(() => new EventStorageException("Damn", null));
var writer = new EventStorageWriter(10, TimeSpan.FromMinutes(1), storage, 2);
var task1 = writer.Store(new CommitForStorage("foo", "stream1",
new EventForStorage(Guid.NewGuid(), 1, DateTime.Now, "type", null, "body")));
writer.Start(_token.Token);
try
{
task1.Wait(1000);
}
catch (AggregateException e)
{
throw e.Flatten().InnerException;
}
}
public void should_throw_if_busy()
{
var writer = new EventStorageWriter(1, TimeSpan.FromMinutes(1), new InMemoryEventStorage());
writer.Store(new CommitForStorage("foo", "stream1",
new EventForStorage(Guid.NewGuid(), 1, DateTime.Now, "type", null, "body")));
writer.Store(new CommitForStorage("foo", "stream2",
new EventForStorage(Guid.NewGuid(), 1, DateTime.Now, "type", null, "body")));
}
public void should_store_messages()
{
var storage = new InMemoryEventStorage();
var writer = new EventStorageWriter(10, TimeSpan.FromMinutes(1), storage);
writer.Start(_token.Token);
var task1 = writer.Store(new CommitForStorage("foo", "stream1",
new EventForStorage(Guid.NewGuid(), 1, DateTime.Now, "type", null, "body")));
var task2 = writer.Store(new CommitForStorage("foo", "stream2",
new EventForStorage(Guid.NewGuid(), 1, DateTime.Now, "type", null, "body")));
Task.WhenAll(task1, task2).Wait(1000);
var stream1Events = storage.LoadEvents("foo", "stream1");
var stream2Events = storage.LoadEvents("foo", "stream2");
Assert.AreEqual(1, stream1Events.Length, "stream1 should have one event.");
Assert.AreEqual(1, stream2Events.Length, "stream2 should have one event.");
}
public CommitHandler(EventStorageWriter writer, OutBuffer outBuffer)
{
_writer = writer;
_outBuffer = outBuffer;
}
