public static CqrsEngineBuilder Configure()
{
var builder = new CqrsEngineBuilder();
builder.UseProtoBufSerialization();
builder.Domain(d => d.HandlerSample<IConsume<IMessage>>(m => m.Consume(null)));
var connection = AzureSettingsProvider.GetString("DiagnosticsConnectionString");
var storageConfig = AzureStorage.CreateConfig(CloudStorageAccount.Parse(connection), c =>
{
c.ConfigureBlobClient(x => x.ReadAheadInBytes = 0x200000L);
c.Named("dev");
});
builder.Azure(m =>
{
m.AddAzureSender(storageConfig, "sample-02");
m.AddAzureProcess(storageConfig, "sample-02", x =>
{
x.DirectoryFilter(f => f.WhereMessagesAre<IMessage>());
x.DispatchAsEvents();
});
});
builder.Advanced.ConfigureContainer(WireTasks);
return builder;
}
public static CqrsEngineBuilder Configure()
{
// for more detail about this sample see:
// http://code.google.com/p/lokad-cqrs/wiki/GuidanceSeries
var builder = new CqrsEngineBuilder();
builder.UseProtoBufSerialization();
builder.Domain(d => d.HandlerSample<IConsume<IMessage>>(m => m.Consume(null)));
var connection = AzureSettingsProvider.GetString("StorageConnectionString");
var storageConfig = AzureStorage.CreateConfig(CloudStorageAccount.Parse(connection), c =>
{
c.ConfigureBlobClient(x => x.ReadAheadInBytes = 0x200000L);
c.Named("dev");
});
builder.Azure(m =>
{
m.AddAzureSender(storageConfig, "sample - 01");
m.AddAzureProcess(storageConfig, "sample-01", x =>
{
x.DirectoryFilter(f => f.WhereMessagesAre<IMessage>());
x.DispatchAsCommandBatch();
});
});
return builder;
}
// 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 b)
{
b.Storage(m => m.AtomicIsInFiles(_path, DefaultWithCustomConfig));
b.Memory(m =>
{
m.AddMemoryProcess("azure-dev");
m.AddMemorySender("azure-dev", x => x.IdGeneratorForTests());
});
}
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());
});
}
private static CqrsEngineHost ConfigureHost()
{
var builder = new CqrsEngineBuilder();
builder.Domain(d =>
{
d.InAssemblyOf<CreateInventoryItem>();
d.HandlerSample<IConsume<Define.Command>>(m => m.Consume(null));
});
builder.File(f =>
{
f.AddFileSender(storageConfig, "events");
f.AddFileProcess(storageConfig, "commands", p =>
{
p.WhereFilter(x => x.WhereMessagesAre<Define.Command>());
p.DispatchAsCommandBatch();
});
f.AddFileProcess(storageConfig, "events", p=>
{
p.WhereFilter(x => x.WhereMessagesAre<DomainEvent>());
p.DispatchAsEvents();
});
});
builder.Storage(s =>
{
s.TapeIsInFiles(Path.Combine(storageConfig.Folder.FullName, "eventstore"));
s.AtomicIsInFiles(storageConfig.Folder.FullName, b =>
{
b.WhereEntityIs<IEntity>();
b.WhereSingletonIs<ISingleton>();
});
s.StreamingIsInFiles(storageConfig.Folder.FullName);
});
builder.Advanced.ConfigureContainer(c =>
{
c.RegisterType<ReadModelFacade>().As<IReadModelFacade>();
c.RegisterType<Repository<InventoryItem>>().As<IRepository<InventoryItem>>();
c.RegisterType<EventStore>().As<IEventStore>();
});
return builder.Build();
}
public void Test()
{
var builder = new CqrsEngineBuilder();
builder.Domain(m =>
{
m.HandlerSample<Definitions.Define.Consumer<Definitions.Define.ICommand>>(c => c.Consume(null));
m.ContextFactory((e,x) => new Definitions.Define.MyContext(e.GetAttribute("EntityId","")));
});
builder.Storage(m => m.AtomicIsInMemory());
builder.Memory(m =>
{
m.AddMemorySender("in", c => c.IdGeneratorForTests());
m.AddMemoryProcess("in");
});
builder.Advanced.ConfigureContainer(cb =>
{
cb.Register(c => new InMemoryEventStreamer<IAccountEvent>(c.Resolve<IMessageSender>())).
SingleInstance();
cb.RegisterType<InMemoryEventStreamer<IAccountEvent>>().SingleInstance();
cb.RegisterType<AccountAggregateRepository>().SingleInstance();
});
using (var source = new CancellationTokenSource())
using (var engine = builder.Build())
{
engine.Start(source.Token);
var sender = engine.Resolve<IMessageSender>();
sender.SendOne(new CreateAccount("Sample User"), cb => cb.AddString("EntityId","1"));
sender.SendOne(new AddLogin("login","pass"), cb => cb.AddString("EntityId", "1"));
source.Token.WaitHandle.WaitOne(5000);
source.Cancel();
}
}
public static CqrsEngineBuilder Configure()
{
var builder = new CqrsEngineBuilder();
builder.Domain(d => d.HandlerSample<IConsume<IMessage>>(m => m.Consume(null)));
var connection = AzureSettingsProvider.GetString("DiagnosticsConnectionString");
var storageConfig = AzureStorage.CreateConfig(CloudStorageAccount.Parse(connection), c =>
{
c.ConfigureBlobClient(x => x.ReadAheadInBytes = 0x200000L);
c.Named("dev");
});
builder.Azure(m =>
{
m.AddAzureSender(storageConfig, "sample-03");
m.AddAzureProcess(storageConfig, "sample-03", x =>
{
x.DirectoryFilter(f => f.WhereMessagesAre<IMessage>());
x.DispatchAsCommandBatch();
});
});
builder.Advanced.ConfigureContainer(cb =>
{
var config = ConfigureNHibernate.Build("MyDbFile");
cb.RegisterModule(new NHibernateModule(config));
WireTasks(cb);
});
return builder;
}
public static CqrsEngineBuilder Configure(string localStorage, string storageConnectionString)
{
var dev = AzureStorage.CreateConfig(storageConnectionString,
c => c.ConfigureBlobClient(x => x.ReadAheadInBytes = 0x200000L));
var builder = new CqrsEngineBuilder();
JsonSerialization.SetForMessages(builder);
builder.MessagesWithHandlersFromAutofac(d =>
{
d.HandlerSample<IHandle<Define.Command>>(m => m.Handle(null));
d.InAssemblyOf<RunTaskCommand>();
});
builder.Azure(m =>
{
m.AddAzureSender(dev, IdFor.CommandsQueue);
m.AddAzureProcess(dev, IdFor.CommandsQueue, x =>
{
x.DispatchAsCommandBatch(f => f.WhereMessagesAre<Define.Command>());
x.Quarantine(c => new Quarantine(c.Resolve<IStreamingRoot>()));
x.DecayPolicy(TimeSpan.FromSeconds(0.75));
});
m.AddAzureSender(dev, IdFor.EventsQueue);
m.AddAzureProcess(dev, IdFor.EventsQueue, x =>
{
x.DispatchAsEvents(f => f.WhereMessagesAre<Define.Event>());
x.Quarantine(c => new Quarantine(c.Resolve<IStreamingRoot>()));
x.DecayPolicy(TimeSpan.FromSeconds(0.75));
});
});
builder.Storage(m =>
{
m.AtomicIsInAzure(dev, x =>
{
x.FolderForEntity(t => "template-view-" + t.Name.ToLowerInvariant());
x.NameForEntity((t, o) => o.ToString().ToLowerInvariant() + ".json");
x.FolderForSingleton("template-singleton");
x.NameForSingleton(t => t.Name.ToLowerInvariant() + ".json");
JsonSerialization.SetForStorage(x);
});
m.StreamingIsInAzure(dev);
});
builder.Advanced.RegisterQueueWriterFactory(c => new AzureQueueWriterFactory(dev, c.Resolve<IEnvelopeStreamer>()));
builder.Advanced.ConfigureContainer(cb =>
{
var queueWriterRegistry = cb.Resolve<QueueWriterRegistry>();
var factory = queueWriterRegistry.GetOrThrow(dev.AccountName);
var client = new BusClient(factory.GetWriteQueue(IdFor.CommandsQueue), factory.GetWriteQueue(IdFor.EventsQueue));
cb.Register<IBusClient>(client);
var local = new FileStreamingContainer(localStorage);
var remote = new BlobStreamingRoot(dev.CreateBlobClient());
cb.Register(new StorageProvider(local, remote));
cb.Register<IStreamingRoot>(remote);
builder.Setup.AddProcess(new ScanTaskBlob(client, remote));
});
return builder;
}
protected abstract void EngineConfig(CqrsEngineBuilder b);
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);
}
}
}
protected abstract void CurrentConfig(CqrsEngineBuilder config);
public static void SetForMessages(CqrsEngineBuilder builder)
{
builder.Advanced.CustomDataSerializer(t => new JsonDataSerializer(t));
}
