/// <summary>
/// When overriden, defines the custom behavior to be invoked after attempting to save the specified <paramref name="aggregate"/>.
/// </summary>
/// <param name="aggregate">The modified <see cref="Aggregate"/> instance if <paramref name="commit"/> is not <value>null</value>; otherwise the original <see cref="Aggregate"/> instance if <paramref name="error"/> is not <value>null</value>.</param>
/// <param name="commit">The <see cref="Commit"/> generated if the save was successful; otherwise <value>null</value>.</param>
/// <param name="error">The <see cref="Exception"/> thrown if the save was unsuccessful; otherwise <value>null</value>.</param>
public override void PostSave(Aggregate aggregate, Commit commit, Exception error)
{
base.PostSave(aggregate, commit, error);
if (error is ConcurrencyException)
statistics.IncrementConflictCount();
}
/// <summary>
/// Initializes a new instance of <see cref="SaveResult"/>.
/// </summary>
/// <param name="aggregate">The saved <see cref="Aggregate"/>.</param>
/// <param name="commit">The generated <see cref="Commit"/></param>
public SaveResult(Aggregate aggregate, Commit commit)
{
Verify.NotNull(aggregate, nameof(aggregate));
Verify.NotNull(commit, nameof(commit));
Aggregate = aggregate;
Commit = commit;
}
/// <summary>
/// Verify that the specified <paramref name="aggregate"/> state has not been corrupted after a failed save attempt and update the check sum if the save was successful.
/// </summary>
/// <param name="aggregate">The modified <see cref="Aggregate"/> instance if <paramref name="commit"/> is not <value>null</value>; otherwise the original <see cref="Aggregate"/> instance if <paramref name="error"/> is not <value>null</value>.</param>
/// <param name="commit">The <see cref="Commit"/> generated if the save was successful; otherwise <value>null</value>.</param>
/// <param name="error">The <see cref="Exception"/> thrown if the save was unsuccessful; otherwise <value>null</value>.</param>
public override void PostSave(Aggregate aggregate, Commit commit, Exception error)
{
if (error != null)
aggregate.VerifyHash();
if (commit != null)
aggregate.UpdateHash();
}
/// <summary>
/// Apply the specified <see cref="Event"/> <paramref name="e"/> to the provided <paramref name="aggregate"/>.
/// </summary>
/// <param name="e">The event to be applied to the provided <paramref name="aggregate"/>.</param>
/// <param name="aggregate">The <see cref="Aggregate"/> instance on which the event is to be applied.</param>
public void Apply(Event e, Aggregate aggregate)
{
Verify.NotNull(e, nameof(e));
Verify.NotNull(aggregate, nameof(aggregate));
var applyMethods = GetKnownApplyMethods(aggregate);
var applyMethod = GetApplyMethod(aggregate, e, applyMethods);
Log.Trace("Applying event {0} to aggregate {1}", e, aggregate);
applyMethod(aggregate, e);
}
/// <summary>
/// When overriden, defines the custom behavior to be invoked after attempting to save the specified <paramref name="aggregate"/>.
/// </summary>
/// <param name="aggregate">The modified <see cref="Aggregate"/> instance if <paramref name="commit"/> is not <value>null</value>; otherwise the original <see cref="Aggregate"/> instance if <paramref name="error"/> is not <value>null</value>.</param>
/// <param name="commit">The <see cref="Commit"/> generated if the save was successful; otherwise <value>null</value>.</param>
/// <param name="error">The <see cref="Exception"/> thrown if the save was unsuccessful; otherwise <value>null</value>.</param>
public virtual void PostSave(Aggregate aggregate, Commit commit, Exception error)
{
}
/// <summary>
/// When overriden, defines the custom behavior to be invokes after successfully retrieving the specified <paramref name="aggregate"/>.
/// </summary>
/// <param name="aggregate">The loaded aggregate instance.</param>
public virtual void PostGet(Aggregate aggregate)
{
}
/// <summary>
/// Invokes zero or more customized <see cref="PipelineHook.PostGet"/> implementations.
/// </summary>
/// <param name="aggregate">The loaded aggregate instance.</param>
private void InvokePostGetHooks(Aggregate aggregate)
{
foreach (var pipelineHook in postGetHooks)
{
Log.Trace("Invoking post-get pipeline hook: {0}", pipelineHook);
pipelineHook.PostGet(aggregate);
}
}
/// <summary>
/// When overriden, defines the custom behavior to be invoked prior to saving the specified <paramref name="aggregate"/>.
/// </summary>
/// <param name="aggregate">The aggregate to be modified by the current <paramref name="context"/>.</param>
/// <param name="context">The current <see cref="CommandContext"/> containing the pending aggregate modifications.</param>
public virtual void PreSave(Aggregate aggregate, CommandContext context)
{
}
/// <summary>
/// When overriden, defines the custom behavior to be invoked after attempting to save the specified <paramref name="aggregate"/>.
/// </summary>
/// <param name="aggregate">The modified <see cref="Aggregate"/> instance if <paramref name="commit"/> is not <value>null</value>; otherwise the original <see cref="Aggregate"/> instance if <paramref name="error"/> is not <value>null</value>.</param>
/// <param name="commit">The <see cref="Commit"/> generated if the save was successful; otherwise <value>null</value>.</param>
/// <param name="error">The <see cref="Exception"/> thrown if the save was unsuccessful; otherwise <value>null</value>.</param>
public override void PostSave(Aggregate aggregate, Commit commit, Exception error)
{
if (commit?.Id != null)
DispatchCommit(commit);
else
Log.Warn("Commit not dispatched");
}
/// <summary>
/// Gets the set of known apply methods for the given <paramref name="aggregate"/> instance.
/// </summary>
/// <param name="aggregate">The <see cref="Aggregate"/> instance on which the event is to be applied.</param>
private ApplyMethodCollection GetKnownApplyMethods(Aggregate aggregate)
{
Type aggregateType = aggregate.GetType();
ApplyMethodCollection applyMethods;
if (!knownApplyMethods.TryGetValue(aggregateType, out applyMethods))
throw new MappingException(Exceptions.AggregateTypeUndiscovered.FormatWith(aggregate.GetType()));
return applyMethods;
}
/// <summary>
/// Verify that the specified <paramref name="aggregate"/> state has not been corrupted before proceeding with the save.
/// </summary>
/// <param name="aggregate">The aggregate to be modified by the current <paramref name="context"/>.</param>
/// <param name="context">The current <see cref="CommandContext"/> containing the pending aggregate modifications.</param>
public override void PreSave(Aggregate aggregate, CommandContext context)
{
aggregate.VerifyHash();
}
/// <summary>
/// Verify that the retrieved <paramref name="aggregate"/> state has not been corrupted before returning to the caller.
/// </summary>
/// <param name="aggregate">The loaded aggregate instance.</param>
public override void PostGet(Aggregate aggregate)
{
Verify.NotNull(aggregate, nameof(aggregate));
aggregate.VerifyHash();
}
/// <summary>
/// Invokes zero or more customized <see cref="PipelineHook.PreSave"/> implementations.
/// </summary>
/// <param name="aggregate">The aggregate to be modified by the current <paramref name="context"/>.</param>
/// <param name="context">The current <see cref="CommandContext"/> containing the pending aggregate modifications.</param>
private void InvokePreSaveHooks(Aggregate aggregate, CommandContext context)
{
foreach (var pipelineHook in preSaveHooks)
{
Log.Trace("Invoking pre-save pipeline hook: {0}", pipelineHook);
pipelineHook.PreSave(aggregate, context);
}
}
/// <summary>
/// Invokes zero or more customized <see cref="PipelineHook.PostSave"/> implementations.
/// </summary>
/// <param name="aggregate">The modified <see cref="Aggregate"/> instance if <paramref name="commit"/> is not <value>null</value>; otherwise the original <see cref="Aggregate"/> instance if <paramref name="error"/> is not <value>null</value>.</param>
/// <param name="commit">The <see cref="Commit"/> generated if the save was successful; otherwise <value>null</value>.</param>
/// <param name="error">The <see cref="Exception"/> thrown if the save was unsuccessful; otherwise <value>null</value>.</param>
private void InvokePostSaveHooks(Aggregate aggregate, Commit commit, Exception error)
{
foreach (var pipelineHook in postSaveHooks)
{
Log.Trace("Invoking post-save pipeline hook: {0}", pipelineHook);
pipelineHook.PostSave(aggregate, commit, error);
}
}
/// <summary>
/// When overriden, defines the custom behavior to be invoked prior to saving the specified <paramref name="aggregate"/>.
/// </summary>
/// <param name="aggregate">The aggregate to be modified by the current <paramref name="context"/>.</param>
/// <param name="context">The current <see cref="CommandContext"/> containing the pending aggregate modifications.</param>
public virtual void PreSave(Aggregate aggregate, CommandContext context)
{
}
/// <summary>
/// Get the associated apply method for the specified <see cref="Event"/> <paramref name="e"/> from the known <paramref name="applyMethods"/>.
/// </summary>
/// <param name="aggregate">The <see cref="Aggregate"/> instance on which the event is to be applied.</param>
/// <param name="e">The <see cref="Event"/> to be applied.</param>
/// <param name="applyMethods">The set of known apply methods for a given aggregate instance</param>
private static Action<Aggregate, Event> GetApplyMethod(Aggregate aggregate, Event e, ApplyMethodCollection applyMethods)
{
Action<Aggregate, Event> applyMethod;
Type eventType = e.GetType();
if (applyMethods.TryGetValue(eventType, out applyMethod))
return applyMethod;
if (!applyMethods.ApplyOptional)
throw new MappingException(Exceptions.AggregateApplyMethodNotFound.FormatWith(aggregate.GetType(), e.GetType()));
return VoidApplyMethod;
}
/// <summary>
/// Save the specified <paramref name="context"/> changes for the given aggregate.
/// </summary>
/// <param name="aggregate">The current aggregate version for which the context applies.</param>
/// <param name="context">The command context containing the aggregate changes to be applied.</param>
public SaveResult Save(Aggregate aggregate, CommandContext context)
{
Verify.NotNull(aggregate, nameof(aggregate));
Verify.NotNull(context, nameof(context));
var commit = CreateCommit(aggregate, context);
try
{
eventStore.Save(commit);
}
catch (DuplicateCommitException)
{
Log.Warn("Duplicate commit: {0}", commit);
}
// NOTE: Apply commit directly to existing aggregate. By default, each call to `Get` returns a new `Aggregate` instance.
// Should the caller hold on to a reference to `this` aggregate instance, it is their responsibility to gaurd against
// modifications (via `aggregate.Copy()` call) if they require an unaltered instance of `aggregate`.
ApplyCommitToAggregate(commit, aggregate);
if (aggregate.Version > 0 && aggregate.Version % snapshotInterval == 0)
snapshotStore.Save(new Snapshot(aggregate.Id, aggregate.Version, aggregate));
return new SaveResult(aggregate, commit);
}
/// <summary>
/// Creates a commit for the specified <paramref name="aggregate"/> based on the provided <paramref name="context"/>.
/// </summary>
/// <param name="aggregate">The <see cref="Aggregate"/> instance for which the commit is to be applied.</param>
/// <param name="context">The <see cref="CommandContext"/> instance containing the pending modifications to the associated <paramref name="aggregate"/>.</param>
private static Commit CreateCommit(Aggregate aggregate, CommandContext context)
{
EventCollection events = context.GetRaisedEvents();
HeaderCollection headers;
if (aggregate.Version == 0)
{
var typeHeader = new Header(Header.Aggregate, aggregate.GetType().GetFullNameWithAssembly(), checkReservedNames: false);
headers = new HeaderCollection(context.Headers.Concat(typeHeader));
}
else
{
headers = context.Headers;
}
return new Commit(context.CommandId, aggregate.Id, aggregate.Version + 1, headers, events);
}
/// <summary>
/// Applies all <see cref="Commit.Events"/> to the specified <paramref name="aggregate"/> instance.
/// </summary>
/// <param name="commit">The <see cref="Commit"/> to be applied to the specified <paramref name="aggregate"/>.</param>
/// <param name="aggregate">The <see cref="Aggregate"/> instance for which the commit is to be applied.</param>
private void ApplyCommitToAggregate(Commit commit, Aggregate aggregate)
{
var expectedVersion = aggregate.Version + 1;
if (commit.Version != expectedVersion)
throw new InvalidOperationException(Exceptions.MissingAggregateCommits.FormatWith(expectedVersion, commit.Version));
aggregate.Version = commit.Version;
foreach (var e in commit.Events)
{
using (new EventContext(aggregate.Id, commit.Headers, e))
aggregateUpdater.Apply(e, aggregate);
}
}
/// <summary>
/// When overriden, defines the custom behavior to be invokes after successfully retrieving the specified <paramref name="aggregate"/>.
/// </summary>
/// <param name="aggregate">The loaded aggregate instance.</param>
public virtual void PostGet(Aggregate aggregate)
{
}
/// <summary>
/// Verify that the retrieved <paramref name="aggregate"/> state has not been corrupted before returning to the caller.
/// </summary>
/// <param name="aggregate">The loaded aggregate instance.</param>
public override void PostGet(Aggregate aggregate)
{
Verify.NotNull(aggregate, nameof(aggregate));
aggregate.VerifyHash();
}
/// <summary>
/// When overriden, defines the custom behavior to be invoked after attempting to save the specified <paramref name="aggregate"/>.
/// </summary>
/// <param name="aggregate">The modified <see cref="Aggregate"/> instance if <paramref name="commit"/> is not <value>null</value>; otherwise the original <see cref="Aggregate"/> instance if <paramref name="error"/> is not <value>null</value>.</param>
/// <param name="commit">The <see cref="Commit"/> generated if the save was successful; otherwise <value>null</value>.</param>
/// <param name="error">The <see cref="Exception"/> thrown if the save was unsuccessful; otherwise <value>null</value>.</param>
public virtual void PostSave(Aggregate aggregate, Commit commit, Exception error)
{
}
/// <summary>
/// Verify that the specified <paramref name="aggregate"/> state has not been corrupted before proceeding with the save.
/// </summary>
/// <param name="aggregate">The aggregate to be modified by the current <paramref name="context"/>.</param>
/// <param name="context">The current <see cref="CommandContext"/> containing the pending aggregate modifications.</param>
public override void PreSave(Aggregate aggregate, CommandContext context)
{
aggregate.VerifyHash();
}
/// <summary>
/// Save the specified <paramref name="context"/> changes for the given aggregate.
/// </summary>
/// <param name="aggregate">The current aggregate version for which the context applies.</param>
/// <param name="context">The command context containing the aggregate changes to be applied.</param>
public SaveResult Save(Aggregate aggregate, CommandContext context)
{
Verify.NotNull(aggregate, nameof(aggregate));
Verify.NotNull(context, nameof(context));
var copy = aggregate.Copy();
var aggregateType = aggregate.GetType();
var key = String.Concat(aggregateType.GetFullNameWithAssembly(), "-", aggregate.Id);
using (var aggregateLock = new AggregateLock(aggregateType, aggregate.Id))
{
aggregateLock.Aquire();
try
{
var result = aggregateStore.Save(copy, context);
memoryCache.Set(key, copy, CreateCacheItemPolicy());
return result;
}
catch (ConcurrencyException)
{
memoryCache.Remove(key);
throw;
}
}
}
/// <summary>
/// Save the specified <paramref name="context"/> changes for the given aggregate.
/// </summary>
/// <param name="aggregate">The current aggregate version for which the context applies.</param>
/// <param name="context">The command context containing the aggregate changes to be applied.</param>
public SaveResult Save(Aggregate aggregate, CommandContext context)
{
InvokePreSaveHooks(aggregate, context);
try
{
var result = aggregateStore.Save(aggregate, context);
InvokePostSaveHooks(result.Aggregate, result.Commit, null);
return result;
}
catch (Exception ex)
{
InvokePostSaveHooks(aggregate, null, ex);
throw;
}
}
