/// <summary>
/// Creates memory-based tape storage factory, using the provided concurrent dictionary.
/// </summary>
/// <param name="dictionary">The dictionary.</param>
/// <returns></returns>
public static MemoryTapeStorageFactory CreateTape(this MemoryAccount account, string container = "tapes")
{
var factory = new MemoryTapeStorageFactory(account.Tapes, container);
factory.InitializeForWriting();
return(factory);
}
/// <summary>
/// Creates the simplified nuclear storage wrapper around Atomic storage.
/// </summary>
/// <param name="dictionary">The dictionary.</param>
/// <param name="strategy">The atomic storage strategy.</param>
/// <returns></returns>
public static NuclearStorage CreateNuclear(this MemoryAccount dictionary, IAtomicStorageStrategy strategy)
{
var factory = new MemoryAtomicStorageFactory(dictionary.Data, strategy);
factory.Initialize();
return(new NuclearStorage(factory));
}
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 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 static MemoryPartitionInbox CreateInbox(this MemoryAccount account, params string[] queueNames)
{
var queues = queueNames
.Select(n => account.Queues.GetOrAdd(n, s => new BlockingCollection <byte[]>()))
.ToArray();
return(new MemoryPartitionInbox(queues, queueNames));
}
public void Direct()
{
var config = new MemoryAccount();
var raw = new RawEngineBuilder();
var doWriter = config.CreateQueueWriter("do");
// forwarder do => do
raw.Dispatch(config.CreateInbox("do"), doWriter.PutMessage);
TestConfiguration(doWriter, raw);
}
public void Direct()
{
var config = new MemoryAccount();
var raw = new RawEngineBuilder();
var doWriter = config.CreateQueueWriter("do");
// forwarder do => do
raw.Dispatch(config.CreateInbox("do"), doWriter.PutMessage);
TestConfiguration(doWriter, raw);
}
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);
}
}
/// <summary>
/// Creates the simplified nuclear storage wrapper around Atomic storage.
/// </summary>
/// <param name="dictionary">The dictionary.</param>
/// <param name="configStrategy">The config strategy.</param>
/// <returns></returns>
public static NuclearStorage CreateNuclear(this MemoryAccount dictionary,
Action <DefaultAtomicStorageStrategyBuilder> configStrategy)
{
var strategyBuilder = new DefaultAtomicStorageStrategyBuilder();
configStrategy(strategyBuilder);
var strategy = strategyBuilder.Build();
return(CreateNuclear(dictionary, strategy));
}
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 PartitionWithRouter()
{
var config = new MemoryAccount();
var raw = new RawEngineBuilder();
var inWriter = config.CreateQueueWriter("in");
var doWriter = config.CreateQueueWriter("do");
// forwarder in => do
raw.Dispatch(config.CreateInbox("in"), doWriter.PutMessage);
// forwarder do => in
raw.Dispatch(config.CreateInbox("do"), inWriter.PutMessage);
TestConfiguration(inWriter, raw);
}
public void PartitionWithRouter()
{
var config = new MemoryAccount();
var raw = new RawEngineBuilder();
var inWriter = config.CreateQueueWriter("in");
var doWriter = config.CreateQueueWriter("do");
// forwarder in => do
raw.Dispatch(config.CreateInbox("in"), doWriter.PutMessage);
// forwarder do => in
raw.Dispatch(config.CreateInbox("do"), inWriter.PutMessage);
TestConfiguration(inWriter, raw);
}
public void RouterChain()
{
var config = new MemoryAccount();
var raw = new RawEngineBuilder();
var doWriter = config.CreateQueueWriter("do");
var route1 = config.CreateQueueWriter("route1");
var route2 = config.CreateQueueWriter("route2");
// in => (route1 OR route2)
raw.Dispatch(config.CreateInbox("in"), bytes => LoadBalance(bytes, route1, route2));
// forwarder (route1,route2) => do
raw.Dispatch(config.CreateInbox("route1", "route2"), doWriter.PutMessage);
raw.Dispatch(config.CreateInbox("do"), bytes => LoadBalance(bytes, route1, route2));
TestConfiguration(config.CreateQueueWriter("in"), raw);
}
public void RouterChain()
{
var config = new MemoryAccount();
var raw = new RawEngineBuilder();
var doWriter = config.CreateQueueWriter("do");
var route1 = config.CreateQueueWriter("route1");
var route2 = config.CreateQueueWriter("route2");
// in => (route1 OR route2)
raw.Dispatch(config.CreateInbox("in"), bytes => LoadBalance(bytes, route1, route2));
// forwarder (route1,route2) => do
raw.Dispatch(config.CreateInbox("route1", "route2"), doWriter.PutMessage);
raw.Dispatch(config.CreateInbox("do"), bytes => LoadBalance(bytes, route1, route2));
TestConfiguration(config.CreateQueueWriter("in"), raw);
}
public void Memory_lambda()
{
var config = new MemoryAccount();
var writer = config.CreateQueueWriter("test");
var inbox = config.CreateInbox("test");
var builder = new RawEngineBuilder();
builder.Dispatch(inbox, bytes => { });
var setup = new Setup
{
Send = i => writer.PutMessage(new[] {i}),
Engine = builder.Build()
};
TestConfiguration(setup, 1000000);
}
public void Memory_lambda()
{
var config = new MemoryAccount();
var writer = config.CreateQueueWriter("test");
var inbox = config.CreateInbox("test");
var builder = new RawEngineBuilder();
builder.Dispatch(inbox, bytes => { });
var setup = new Setup
{
Send = i => writer.PutMessage(new[] { i }),
Engine = builder.Build()
};
TestConfiguration(setup, 1000000);
}
public static SimpleMessageSender CreateSimpleSender(this MemoryAccount account, IEnvelopeStreamer streamer, string queueName, Func <string> idGenerator = null)
{
var queueWriter = new[] { CreateQueueWriter(account, queueName) };
return(new SimpleMessageSender(streamer, queueWriter, idGenerator));
}
/// <summary>
/// Creates the simplified nuclear storage wrapper around Atomic storage, using the default
/// storage configuration and atomic strategy.
/// </summary>
/// <param name="dictionary">The dictionary.</param>
/// <returns>
/// new instance of the nuclear storage
/// </returns>
public static NuclearStorage CreateNuclear(this MemoryAccount dictionary)
{
return(CreateNuclear(dictionary, b => { }));
}
public static MemoryQueueWriterFactory CreateWriteQueueFactory(this MemoryAccount account)
{
return(new MemoryQueueWriterFactory(account));
}
public static IQueueWriter CreateQueueWriter(this MemoryAccount account, string queueName)
{
var collection = account.Queues.GetOrAdd(queueName, s => new BlockingCollection <byte[]>());
return(new MemoryQueueWriter(collection, queueName));
}
