public Applied Load(ICollection <ICommand <IIdentity> > commands)
{
var id = commands.First().Id;
var stream = _factory.GetOrCreateStream(IdentityConvert.ToStream(id));
var records = stream.ReadRecords(0, int.MaxValue).ToList();
var events = records
.SelectMany(r => _streamer.ReadAsEnvelopeData(r.Data).Items.Select(m => (IEvent <IIdentity>)m.Content))
.ToArray();
var then = new Applied();
if (records.Count > 0)
{
then.Version = records.Last().Version;
}
var recipeId = id as RecipeId;
if (recipeId != null)
{
var state = new RecipeAggregateState(events);
var agg = new RecipeAggregate(state, then.Events.Add);
ExecuteSafely(agg, commands);
return(then);
}
throw new NotSupportedException("identity not supported " + id);
}
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 ITapeStream InitializeAndGetTapeStorage()
{
var connectionString = Settings.Default.SqlConnectionString;
var tableName = Settings.Default.SqlTapeWriterTableName;
_storageFactory = new SqlTapeStorageFactory(connectionString, tableName);
var count = 0;
while (true)
{
count++;
try
{
_storageFactory.InitializeForWriting();
break;
}
catch (Exception)
{
if (count < 1)
{
System.Threading.Thread.Sleep(500);
continue;
}
throw;
}
}
const string name = "test";
return _storageFactory.GetOrCreateStream(name);
}
protected override ITapeStream InitializeAndGetTapeStorage()
{
_storageFactory = new FileTapeStorageFactory(_path);
_storageFactory.InitializeForWriting();
const string name = "test";
return(_storageFactory.GetOrCreateStream(name));
}
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 ITapeStream InitializeAndGetTapeStorage()
{
var config = AzureStorage.CreateConfig(_cloudStorageAccount);
_storageFactory = new BlobTapeStorageFactory(config, ContainerName);
_storageFactory.InitializeForWriting();
const string name = "test";
return _storageFactory.GetOrCreateStream(name);
}
protected override ITapeStream InitializeAndGetTapeStorage()
{
var config = AzureStorage.CreateConfig(_cloudStorageAccount);
_storageFactory = new BlobTapeStorageFactory(config, ContainerName);
_storageFactory.InitializeForWriting();
const string name = "test";
return(_storageFactory.GetOrCreateStream(name));
}
protected override ITapeStream InitializeAndGetTapeStorage()
{
var connectionString = Settings.Default.SqlConnectionString;
var tableName = Settings.Default.SqlTapeWriterTableName;
_storageFactory = new SqlTapeStorageFactory(connectionString, tableName);
var count = 0;
while (true)
{
count++;
try
{
_storageFactory.InitializeForWriting();
break;
}
catch (Exception)
{
if (count < 1)
{
System.Threading.Thread.Sleep(500);
continue;
}
throw;
}
}
const string name = "test";
return(_storageFactory.GetOrCreateStream(name));
}
void Dispatch(string id, IEnumerable <ICommand> commands)
{
var stream = _factory.GetOrCreateStream(id);
var records = stream.ReadRecords(0, int.MaxValue).ToList();
var events = records
.Select(tr => _streamer.ReadAsEnvelopeData(tr.Data))
.SelectMany(i => i.Items)
.Select(i => (IEvent)i.Content)
.ToList();
var then = AggregateFactory
.LoadProject(events, commands)
.Select(e => new MessageBuilder(e.GetType(), e)).ToList();
if (then.Count == 0)
{
return;
}
// events are stored here as envelopes )
var b = new EnvelopeBuilder("unknown");
foreach (var e in then)
{
b.Items.Add(e);
}
var version = records.Count == 0 ? 0 : records.Last().Version;
var data = _streamer.SaveEnvelopeData(b.Build());
var result = stream.TryAppend(data, TapeAppendCondition.VersionIs(version));
if (!result)
{
throw new InvalidOperationException(
"Data was modified concurrently, and we don't have merging implemented, yet");
}
var args = _path.Split(':');
IQueueWriterFactory factory;
if (!_queue.TryGet(args[0], out factory))
{
throw new InvalidOperationException("Not found " + _path);
}
var arVersion = events.Count + 1;
var arName = id;
for (int i = 0; i < then.Count; i++)
{
var name = string.Format("{0}/{1}/{2}", arName, arVersion, i);
var builder = new EnvelopeBuilder(name);
builder.Items.Add(then[i]);
builder.AddString("from-entity", arName);
factory.GetWriteQueue(args[1]).PutMessage(builder.Build());
}
}
protected override ITapeStream InitializeAndGetTapeStorage()
{
_storageFactory = new FileTapeStorageFactory(_path);
_storageFactory.InitializeForWriting();
const string name = "test";
return _storageFactory.GetOrCreateStream(name);
}
