public void Dulicate_message_is_detected()
{
var builder = new CqrsEngineBuilder();
builder.Memory(m =>
{
m.AddMemorySender("in", s => s.IdGenerator(() => "same"));
m.AddMemoryRouter("in", c => "memory:null");
});
var observer = new ImmediateEventsObserver();
builder.Advanced.RegisterObserver(observer);
using (var token = new CancellationTokenSource())
using (var build = builder.Build())
{
var sender = build.Resolve<IMessageSender>();
sender.SendOne(new Message());
sender.SendOne(new Message());
observer.Event += @event =>
{
var e = @event as EnvelopeDuplicateDiscarded;
if (e != null)
{
token.Cancel();
}
};
build.Start(token.Token);
token.Token.WaitHandle.WaitOne(10000);
Assert.IsTrue(token.IsCancellationRequested);
}
}
public void Dulicate_message_is_detected()
{
var streamer = EnvelopeStreamer.CreateDefault(typeof(Message));
var builder = new CqrsEngineBuilder(streamer);
var cfg = new MemoryStorageConfig();
var sender = cfg.CreateSimpleSender(streamer, "in");
builder.Handle(cfg.CreateInbox("in"), envelope => Console.WriteLine("Got message"));
var env = new EnvelopeBuilder("fixed ID").Build();
using (var token = new CancellationTokenSource())
using (var build = builder.Build())
using (TestObserver.When <EnvelopeDuplicateDiscarded>(discarded => token.Cancel()))
{
sender.SendBatch(new object[] { new Message() }, IdGeneration.HashContent);
sender.SendBatch(new object[] { new Message() }, IdGeneration.HashContent);
build.Start(token.Token);
if (Debugger.IsAttached)
{
token.Token.WaitHandle.WaitOne();
}
else
{
token.Token.WaitHandle.WaitOne(10000);
}
Assert.IsTrue(token.IsCancellationRequested);
}
}
public void Run_in_test()
{
var streamer = EnvelopeStreamer.CreateDefault(typeof(CreateCustomer), typeof(CustomerCreated));
var builder = new CqrsEngineBuilder(streamer);
var account = new MemoryAccount();
var nuclear = account.CreateNuclear();
var inbox = account.CreateInbox("input");
var sender = account.CreateSimpleSender(streamer, "input");
var handler = new MessageHandler();
handler.WireToLambda <CreateCustomer>(customer => Consume(customer, nuclear, sender));
handler.WireToLambda <CustomerCreated>(m => Console.WriteLine("Created!"));
builder.Handle(inbox, handler.HandleEnvelope);
using (var engine = builder.Build())
{
sender.SendOne(new CreateCustomer
{
CustomerId = 1,
CustomerName = "Rinat Abdullin"
});
engine.RunForever();
}
}
public void Test()
{
using (var source = new CancellationTokenSource())
{
var dev = AzureStorage.CreateConfigurationForDev();
WipeAzureAccount.Fast(s => s.StartsWith("test-"), dev);
var b = new CqrsEngineBuilder(null);
b.Dispatch(dev.CreateInbox("test-publish"), bytes =>
{
if (bytes[0] == 42)
{
source.Cancel();
}
});
using (var engine = b.Build())
{
var task = engine.Start(source.Token);
dev.CreateQueueWriter("test-publish").PutMessage(new byte[] { 42 });
if (!task.Wait(5000))
{
source.Cancel();
}
}
}
}
public void Test()
{
var streamer = EnvelopeStreamer.CreateDefault(typeof(SecondPassed));
var builder = new CqrsEngineBuilder(streamer);
var store = FileStorage.CreateConfig(GetType().Name, reset: true);
builder.Handle(store.CreateInbox("inbox"), BuildRouter(store, streamer));
builder.Handle(store.CreateInbox("process"), ie => Console.WriteLine("Message from past!"));
var inboxWriter = store.CreateQueueWriter("inbox");
var futureContainer = store.CreateStreaming().GetContainer("future");
var timer = new StreamingTimerService(inboxWriter, futureContainer, streamer);
builder.AddProcess(timer);
builder.Handle(store.CreateInbox("timer"), timer.PutMessage);
using (var engine = builder.Build())
{
var bytes = streamer.SaveEnvelopeData(new SecondPassed(), c => c.DelayBy(TimeSpan.FromSeconds(4)));
inboxWriter.PutMessage(bytes);
Console.WriteLine("Sent message to future...");
engine.RunForever();
}
}
public void Test()
{
// this test will start a simple web server on port 8082 (with a CQRS engine)
// You might need to reserve that port or run test as admin. Check out unit test
// output for the exact command line on port reservation (or MSDN docs)
//
// netsh http add urlacl url=http://+:8082/ user=RINAT-R5\Rinat.Abdullin
// after starting the test, navigate you browser to localhost:8082/index.htm
// and try dragging the image around
// in-memory structure to capture mouse movement
// statistics
var stats = new MouseStats();
// we accept a message just of this type, using a serializer
var messages = new[] { typeof(MouseMoved), typeof(MouseClick) };
var serializer = new MyJsonSerializer(messages);
var streamer = new EnvelopeStreamer(serializer);
var store = new MemoryAccount();
var atomic = store.CreateNuclear().Factory;
// let's configure our custom Http server to
// 1. serve resources
// 2. serve MouseStats View
// 3. accept commands
var environment = new HttpEnvironment {
Port = 8082
};
var builder = new CqrsEngineBuilder(streamer);
builder.AddProcess(new Listener(environment,
new EmbeddedResourceHttpRequestHandler(typeof(MouseMoved).Assembly, "Snippets.HttpEndpoint"),
new MouseStatsRequestHandler(stats),
new HeatMapRequestHandler(atomic.GetEntityReader <unit, HeatMapView>()),
new MouseEventsRequestHandler(store.CreateQueueWriter("inbox"), serializer, streamer)));
builder.Handle(store.CreateInbox("inbox"), envelope =>
{
if (envelope.Items.Any(i => i.Content is MouseMoved))
{
MouseStatHandler(envelope, stats);
}
else if (envelope.Items.Any(i => i.Content is MouseClick))
{
MouseClickHandler(envelope, atomic.GetEntityWriter <unit, PointsView>());
}
});
builder.AddProcess(new HeatMapGenerateTask(atomic.GetEntityReader <unit, PointsView>(), atomic.GetEntityWriter <unit, HeatMapView>()));
Process.Start("http://localhost:8082/index.htm");
// this is a test, so let's block everything
builder.Build().RunForever();
}
public void Test()
{
var dev = AzureStorage.CreateConfigurationForDev();
WipeAzureAccount.Fast(s => s.StartsWith("test-"), dev);
var events = new Subject <ISystemEvent>();
var b = new CqrsEngineBuilder();
b.Azure(c => c.AddAzureProcess(dev, "test-publish"));
b.Advanced.RegisterObserver(events);
var engine = b.Build();
var source = new CancellationTokenSource();
engine.Start(source.Token);
var builder = new CqrsClientBuilder();
builder.Azure(c => c.AddAzureSender(dev, "test-publish"));
var client = builder.Build();
client.Sender.SendOne(new Message());
using (engine)
using (events.OfType <EnvelopeAcked>().Subscribe(e => source.Cancel()))
{
source.Token.WaitHandle.WaitOne(5000);
source.Cancel();
}
}
public static void Azure(this CqrsEngineBuilder @this, Action <AzureEngineModule> config)
{
var module = new AzureEngineModule();
config(module);
@this.Advanced.RegisterModule(module);
}
public void Dulicate_message_is_detected()
{
var builder = new CqrsEngineBuilder();
builder.Memory(m =>
{
m.AddMemorySender("in", s => s.IdGenerator(() => "same"));
m.AddMemoryRouter("in", c => "memory:null");
});
var observer = new ImmediateEventsObserver();
builder.Advanced.RegisterObserver(observer);
using (var token = new CancellationTokenSource())
using (var build = builder.Build())
{
var sender = build.Resolve <IMessageSender>();
sender.SendOne(new Message());
sender.SendOne(new Message());
observer.Event += @event =>
{
var e = @event as EnvelopeDuplicateDiscarded;
if (e != null)
{
token.Cancel();
}
};
build.Start(token.Token);
token.Token.WaitHandle.WaitOne(10000);
Assert.IsTrue(token.IsCancellationRequested);
}
}
// ReSharper disable InconsistentNaming
static void TestConfiguration(IQueueWriter sender, CqrsEngineBuilder builder)
{
int i = 0;
using (var t = new CancellationTokenSource())
using (TestObserver.When <MessageAcked>(ea =>
{
if (ea.Context.QueueName != "do")
{
return;
}
if (i++ >= 5)
{
t.Cancel();
}
}))
using (var engine = builder.Build())
{
engine.Start(t.Token);
sender.PutMessage(new byte[1]);
if (!t.Token.WaitHandle.WaitOne(5000))
{
t.Cancel();
}
Assert.IsTrue(t.IsCancellationRequested);
}
}
public void when_create_instance()
{
var builder = new CqrsEngineBuilder(null);
Assert.AreEqual(1, builder.Processes.Count);
Assert.AreEqual(typeof(DuplicationManager), builder.Processes[0].GetType());
}
public void Run_in_test()
{
var streamer = EnvelopeStreamer.CreateDefault(typeof(CreateCustomer), typeof(CustomerCreated));
var builder = new CqrsEngineBuilder(streamer);
var account = new MemoryStorageConfig();
var nuclear = account.CreateNuclear(new TestStrategy());
var inbox = account.CreateInbox("input");
var sender = account.CreateSimpleSender(streamer, "input");
var handler = new RedirectToCommand();
handler.WireToLambda <CreateCustomer>(customer => Consume(customer, nuclear, sender));
handler.WireToLambda <CustomerCreated>(m => Console.WriteLine("Created!"));
builder.Handle(inbox, envelope => handler.InvokeMany(envelope.SelectContents()));
using (var engine = builder.Build())
{
sender.SendOne(new CreateCustomer
{
CustomerId = 1,
CustomerName = "Rinat Abdullin"
});
engine.RunForever();
}
}
static void TestConfiguration(Action <CqrsEngineBuilder> build, int useMessages)
{
var builder = new CqrsEngineBuilder();
build(builder);
var subj = new Subject <ISystemEvent>();
builder.Advanced.Observers.Clear();
builder.Advanced.RegisterObserver(subj);
var step = (useMessages / 5);
int count = 0;
var watch = new Stopwatch();
using (var token = new CancellationTokenSource())
{
subj
.OfType <EnvelopeAcked>()
.Subscribe(ea =>
{
count += 1;
if ((count % step) == 0)
{
var messagesPerSecond = count / watch.Elapsed.TotalSeconds;
Console.WriteLine("{0} - {1}", count, Math.Round(messagesPerSecond, 1));
}
if (ea.Attributes.Any(ia => ia.Key == "last"))
{
token.Cancel();
}
});
using (var engine = builder.Build())
{
// first we send X then we check
var sender = engine.Resolve <IMessageSender>();
for (int i = 0; i < useMessages; i++)
{
sender.SendOne(new UsualMessage {
HasData = true
});
}
sender.SendOne(new UsualMessage {
HasData = true
}, b => b.AddString("last"));
watch.Start();
engine.Start(token.Token);
token.Token.WaitHandle.WaitOne(10000);
}
}
}
// ReSharper disable InconsistentNaming
protected override void CurrentConfig(CqrsEngineBuilder config)
{
config.Memory(m =>
{
m.AddMemoryProcess("do", x => x.DispatchAsCommandBatch());
m.AddMemorySender("do", cb => cb.IdGeneratorForTests());
});
}
protected override void EngineConfig(CqrsEngineBuilder config)
{
config.Memory(m =>
{
m.AddMemoryProcess("do");
m.AddMemorySender("do", cb => cb.IdGeneratorForTests());
});
}
public void Test()
{
var types = Assembly.GetExecutingAssembly().GetExportedTypes()
.Where(t => typeof(IPS_SampleMessage).IsAssignableFrom(t));
var streamer = EnvelopeStreamer.CreateDefault(types);
var builder = new CqrsEngineBuilder(streamer);
// only message contracts within this class
// configure in memory:
// -> sub 1
// inbox -> [PubSubRouter] <
// -> sub 2
//
var store = new MemoryAccount();
var nuclear = store.CreateNuclear();
var router = new PubSubRouter(nuclear, store.CreateWriteQueueFactory(), streamer);
router.Init();
builder.Dispatch(store.CreateInbox("sub1"), b => Console.WriteLine("sub1 hit"));
builder.Dispatch(store.CreateInbox("sub2"), b => Console.WriteLine("sub2 hit"));
builder.Handle(store.CreateInbox("inbox"), router.DispatchMessage);
var sender = store.CreateSimpleSender(streamer, "inbox");
using (var engine = builder.Build())
using (var cts = new CancellationTokenSource())
{
var task = engine.Start(cts.Token);
// no handler should get these.
sender.SendOne(new SomethingHappened());
sender.SendOne(new OtherHappened());
// subscribe sub1 to all messages and sub2 to specific message
sender.SendControl(eb =>
{
eb.AddString("router-subscribe:sub1", ".*");
eb.AddString("router-subscribe:sub2", "SomethingHappened");
});
sender.SendOne(new SomethingHappened());
sender.SendOne(new OtherHappened());
// unsubscribe all
sender.SendControl(eb =>
{
eb.AddString("router-unsubscribe:sub1", ".*");
eb.AddString("router-unsubscribe:sub2", "SomethingHappened");
});
sender.SendOne(new SomethingHappened());
sender.SendOne(new OtherHappened());
task.Wait(5000);
}
}
public AssembledComponents AssembleComponents()
{
var documents = CreateNuclear(new DocumentStrategy());
var streamer = Streamer;
var tapes = Tapes;
var streaming = Streaming;
var routerQueue = CreateQueueWriter(Topology.RouterQueue);
var aggregates = new AggregateFactory(tapes, streamer, routerQueue);
var sender = new SimpleMessageSender(streamer, routerQueue);
var flow = new MessageSender(sender);
var builder = new CqrsEngineBuilder(streamer);
var log = tapes.GetOrCreateStream(Topology.DomainLogName);
var dispatcher = new SimpleDispatcher(aggregates, streamer, log);
builder.Handle(CreateInbox(Topology.RouterQueue),
Topology.Route(CreateQueueWriter, streamer, tapes), "router");
builder.Handle(CreateInbox(Topology.EntityQueue), aggregates.Dispatch);
var functions = new RedirectToDynamicEvent();
// documents
//functions.WireToWhen(new RegistrationUniquenessProjection(atomic.Factory.GetEntityWriter<unit, RegistrationUniquenessDocument>()));
// UI projections
var projectionStore = CreateNuclear(new ProjectionStrategy());
foreach (var projection in BootstrapProjections.BuildProjectionsWithWhenConvention(projectionStore.Factory))
{
functions.WireToWhen(projection);
}
// processes
//functions.WireToWhen(new Domain.RecipeProcess(flow));
builder.Handle(CreateInbox(Topology.EventsQueue), aem => CallHandlers(functions, aem));
var timer = new StreamingTimerService(CreateQueueWriter(Topology.RouterQueue),
streaming.GetContainer(Topology.FutureMessagesContainer), streamer);
builder.Handle(CreateInbox(Topology.TimerQueue), timer.PutMessage);
builder.AddProcess(timer);
// GNS: just for this simple sample. In reality one would have some command handlers involved
Bus.SetBus(new SimpleBus(sender, dispatcher));
return(new AssembledComponents
{
Builder = builder,
Sender = sender,
Dispatcher = dispatcher,
ProjectionFactory = projectionStore.Factory,
Setup = this
});
}
CqrsEngineBuilder BootstrapHandlers(Setup setup)
{
var builder = new CqrsEngineBuilder(_streamer);
var handler = new CommandHandler();
handler.WireToLambda <FailingMessage>(am => SmartFailing(am, setup.Store));
builder.Handle(setup.Inbox, handler.HandleAll);
return(builder);
}
public void when_handle()
{
var builder = new CqrsEngineBuilder(null);
builder.Dispatch(new TestQueueReader(), (b) => { });
Assert.AreEqual(2, builder.Processes.Count);
Assert.AreEqual(typeof(DispatcherProcess), builder.Processes[1].GetType());
}
public void when_add_factory_to_start_process()
{
var builder = new CqrsEngineBuilder(null);
builder.AddTask(x => new Task(() => { }, x));
Assert.AreEqual(2, builder.Processes.Count);
Assert.AreEqual(typeof(TaskProcess), builder.Processes[1].GetType());
}
public static CqrsEngineBuilder ConfigureJonathanOliverEventStore(this CqrsEngineBuilder builder,
Action <EventStoreModule> config)
{
var module = new EventStoreModule();
config(module);
builder.Advanced.RegisterModule(module);
return(builder);
}
protected override void Configure(CqrsEngineBuilder b)
{
b.Memory(m =>
{
m.AddMemoryProcess("in");
m.AddMemorySender("in");
});
EnlistMessage(new Do());
}
protected override void EngineConfig(CqrsEngineBuilder b)
{
b.Storage(m => m.AtomicIsInFiles(_path, DefaultWithCustomConfig));
b.Memory(m =>
{
m.AddMemoryProcess("azure-dev");
m.AddMemorySender("azure-dev", x => x.IdGeneratorForTests());
});
}
private static CqrsEngineBuilder GetBuilder()
{
var builder = new CqrsEngineBuilder();
//NOTE: Core Lokad CQRS Initialization
builder.UseProtoBufSerialization();
builder.Domain(config =>
{
config.InAssemblyOf<CreateMessage>();
config.InAssemblyOf<CreateMessageHandler>();
config.ContextFactory(MyMessageContext.Factory);
});
builder.Memory(config =>
{
config.AddMemoryProcess(Queues.MESSAGES, d=>{});
config.AddMemorySender(Queues.MESSAGES);
});
builder.Storage(config =>
{
var folder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "storage");
if (!Directory.Exists(folder))
Directory.CreateDirectory(folder);
config.AtomicIsInFiles(folder, s =>
{
s.NameForSingleton(type => DefaultAtomicStorageStrategyBuilder.CleanName(type.Name) + ".json");
s.NameForEntity((type, key) => (DefaultAtomicStorageStrategyBuilder.CleanName(type.Name) + "-" + Convert.ToString(key, CultureInfo.InvariantCulture).ToLowerInvariant()) + ".json");
s.WithAssemblyOf<MessageView>();
s.CustomStaticSerializer(new AtomicStorageSerializerWithJson());
});
config.StreamingIsInFiles(folder);
});
//NOTE: Event Store Initialization
builder.ConfigureJonathanOliverEventStore(config =>
{
const string CONNECTION_STRING = @"Data Source=.\sqlexpress;Initial Catalog=lokad-cqrs-eventstore;Integrated Security=True";
config.ConnectionString(CONNECTION_STRING);
config.Hooks(p => p.Add<MyNullPipelineHook>());
config.Snapshots(s =>
{
s.Enable();
s.AggregateTypeResolver(typeName => Type.GetType(typeName + ",Domain"));
s.CheckEvery(TimeSpan.FromSeconds(30));
//set this to something reasonable like 250.
//It's so low here to demonstrate background "out-of-band" snapshotting.
s.MaxThreshold(5);
});
});
return builder;
}
public void when_add_process()
{
var builder = new CqrsEngineBuilder(null);
var testEngineProcess = new TestEngineProcess();
builder.AddTask(testEngineProcess);
Assert.AreEqual(2, builder.Processes.Count);
Assert.AreEqual(testEngineProcess, builder.Processes[1]);
}
public void Direct()
{
var config = new MemoryStorageConfig();
var raw = new CqrsEngineBuilder(EnvelopeStreamer.CreateDefault());
var doWriter = config.CreateQueueWriter("do");
// forwarder do => do
raw.Dispatch(config.CreateInbox("do"), doWriter.PutMessage);
TestConfiguration(doWriter, raw);
}
public void when_build()
{
var builder = new CqrsEngineBuilder(null);
var testEngineProcess = new TestEngineProcess();
builder.AddTask(testEngineProcess);
builder.Build(new CancellationToken());
Assert.IsTrue(testEngineProcess.IsInitialized);
}
CqrsEngineBuilder BootstrapHandlers(Setup setup)
{
var builder = new CqrsEngineBuilder(_streamer);
var writer = setup.Store.Factory.GetEntityWriter <unit, int>();
var handler = new CommandHandler();
handler.WireToLambda <AtomicMessage>(am => HandleAtomic(am, setup.Sender, writer));
handler.WireToLambda <NuclearMessage>(am => HandleNuclear(am, setup.Sender, setup.Store));
builder.Handle(setup.Inbox, handler.HandleAll);
return(builder);
}
protected override void EngineConfig(CqrsEngineBuilder b)
{
var account = AzureStorage.CreateConfigurationForDev();
WipeAzureAccount.Fast(s => s.StartsWith("test-"), account);
b.Azure(m =>
{
m.AddAzureProcess(account, new[] {"test-incoming"}, c => c.QueueVisibility(1));
m.AddAzureSender(account, "test-incoming", x => x.IdGeneratorForTests());
});
b.Storage(m => m.AtomicIsInAzure(account, DefaultWithCustomConfig));
}
protected override void EngineConfig(CqrsEngineBuilder b)
{
var account = AzureStorage.CreateConfigurationForDev();
WipeAzureAccount.Fast(s => s.StartsWith("test-"), account);
b.Azure(m =>
{
m.AddAzureProcess(account, new[] { "test-incoming" }, c => c.QueueVisibility(1));
m.AddAzureSender(account, "test-incoming", x => x.IdGeneratorForTests());
});
b.Storage(m => m.AtomicIsInAzure(account, DefaultWithCustomConfig));
}
protected override void Configure(CqrsEngineBuilder b)
{
HandlerFailuresAreExpected = true;
Enlist((observable, sender, arg3) => observable
.OfType <EnvelopeQuarantined>()
.Subscribe(eq =>
{
Assert.AreEqual("Fail: try", eq.LastException.Message);
arg3.Cancel();
}));
EnlistMessage(new Message());
}
protected override CqrsEngineHost BuildHost()
{
var builder = new CqrsEngineBuilder();
//NOTE: Core Lokad CQRS Initialization
builder.UseProtoBufSerialization();
builder.Domain(config =>
{
config.InAssemblyOf<CreateMessage>();
config.InAssemblyOf<CreateMessageHandler>();
config.ContextFactory(MyMessageContext.Factory);
});
var storageConfig = CreateCloudStorageConfig();
builder.Azure(config =>
{
config.AddAzureProcess(storageConfig, Queues.MESSAGES);
config.AddAzureSender(storageConfig, Queues.MESSAGES);
});
builder.Storage(config => config.AtomicIsInAzure(storageConfig, s =>
{
s.WithAssemblyOf<MessageView>();
s.CustomStaticSerializer(new AtomicStorageSerializerWithProtoBuf());
}));
//NOTE: Event Store Initialization
builder.ConfigureJonathanOliverEventStore(config =>
{
var connectionString = AzureSettingsProvider.GetString("EventStoreConnectionString");
config.ConnectionString(connectionString);
config.Hooks(p => p.Add<MyNullPipelineHook>());
config.Snapshots(s =>
{
//snapshotting isn't implemented correctly right now.
s.Disable();
s.CheckEvery(TimeSpan.FromSeconds(30));
//set this to something reasonable like 250.
//It's so low here to demonstrate background "out-of-band" snapshotting.
s.MaxThreshold(2);
});
});
return builder.Build();
}
protected override void CurrentConfig(CqrsEngineBuilder b)
{
var dev = AzureStorage.CreateConfigurationForDev();
WipeAzureAccount.Fast(s => s.StartsWith("test-"), dev);
b.Azure(m =>
{
m.AddAzureProcess(dev, new[] { "test-incoming" }, c =>
{
c.QueueVisibility(1);
c.DispatchAsCommandBatch();
});
m.AddAzureSender(dev, "test-incoming", x => x.IdGeneratorForTests());
});
}
CqrsEngineBuilder BootstrapHandlers(Setup setup)
{
var builder = new CqrsEngineBuilder(_streamer);
var handler = new RedirectToCommand();
handler.WireToLambda <FailingMessage>(am => SmartFailing(am, setup.Store));
builder.Handle(setup.Inbox, envelope =>
{
foreach (var message in envelope.Items)
{
handler.Invoke(message.Content);
}
});
return(builder);
}
private static void StartProgram(CqrsEngineBuilder builder)
{
builder.Advanced.RegisterObserver(new LogFileObserver());
builder.Advanced.ConfigureContainer(b => b.RegisterType<Program>()
.WithParameter(TypedParameter.From(tokenSource)));
var engine = builder.Build();
engine.Start(tokenSource.Token);
engine.Resolve<Program>().Run();
}
