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();
}
}
public void when_wire_to_method()
{
var command = new RedirectToCommand();
var testClass = new TestClassWithMethod();
command.WireToMethod(testClass, "Method1");
command.Invoke("value1");
Assert.IsTrue(testClass.CallMethod1);
}
public void when_wire_to_lamda()
{
var command = new RedirectToCommand();
var testClass = new TestClassWithMethod();
command.WireToLambda<int>(i => { testClass.Summa += i; });
command.Invoke(4);
command.Invoke(4);
Assert.AreEqual(8, testClass.Summa);
}
public void when_wire_to_when_method()
{
var command = new RedirectToCommand();
var testClass = new TestClassWithMethod();
command.WireToWhen(testClass);
var t = new TestRedirectMethod { Id = 333, Name = "Name" };
command.Invoke(t);
Assert.AreEqual(t, testClass.RedirectMethod);
}
public void when_wire_to_method()
{
var command = new RedirectToCommand();
var testClass = new TestClassWithMethod();
command.WireToMethod(testClass, "Method1");
command.Invoke("value1");
Assert.IsTrue(testClass.CallMethod1);
}
public void when_wire_to_lamda()
{
var command = new RedirectToCommand();
var testClass = new TestClassWithMethod();
command.WireToLambda <int>(i => { testClass.Summa += i; });
command.Invoke(4);
command.Invoke(4);
Assert.AreEqual(8, testClass.Summa);
}
public void when_many_invoke()
{
var command = new RedirectToCommand();
var testClass = new TestClassWithMethod();
command.WireToMethod(testClass, "Method2");
command.InvokeMany(new List<string> { "value1", "value2", "value3" });
Assert.AreEqual(3, testClass.List.Count);
Assert.AreEqual("value1", testClass.List[0]);
Assert.AreEqual("value2", testClass.List[1]);
Assert.AreEqual("value3", testClass.List[2]);
}
public void when_wire_to_when_method()
{
var command = new RedirectToCommand();
var testClass = new TestClassWithMethod();
command.WireToWhen(testClass);
var t = new TestRedirectMethod {
Id = 333, Name = "Name"
};
command.Invoke(t);
Assert.AreEqual(t, testClass.RedirectMethod);
}
static void CallHandlers(RedirectToCommand serviceCommands, ImmutableEnvelope aem)
{
var content = aem.Message;
var watch = Stopwatch.StartNew();
serviceCommands.Invoke(content);
watch.Stop();
var seconds = watch.Elapsed.TotalSeconds;
if (seconds > 10)
{
SystemObserver.Notify("[Warn]: {0} took {1:0.0} seconds", content.GetType().Name, seconds);
}
}
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);
}
public void when_many_invoke()
{
var command = new RedirectToCommand();
var testClass = new TestClassWithMethod();
command.WireToMethod(testClass, "Method2");
command.InvokeMany(new List <string> {
"value1", "value2", "value3"
});
Assert.AreEqual(3, testClass.List.Count);
Assert.AreEqual("value1", testClass.List[0]);
Assert.AreEqual("value2", testClass.List[1]);
Assert.AreEqual("value3", testClass.List[2]);
}
CqrsEngineBuilder BootstrapHandlers(Setup setup)
{
var builder = new CqrsEngineBuilder(_streamer);
var writer = setup.Store.Container.GetWriter <unit, int>();
var handler = new RedirectToCommand();
handler.WireToLambda <AtomicMessage>(am => HandleAtomic(am, setup.Sender, writer));
handler.WireToLambda <NuclearMessage>(am => HandleNuclear(am, setup.Sender, setup.Store));
builder.Handle(setup.Inbox, envelope =>
{
foreach (var message in envelope.Items)
{
handler.Invoke(message.Content);
}
});
return(builder);
}
public void Then_transactional_support_is_provided()
{
var streamer = EnvelopeStreamer.CreateDefault(typeof(Act));
var builder = new CqrsEngineBuilder(streamer);
var setup = ComposeComponents(streamer);
var handler = new RedirectToCommand();
handler.WireToLambda <Act>(act => Consume(act, setup.Storage));
builder.Handle(setup.Inbox, envelope =>
{
using (var tx = new TransactionScope(TransactionScopeOption.RequiresNew))
{
handler.InvokeMany(envelope.Items.Select(i => i.Content));
tx.Complete();
}
});
using (var source = new CancellationTokenSource())
using (TestObserver.When <EnvelopeDispatched>(e => source.Cancel()))
using (var engine = builder.Build())
{
setup.Sender.SendBatch(new[] { new Act(), new Act(), new Act {
Fail = true
} });
setup.Sender.SendBatch(new[] { new Act(), new Act(), new Act() });
var task = engine.Start(source.Token);
// Trace.WriteLine("Started");
if (!task.Wait(Debugger.IsAttached ? int.MaxValue : TestSpeed))
{
source.Cancel();
Assert.Fail("System should be stopped by now");
}
var storage = setup.Storage;
var count = storage.GetSingletonOrNew <int>();
Assert.AreEqual(3, count, "Three acts are expected");
}
}
public void Then_transactional_support_is_provided()
{
var streamer = EnvelopeStreamer.CreateDefault(typeof(Act));
var builder = new CqrsEngineBuilder(streamer);
var setup = ComposeComponents(streamer);
var handler = new RedirectToCommand();
handler.WireToLambda<Act>(act => Consume(act, setup.Storage));
builder.Handle(setup.Inbox, envelope =>
{
using (var tx = new TransactionScope(TransactionScopeOption.RequiresNew))
{
handler.InvokeMany(envelope.Items.Select(i => i.Content));
tx.Complete();
}
});
using (var source = new CancellationTokenSource())
using (TestObserver.When<EnvelopeDispatched>(e => source.Cancel()))
using (var engine = builder.Build())
{
setup.Sender.SendBatch(new[] { new Act(), new Act(), new Act { Fail = true } });
setup.Sender.SendBatch(new[] { new Act(), new Act(), new Act() });
var task = engine.Start(source.Token);
// Trace.WriteLine("Started");
if (!task.Wait(Debugger.IsAttached ? int.MaxValue : TestSpeed))
{
source.Cancel();
Assert.Fail("System should be stopped by now");
}
var storage = setup.Storage;
var count = storage.GetSingletonOrNew<int>();
Assert.AreEqual(3, count, "Three acts are expected");
}
}
public AssembledComponents AssembleComponents()
{
// set up all the variables
var routerQueue = CreateQueueWriter(Topology.RouterQueue);
var commands = new RedirectToCommand();
var events = new RedirectToDynamicEvent();
IEventStore eventStore = null;// new LegacyTapeStreamEventStore(Tapes(Topology.TapesContainer), Streamer, routerQueue);
var simple = new SimpleMessageSender(Streamer, routerQueue);
var flow = new CommandSender(simple);
var builder = new CqrsEngineBuilder(Streamer);
// route queue infrastructure together
builder.Handle(CreateInbox(Topology.RouterQueue), Topology.Route(CreateQueueWriter, Streamer, Tapes), "router");
builder.Handle(CreateInbox(Topology.EntityQueue), em => CallHandlers(commands, em));
builder.Handle(CreateInbox(Topology.EventsQueue), aem => CallHandlers(events, aem));
// message wiring magic
DomainBoundedContext.ApplicationServices(Docs, eventStore).ForEach(commands.WireToWhen);
DomainBoundedContext.Receptors(flow).ForEach(events.WireToWhen);
DomainBoundedContext.Projections(Docs).ForEach(events.WireToWhen);
DomainBoundedContext.Tasks(flow, Docs, false).ForEach(builder.AddTask);
ClientBoundedContext.Projections(Docs).ForEach(events.WireToWhen);
return(new AssembledComponents
{
Builder = builder,
Sender = flow,
Setup = this,
Simple = simple
});
}
public Container Build()
{
var appendOnlyStore = CreateTapes(TapesContainer);
var messageStore = new MessageStore(appendOnlyStore, Streamer.MessageSerializer);
var toCommandRouter = new MessageSender(Streamer, CreateQueueWriter(RouterQueue));
var toFunctionalRecorder = new MessageSender(Streamer, CreateQueueWriter(FunctionalRecorderQueue));
var toEventHandlers = new MessageSender(Streamer, CreateQueueWriter(EventProcessingQueue));
var sender = new TypedMessageSender(toCommandRouter, toFunctionalRecorder);
var store = new EventStore(messageStore);
var quarantine = new EnvelopeQuarantine(Streamer, sender, Streaming.GetContainer(ErrorsContainer));
var builder = new CqrsEngineBuilder(Streamer, quarantine);
var events = new RedirectToDynamicEvent();
var commands = new RedirectToCommand();
var funcs = new RedirectToCommand();
builder.Handle(CreateInbox(EventProcessingQueue), aem => CallHandlers(events, aem), "watch");
builder.Handle(CreateInbox(AggregateHandlerQueue), aem => CallHandlers(commands, aem));
builder.Handle(CreateInbox(RouterQueue), MakeRouter(messageStore), "watch");
// multiple service queues
_serviceQueues.ForEach(s => builder.Handle(CreateInbox(s), aem => CallHandlers(funcs, aem)));
builder.Handle(CreateInbox(FunctionalRecorderQueue), aem => RecordFunctionalEvent(aem, messageStore));
var viewDocs = CreateDocs(ViewStrategy);
var stateDocs = new NuclearStorage(CreateDocs(DocStrategy));
var vector = new DomainIdentityGenerator(stateDocs);
//var ops = new StreamOps(Streaming);
var projections = new ProjectionsConsumingOneBoundedContext();
// Domain Bounded Context
DomainBoundedContext.EntityApplicationServices(viewDocs, store, vector).ForEach(commands.WireToWhen);
DomainBoundedContext.FuncApplicationServices().ForEach(funcs.WireToWhen);
DomainBoundedContext.Ports(sender).ForEach(events.WireToWhen);
DomainBoundedContext.Tasks(sender, viewDocs, true).ForEach(builder.AddTask);
projections.RegisterFactory(DomainBoundedContext.Projections);
// Client Bounded Context
projections.RegisterFactory(ClientBoundedContext.Projections);
// wire all projections
projections.BuildFor(viewDocs).ForEach(events.WireToWhen);
// wire in event store publisher
var publisher = new MessageStorePublisher(messageStore, toEventHandlers, stateDocs, DoWePublishThisRecord);
builder.AddTask(c => Task.Factory.StartNew(() => publisher.Run(c)));
return(new Container
{
Builder = builder,
Setup = this,
SendToCommandRouter = toCommandRouter,
MessageStore = messageStore,
ProjectionFactories = projections,
ViewDocs = viewDocs,
Publisher = publisher,
AppendOnlyStore = appendOnlyStore
});
}
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;
}
CqrsEngineBuilder BootstrapHandlers(Setup setup)
{
var builder = new CqrsEngineBuilder(_streamer);
var writer = setup.Store.Container.GetWriter<unit, int>();
var handler = new RedirectToCommand();
handler.WireToLambda<AtomicMessage>(am => HandleAtomic(am, setup.Sender, writer));
handler.WireToLambda<NuclearMessage>(am => HandleNuclear(am, setup.Sender, setup.Store));
builder.Handle(setup.Inbox, envelope =>
{
foreach (var message in envelope.Items)
{
handler.Invoke(message.Content);
}
});
return builder;
}
static void CallHandlers(RedirectToCommand serviceCommands, ImmutableEnvelope aem)
{
var content = aem.Items[0].Content;
serviceCommands.Invoke(content);
}
