public AggregateDispatcher(ITapeStorageFactory factory, IEnvelopeStreamer streamer, string path, QueueWriterRegistry queue)
{
_factory = factory;
_streamer = streamer;
_path = path;
_queue = queue;
}
public StatelessAzureQueueWriter(IEnvelopeStreamer streamer, CloudBlobContainer container, CloudQueue queue, string name)
{
_streamer = streamer;
_cloudBlob = container;
_queue = queue;
Name = name;
}
public StreamingTimerService(IQueueWriter target, IStreamingContainer storage, IEnvelopeStreamer streamer)
{
_target = target;
_storage = storage;
_streamer = streamer;
_suffix = Guid.NewGuid().ToString().Substring(0, 4);
}
public AzureQueueWriterFactory(
IAzureStorageConfig accounts,
IEnvelopeStreamer streamer)
{
_config = accounts;
_streamer = streamer;
}
public EnvelopeQuarantine(IEnvelopeStreamer streamer,
TypedMessageSender writer, IStreamContainer root)
{
_streamer = streamer;
_writer = writer;
_root = root;
_root.Create();
}
public StatelessFileQueueReader(IEnvelopeStreamer streamer, ISystemObserver observer, Lazy<DirectoryInfo> posionQueue, DirectoryInfo queue, string queueName)
{
_streamer = streamer;
_observer = observer;
_posionQueue = posionQueue;
_queue = queue;
_queueName = queueName;
}
public EnvelopeDispatcher(Action<ImmutableEnvelope> action, IEnvelopeStreamer streamer, IEnvelopeQuarantine quarantine, MessageDuplicationManager manager, string dispatcherName)
{
_action = action;
_quarantine = quarantine;
_dispatcherName = dispatcherName;
_manager = manager.GetOrAdd(this);
_streamer = streamer;
}
public SimpleMessageSender(IEnvelopeStreamer streamer, IQueueWriter[] queues, Func<string> idGenerator = null)
{
_queues = queues;
_idGenerator = idGenerator ?? (() =>Guid.NewGuid().ToString());
_streamer = streamer;
if (queues.Length == 0)
throw new InvalidOperationException("There should be at least one queue");
}
protected override Setup ComposeComponents(IEnvelopeStreamer streamer)
{
return new Setup
{
Inbox = _config.CreateInbox("in"),
Sender = _config.CreateSimpleSender(streamer, "in"),
Storage = _config.CreateNuclear(new TestStrategy())
};
}
public CqrsEngineBuilder(IEnvelopeStreamer streamer, IEnvelopeQuarantine quarantine = null, DuplicationManager duplication = null)
{
Processes = new List<IEngineProcess>();
Streamer = streamer;
Quarantine = quarantine ?? new MemoryQuarantine();
Duplication = duplication ?? new DuplicationManager();
Processes.Add(Duplication);
}
static Action<ImmutableEnvelope> BuildRouter(FileStorageConfig storage, IEnvelopeStreamer streamer)
{
return envelope =>
{
var target = (envelope.DeliverOnUtc < DateTime.UtcNow ? "process" : "timer");
Console.WriteLine("Routed to " + target);
storage.CreateQueueWriter(target).PutMessage(streamer.SaveEnvelopeData(envelope));
};
}
public static Action<ImmutableEnvelope> Route(Func<string, IQueueWriter> factory, IEnvelopeStreamer serializer,
ITapeStorageFactory tapes)
{
var events = factory(EventsQueue);
var timerQueue = factory(TimerQueue);
var entityQueue = factory(EntityQueue);
var services = factory(ServiceQueue);
var log = tapes.GetOrCreateStream(DomainLogName);
return envelope =>
{
var data = serializer.SaveEnvelopeData(envelope);
if (!log.TryAppend(data))
throw new InvalidOperationException("Failed to record domain log");
if (envelope.DeliverOnUtc > Current.UtcNow)
{
timerQueue.PutMessage(data);
return;
}
if (envelope.Items.All(i => i.Content is ICommand<IIdentity>))
{
entityQueue.PutMessage(data);
return;
}
if (envelope.Items.All(i => i.Content is IEvent<IIdentity>))
{
// we can have more than 1 entity event.
// all entity events are routed to events as separate
for (int i = 0; i < envelope.Items.Length; i++)
{
var name = envelope.EnvelopeId + "-e" + i;
var copy = EnvelopeBuilder.CloneProperties(name, envelope);
copy.AddItem(envelope.Items[i]);
events.PutMessage(serializer.SaveEnvelopeData(copy.Build()));
}
return;
}
if (envelope.Items.Length != 1)
{
throw new InvalidOperationException(
"Only entity commands or entity events can be batched");
}
var item = envelope.Items[0].Content;
if (item is IFunctionalCommand)
{
services.PutMessage(data);
return;
}
if (item is IFunctionalEvent || item is ISampleEvent)
{
events.PutMessage(data);
return;
}
throw new InvalidOperationException(string.Format("Unroutable message {0}", item));
};
}
protected override Setup ConfigureComponents(IEnvelopeStreamer config)
{
return new Setup
{
Store = _config.CreateNuclear(),
Sender = _config.CreateSimpleSender(config, "my-queue"),
Inbox = _config.CreateInbox("my-queue")
};
}
protected override Setup ConfigureComponents(IEnvelopeStreamer streamer)
{
return new Setup
{
Store = _config.CreateNuclear(new TestStrategy()),
Inbox = _config.CreateInbox("dev"),
Sender = _config.CreateSimpleSender(streamer, "dev")
};
}
protected override Setup ComposeComponents(IEnvelopeStreamer streamer)
{
var config = new MemoryAccount();
return new Setup
{
Inbox = config.CreateInbox("in"),
Sender = config.CreateSimpleSender(streamer, "in"),
Storage = config.CreateNuclear()
};
}
protected override Setup ConfigureComponents(IEnvelopeStreamer config)
{
var acc = new MemoryStorageConfig();
return new Setup
{
Store = acc.CreateNuclear(new TestStrategy()),
Inbox = acc.CreateInbox("queue"),
Sender = acc.CreateSimpleSender(config, "queue")
};
}
public SimpleMessageSender(IEnvelopeStreamer streamer, IQueueWriter[] queues, Func <string> idGenerator = null)
{
_queues = queues;
_idGenerator = idGenerator ?? (() => Guid.NewGuid().ToString());
_streamer = streamer;
if (queues.Length == 0)
{
throw new InvalidOperationException("There should be at least one queue");
}
}
protected override Setup ConfigureComponents(IEnvelopeStreamer streamer)
{
var _config = new MemoryAccount();
return new Setup
{
Store = _config.CreateNuclear(),
Inbox = _config.CreateInbox("dev"),
Sender = _config.CreateSimpleSender(streamer, "dev")
};
}
protected override Setup ComposeComponents(IEnvelopeStreamer streamer)
{
var config = new MemoryStorageConfig();
return(new Setup
{
Inbox = config.CreateInbox("in"),
Sender = config.CreateSimpleSender(streamer, "in"),
Storage = config.CreateNuclear(new TestStrategy())
});
}
protected override Setup ConfigureComponents(IEnvelopeStreamer streamer)
{
var _config = new MemoryStorageConfig();
return(new Setup
{
Store = _config.CreateNuclear(new TestStrategy()),
Inbox = _config.CreateInbox("dev"),
Sender = _config.CreateSimpleSender(streamer, "dev")
});
}
public static byte[] SaveEnvelopeData(this IEnvelopeStreamer streamer, object message,
Action <EnvelopeBuilder> build = null)
{
var builder = new EnvelopeBuilder(Guid.NewGuid().ToString());
builder.AddItem(message);
if (null != build)
{
build(builder);
}
return(streamer.SaveEnvelopeData(builder.Build()));
}
protected override Setup ConfigureComponents(IEnvelopeStreamer streamer)
{
TestSpeed = 7000;
var dev = AzureStorage.CreateConfigurationForDev();
WipeAzureAccount.Fast(s => s.StartsWith("test-"), dev);
return new Setup
{
Store = dev.CreateNuclear(),
Inbox = dev.CreateInbox("test-incoming", visibilityTimeout : TimeSpan.FromSeconds(1)),
Sender = dev.CreateSimpleSender(streamer, "test-incoming")
};
}
public AzurePartitionFactory(
IEnvelopeStreamer streamer,
ISystemObserver observer,
IAzureStorageConfig config,
TimeSpan queueVisibilityTimeout,
Func<uint, TimeSpan> decayPolicy)
{
_streamer = streamer;
_queueVisibilityTimeout = queueVisibilityTimeout;
_decayPolicy = decayPolicy;
_config = config;
_observer = observer;
}
public AzurePartitionFactory(
IEnvelopeStreamer streamer,
ISystemObserver observer,
IAzureStorageConfig config,
TimeSpan queueVisibilityTimeout,
Func <uint, TimeSpan> decayPolicy)
{
_streamer = streamer;
_queueVisibilityTimeout = queueVisibilityTimeout;
_decayPolicy = decayPolicy;
_config = config;
_observer = observer;
}
protected override Setup ConfigureComponents(IEnvelopeStreamer config)
{
TestSpeed = 7000;
var dev = AzureStorage.CreateConfigurationForDev();
WipeAzureAccount.Fast(s => s.StartsWith("test-"), dev);
return(new Setup
{
Store = dev.CreateNuclear(new TestStrategy()),
Inbox = dev.CreateInbox("test-incoming", visibilityTimeout: TimeSpan.FromSeconds(1)),
Sender = dev.CreateSimpleSender(config, "test-incoming")
});
}
public StatelessSqlQueueReader(
ISqlStorageConfig config,
string name,
ISystemObserver provider,
IEnvelopeStreamer streamer,
TimeSpan visibilityTimeout
)
{
_config = config;
_observer = provider;
_queueName = name;
_streamer = streamer;
_visibilityTimeout = visibilityTimeout;
}
public StatelessSqlQueueWriter(
IEnvelopeStreamer streamer,
string connectionString,
string name
)
{
_streamer = streamer;
_connectionString = connectionString;
Name = name;
using (var db = new DataContext(_connectionString))
{
_queueID = db.ExecuteQuery<int>("exec [dbo].[GetQueueID] {0}", name).Single();
}
}
protected override Given_Basic_Scenarios.Setup ConfigureComponents(IEnvelopeStreamer config)
{
// Azure dev is implemented via WS on top of SQL on top of FS.
// this can be slow. And it will be
TestSpeed = 7000;
var dev = AzureStorage.CreateConfigurationForDev();
WipeAzureAccount.Fast(s => s.StartsWith("test-"), dev);
return new Setup
{
Store = dev.CreateNuclear(new TestStrategy()),
Inbox = dev.CreateInbox("test-incoming", visibilityTimeout : TimeSpan.FromSeconds(1)),
Sender = dev.CreateSimpleSender(config, "test-incoming")
};
}
public StatelessAzureQueueReader(
string name,
CloudQueue primaryQueue,
CloudBlobContainer container,
Lazy <CloudQueue> poisonQueue,
ISystemObserver provider,
IEnvelopeStreamer streamer, TimeSpan visibilityTimeout)
{
_cloudBlob = container;
_queue = primaryQueue;
_posionQueue = poisonQueue;
_observer = provider;
_queueName = name;
_streamer = streamer;
_visibilityTimeout = visibilityTimeout;
}
protected override Given_Basic_Scenarios.Setup ConfigureComponents(IEnvelopeStreamer config)
{
// Azure dev is implemented via WS on top of SQL on top of FS.
// this can be slow. And it will be
TestSpeed = 7000;
var dev = AzureStorage.CreateConfigurationForDev();
WipeAzureAccount.Fast(s => s.StartsWith("test-"), dev);
return(new Setup
{
Store = dev.CreateNuclear(new TestStrategy()),
Inbox = dev.CreateInbox("test-incoming", visibilityTimeout: TimeSpan.FromSeconds(1)),
Sender = dev.CreateSimpleSender(config, "test-incoming")
});
}
public StatelessAzureQueueReader(
string name,
CloudQueue primaryQueue,
CloudBlobContainer container,
Lazy<CloudQueue> poisonQueue,
ISystemObserver provider,
IEnvelopeStreamer streamer, TimeSpan visibilityTimeout)
{
_cloudBlob = container;
_queue = primaryQueue;
_posionQueue = poisonQueue;
_observer = provider;
_queueName = name;
_streamer = streamer;
_visibilityTimeout = visibilityTimeout;
}
public DomainLogView(LocalEventStore eventStore, SimpleMessageSender endpoint, IEnvelopeStreamer serializer)
{
InitializeComponent();
_client = eventStore;
_services = new ShellServices(endpoint);
_serializer = serializer;
_log.BackColor = CommonColors.Solarized.Base03;
_log.ForeColor = CommonColors.Solarized.Base0;
_display.BackColor = CommonColors.Solarized.Base3;
_display.ForeColor = CommonColors.Solarized.Base00;
_detailsLabel.BackColor = CommonColors.Solarized.Base2;
_detailsLabel.ForeColor = CommonColors.Solarized.Base01;
}
public DomainLogView(LocalEventStore eventStore, SimpleMessageSender endpoint, IEnvelopeStreamer serializer)
{
InitializeComponent();
_client = eventStore;
_services = new ShellServices(endpoint);
_serializer = serializer;
_log.BackColor = CommonColors.Solarized.Base03;
_log.ForeColor = CommonColors.Solarized.Base0;
_display.BackColor = CommonColors.Solarized.Base3;
_display.ForeColor = CommonColors.Solarized.Base00;
_detailsLabel.BackColor = CommonColors.Solarized.Base2;
_detailsLabel.ForeColor = CommonColors.Solarized.Base01;
}
protected override Setup ComposeComponents(IEnvelopeStreamer streamer)
{
// Azure dev is implemented via WS on top of SQL on top of FS.
// this can be slow. And it will be
TestSpeed = 7000;
var dev = AzureStorage.CreateConfigurationForDev();
WipeAzureAccount.Fast(s => s.StartsWith("test-"), dev);
return new Setup
{
Sender = dev.CreateSimpleSender(streamer, "test-incoming"),
Inbox = dev.CreateInbox("test-incoming", visibilityTimeout : TimeSpan.FromMilliseconds(1)),
Storage = dev.CreateNuclear(builder =>
{
builder.FolderForSingleton("test-single");
}, "nuclear")
};
}
protected override Setup ComposeComponents(IEnvelopeStreamer streamer)
{
// Azure dev is implemented via WS on top of SQL on top of FS.
// this can be slow. And it will be
TestSpeed = 7000;
var dev = AzureStorage.CreateConfigurationForDev();
WipeAzureAccount.Fast(s => s.StartsWith("test-"), dev);
return(new Setup
{
Sender = dev.CreateSimpleSender(streamer, "test-incoming"),
Inbox = dev.CreateInbox("test-incoming", visibilityTimeout: TimeSpan.FromMilliseconds(1)),
Storage = dev.CreateNuclear(builder =>
{
builder.FolderForSingleton("test-single");
})
});
}
public DomainLogView(LocalEventStore eventStore, SimpleMessageSender endpoint, IEnvelopeStreamer serializer)
{
InitializeComponent();
_client = eventStore;
_services = new ShellServices(endpoint);
_serializer = serializer;
_log.BackColor = CommonColors.Solarized.Base03;
_log.ForeColor = CommonColors.Solarized.Base0;
_display.BackColor = CommonColors.Solarized.Base3;
_display.ForeColor = CommonColors.Solarized.Base00;
_detailsLabel.BackColor = CommonColors.Solarized.Base2;
_detailsLabel.ForeColor = CommonColors.Solarized.Base01;
var control = new RepopulateView(serializer, eventStore, _services) {Dock = DockStyle.Fill};
viewsTab.Controls.Add(control);
}
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));
}
public MessageSender(IEnvelopeStreamer streamer, IQueueWriter queue)
{
_queue = queue;
_streamer = streamer;
}
public MouseEventsRequestHandler(IQueueWriter writer, IDataSerializer serializer, IEnvelopeStreamer streamer)
{
_writer = writer;
_serializer = serializer;
_streamer = streamer;
}
public SimpleDispatcher(AggregateFactory aggregateFactory, IEnvelopeStreamer serializer, ITapeStream tapeStream)
{
_aggregateFactory = aggregateFactory;
_serializer = serializer;
_tapeStream = tapeStream;
}
public PubSubRouter(NuclearStorage storage, IQueueWriterFactory queueFactory, IEnvelopeStreamer streamer)
{
_storage = storage;
_queueFactory = queueFactory;
_streamer = streamer;
}
public MyAnonymousCommandSender(IQueueWriter writer, IDataSerializer serializer, IEnvelopeStreamer streamer)
{
_writer = writer;
_serializer = serializer;
_streamer = streamer;
}
protected abstract Setup ComposeComponents(IEnvelopeStreamer streamer);
public SimpleMessageSender(IEnvelopeStreamer streamer, params IQueueWriter[] queues)
: this(streamer, queues,null)
{
}
public FileQueueWriter(DirectoryInfo folder, string name, IEnvelopeStreamer streamer)
{
_folder = folder;
_streamer = streamer;
Name = name;
}
public FluentCqrsEngineBuilder(IEnvelopeStreamer streamer, IEnvelopeQuarantine quarantine = null, DuplicationManager duplication = null)
{
_builder = new CqrsEngineBuilder(streamer, quarantine, duplication);
}
static Program()
{
EnvelopeStreamer = Contracts.CreateStreamer();
}
public static MessageSender CreateMessageSender(this MemoryStorageConfig storageConfig, IEnvelopeStreamer streamer, string queueName)
{
return(new MessageSender(streamer, CreateQueueWriter(storageConfig, queueName)));
}
public SimpleMessageSender(IEnvelopeStreamer streamer, params IQueueWriter[] queues)
: this(streamer, queues, null)
{
}
public AggregateFactory(ITapeStorageFactory factory, IEnvelopeStreamer streamer, IQueueWriter writer)
{
_factory = factory;
_streamer = streamer;
_writer = writer;
}
public SimpleDispatcher(AggregateFactory aggregateFactory, IEnvelopeStreamer serializer, ITapeStream tapeStream)
{
_aggregateFactory = aggregateFactory;
_serializer = serializer;
_tapeStream = tapeStream;
}
public WebEndpoint(NuclearStorage store, IEnvelopeStreamer streamer, IQueueWriter writer)
{
_store = store;
_streamer = streamer;
_writer = writer;
}
protected abstract Setup ConfigureComponents(IEnvelopeStreamer config);
public DomainQueryManager(IEnvelopeStreamer serializer, LocalEventStore store, ShellServices services)
{
_serializer = serializer;
_store = store;
_services = services;
}
public static MessageSender CreateMessageSender(this IAzureStorageConfig account,
IEnvelopeStreamer streamer, string queueName)
{
return new MessageSender(streamer, CreateQueueWriter(account, queueName));
}
public StreamingTimerService(IQueueWriter target, IStreamingContainer storage, IEnvelopeStreamer streamer)
{
_target = target;
_storage = storage;
_streamer = streamer;
_suffix = Guid.NewGuid().ToString().Substring(0, 4);
}
public DomainLogView(LocalEventStore eventStore, SimpleMessageSender endpoint, IEnvelopeStreamer serializer)
{
InitializeComponent();
_client = eventStore;
_services = new ShellServices(endpoint);
_serializer = serializer;
_log.BackColor = CommonColors.Solarized.Base03;
_log.ForeColor = CommonColors.Solarized.Base0;
_display.BackColor = CommonColors.Solarized.Base3;
_display.ForeColor = CommonColors.Solarized.Base00;
_detailsLabel.BackColor = CommonColors.Solarized.Base2;
_detailsLabel.ForeColor = CommonColors.Solarized.Base01;
var control = new RepopulateView(serializer, eventStore, _services)
{
Dock = DockStyle.Fill
};
viewsTab.Controls.Add(control);
}
public static Action <ImmutableEnvelope> Route(Func <string, IQueueWriter> factory, IEnvelopeStreamer serializer,
ITapeStorageFactory tapes)
{
var events = factory(EventsQueue);
var timerQueue = factory(TimerQueue);
var entityQueue = factory(EntityQueue);
var services = factory(ServiceQueue);
var log = tapes.GetOrCreateStream(DomainLogName);
return(envelope =>
{
var data = serializer.SaveEnvelopeData(envelope);
if (!log.TryAppend(data))
{
throw new InvalidOperationException("Failed to record domain log");
}
if (envelope.DeliverOnUtc > Current.UtcNow)
{
timerQueue.PutMessage(data);
return;
}
if (envelope.Items.All(i => i.Content is ICommand <IIdentity>))
{
entityQueue.PutMessage(data);
return;
}
if (envelope.Items.All(i => i.Content is IEvent <IIdentity>))
{
// we can have more than 1 entity event.
// all entity events are routed to events as separate
for (int i = 0; i < envelope.Items.Length; i++)
{
var name = envelope.EnvelopeId + "-e" + i;
var copy = EnvelopeBuilder.CloneProperties(name, envelope);
copy.AddItem(envelope.Items[i]);
events.PutMessage(serializer.SaveEnvelopeData(copy.Build()));
}
return;
}
if (envelope.Items.Length != 1)
{
throw new InvalidOperationException(
"Only entity commands or entity events can be batched");
}
var item = envelope.Items[0].Content;
if (item is IFunctionalCommand)
{
services.PutMessage(data);
return;
}
if (item is IFunctionalEvent || item is ISampleEvent)
{
events.PutMessage(data);
return;
}
throw new InvalidOperationException(string.Format("Unroutable message {0}", item));
});
}
public FileQueueWriterFactory(FileStorageConfig account, IEnvelopeStreamer streamer)
{
_account = account;
_streamer = streamer;
_endpoint = _account.AccountName;
}
public static SimpleMessageSender CreateSimpleSender(this FileStorageConfig account, IEnvelopeStreamer streamer, string queueName)
{
return(new SimpleMessageSender(streamer, CreateQueueWriter(account, queueName)));
}
