public void restoring_incompatible_snapshot_should_return_false()
{
var ticket = TicketTestFactory.ForTest();
var persister = (IEventSourcedAggregate)ticket;
var snapshot = new SnapshotInfo(ticket.Id, 2, null, 0);
var restored = persister.TryRestore(snapshot);
Assert.False(restored);
}
protected override SnapshotInfo PreprocessSnapshot(SnapshotInfo snapshotInfo)
{
if (snapshotInfo.SnapshotVersion != 1)
{
return(null);
}
return(snapshotInfo);
}
void Initialize()
{
DateTime startTime = DateTime.Now;
_at = ActionTree.Read <ActionTree>(ActionTreeFile);
if (IsVerbose)
{
Console.WriteLine("Action tree: {0}", _at.Version.ToString());
}
_init = new InitData(this);
_playersCount = _at.PlayersCount;
_epsilonLog = new List <EpsilonLogEntry>();
_snapshotSwitcher = new SnapshotSwitcher(OutputPath, GetSnapshotHeaderFileName(), SnapshotsCount);
_curSnapshotInfo = new SnapshotInfo(_snapshotSwitcher.CurrentSnapshotPath, _playersCount);
IterationCounts = new int[_playersCount];
LastBrValues = new double[_playersCount];
_ptExt = new Node[_playersCount][];
_rng = new System.Random(RngSeed);
_mcDealer = new McDealer(GameDef, _rng);
_hands = new int[_playersCount][].Fill(i => new int[_mcDealer.HandSize]);
_handSizes = GameDef.GetHandSizes();
_oppGv = new double[_at.NodesCount];
bool isNewSnapshot = !_snapshotSwitcher.IsSnapshotAvailable;
if (isNewSnapshot)
{
CreateNewSnapshot();
}
//LoadSnapshot();
CreatePlayerTrees();
for (int p = 0; p < _playersCount; ++p)
{
if (TraceDir != null)
{
Vis.Show(this, p, GetTraceFileName(p, "tree", "init-pt", "gv"));
}
}
if (TraceDir != null)
{
VisChanceTree.Show(_init.PlayerCt, GetTraceFileName(0, "pct", "", "gv"));
}
PrintInitDone();
// Clean-up
_init = null;
double time = (DateTime.Now - startTime).TotalSeconds;
if (IsVerbose)
{
Console.WriteLine("Initialization done in {0:0.0} s", time);
}
}
public void restoring_incompatible_snapshot_should_return_false()
{
var ticket = TicketTestFactory.ForTest();
var snaphottable = (ISnapshottable)ticket;
var snapshot = new SnapshotInfo(ticket.Id, 2, null, null);
var restored = snaphottable.TryRestore(snapshot);
Assert.False(restored);
}
public async Task snapshot_data_should_be_different_across_write_and_reads()
{
var input = new SnapshotInfo("Aggregate_1", 1, new State(), 1);
await _snapshots.Add("Aggregate_1", input);
var output = await _snapshots.Get("Aggregate_1", Int32.MaxValue);
Assert.NotSame(input.Data, output.Data);
}
public async Task empty_snapshot_is_not_persisted()
{
var nullSnapshot = new SnapshotInfo("empty", 0, null, string.Empty);
await _snapshots.AddAsync("empty", nullSnapshot);
var tape = new Recorder();
await Store.ReadForwardAsync("empty", 0, tape);
Assert.True(tape.IsEmpty);
}
public async Task snapshot_data_should_be_different_across_write_and_reads()
{
var input = new SnapshotInfo("Aggregate_1", 1, new State(), string.Empty);
await _snapshots.AddAsync("Aggregate_1", input);
var output = await _snapshots.GetAsync("Aggregate_1", Int32.MaxValue);
Assert.NotSame(input.Payload, output.Payload);
}
internal StateSnapshot(ReplicatedState state, IntPtr stateHandle)
{
State = state;
var info = new SnapshotInfo();
handle = PInvoke_GetSnapshot(stateHandle, ref info);
Version = info.Version;
KeysCount = info.KeysCount.ToUInt64();
SubkeysCount = info.SubkeysCount.ToUInt64();
}
public async Task snapshots_can_be_deleted()
{
var input = new SnapshotInfo("Aggregate_1", 1, new State(), string.Empty);
await _snapshots.AddAsync("Aggregate_1", input);
await _snapshots.DeleteAsync("Aggregate_1");
var tape = new Recorder();
await Store.ReadForwardAsync("Aggregate_1", 0, tape);
Assert.True(tape.IsEmpty);
}
public async Task with_snapshot_but_without_stream_should_throw_stale_aggregate_exception()
{
var ticketState = new TicketState();
var snapshot = new SnapshotInfo("Ticket_1", 2, ticketState, "1");
await Snapshots.AddAsync("Ticket_1", snapshot).ConfigureAwait(false);
var ex = await Assert.ThrowsAsync <StaleSnapshotException>(() =>
Repository.GetByIdAsync <Ticket>("Ticket_1")
).ConfigureAwait(false);
Assert.Equal("Ticket_1", ex.AggregateId);
Assert.Equal(2, ex.AggregateVersion);
}
protected AbstractAggregateTest()
{
this.Aggregate = _defaultFactory.Create <TAggregate>();
this.State = new TState();
var snapshot = new SnapshotInfo("test", 1, this.State, "1");
((ISnaphottable)this.Aggregate).TryRestore(snapshot);
if (!this.Aggregate.IsInitialized)
{
throw new Exception("something went wrong");
}
}
public void process_can_apply_changeset()
{
Checkout.MessageReceived(new PaymentReceived("Order_1", DateTime.Parse("2017-12-31")));
var changeset = GetChangeset();
var cloned = new CheckoutProcess();
var snapshot = new SnapshotInfo("test", 1, new CheckoutState(), "1");
((ISnaphottable)cloned).TryRestore(snapshot);
((IEventSourcedAggregate)cloned).ApplyChanges(changeset);
Assert.True(cloned.ExposeStateForTest.PaymentReceived);
}
public void TestXmlSerializer_ISerializable()
{
var value = new SnapshotInfo()
{
Time = DateTime.Now.ToUniversalTime()
};
var xml = XmlSerializer.Serialize(value);
var roundtrip = (SnapshotInfo)XmlSerializer.Deserialize(xml);
Assert.IsNotNull(roundtrip);
Assert.AreEqual <Guid>(value.Id, roundtrip.Id);
Assert.AreEqual <DateTime>(value.Time, roundtrip.Time);
}
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (SiteConfig != null)
{
SiteConfig.Validate();
}
if (CloningInfo != null)
{
CloningInfo.Validate();
}
if (SnapshotInfo != null)
{
SnapshotInfo.Validate();
}
}
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="ValidationException">
/// Thrown if validation fails
/// </exception>
public override void Validate()
{
if (SiteConfig != null)
{
SiteConfig.Validate();
}
if (CloningInfo != null)
{
CloningInfo.Validate();
}
if (SnapshotInfo != null)
{
SnapshotInfo.Validate();
}
}
private void ParsePackedNativeUnityEngineObject()
{
_snapshotInfo = new SnapshotInfo();
Debug.Log("nativeObjects Length: " + _snapshot.nativeObjects.Length);
foreach (PackedNativeUnityEngineObject nativeObject in _snapshot.nativeObjects)
{
string typeName = _snapshot.nativeTypes[nativeObject.nativeTypeArrayIndex].name;
_snapshotInfo.AddObjectToType(typeName, nativeObject);
_snapshotInfo.TotalSize += nativeObject.size;
_snapshotInfo.TotalObjects++;
}
_snapshotInfo.Sort();
}
public void TestSaveAndGet_ISerializable()
{
var testObject = new SnapshotInfo()
{
Time = DateTime.Now
};
testFile.SaveItem(key, testObject);
var roundTrip = testFile.GetItem <SnapshotInfo>(key);
Assert.IsNotNull(roundTrip);
Assert.AreEqual <Guid>(testObject.Id, roundTrip.Id);
Assert.AreEqual <DateTime>(testObject.Time, roundTrip.Time.ToLocalTime());
}
private async Task <SnapshotInfo> LoadSnapshot(string snapshotId, CancellationToken cancellationToken)
{
SnapshotInfo si = null;
if (_upToIndex.HasValue)
{
si = await _snapshots.GetAsync(snapshotId, _upToIndex.Value, cancellationToken)
.ConfigureAwait(false);
}
else
{
si = await _snapshots.GetLastAsync(snapshotId, cancellationToken)
.ConfigureAwait(false);
}
return(si);
}
public AbstractProcessManagerTest()
{
Process = _defaultFactory.Create <TProcess>();
State = new TState();
//restore @ version 1
var snapshot = new SnapshotInfo("test", 1, State, "1");
((ISnaphottable)this.Process).TryRestore(snapshot);
if (!this.Process.IsInitialized)
#pragma warning disable S112 // General exceptions should never be thrown
{
throw new Exception("something went wrong");
}
#pragma warning restore S112 // General exceptions should never be thrown
}
protected override SnapshotInfo PreprocessSnapshot(SnapshotInfo snapshotInfo)
{
var baseProcessing = base.PreprocessSnapshot(snapshotInfo);
if (baseProcessing == null)
{
return(null);
}
//We are trying to restore a snapshot that has not the very same version of itnernal state of this aggregate
var emptyState = new TState();
if (snapshotInfo.SchemaVersion != emptyState.VersionSignature)
{
return(null);
}
JarvisAggregateState state = snapshotInfo.Payload as JarvisAggregateState;
if (state == null)
{
return(null);
}
//If we need to restore the aggregate we should restore all the entities
snapshotRestoredEntities = new List <IEntityRoot>();
foreach (var entity in CreateChildEntities(snapshotInfo.SourceId))
{
JarvisEntityState entityState;
if (!state.EntityStates.TryGetValue(entity.Id, out entityState))
{
return(null); // one of the entity cannot be restored
}
//TODO: Need to change nstore to avoid this.
var info = new SnapshotInfo(snapshotInfo.SourceId, snapshotInfo.SourceVersion, entityState.Clone(), entityState.VersionSignature);
if (!entity.TryRestore(info))
{
return(null); //This snapshot is not valid for the entity
}
snapshotRestoredEntities.Add(entity);
}
//Set restore snapshot and create a new payload with a clone of the state
RestoreSnapshot = snapshotInfo;
return(new SnapshotInfo(snapshotInfo.SourceId, snapshotInfo.SourceVersion, state.Clone(), snapshotInfo.SchemaVersion));
}
public void LoadSnapshot()
{
if (IsVerbose)
{
Console.WriteLine("Loading snapshot from {0}", _curSnapshotInfo.BaseDir);
}
_loadedSnapshotInfo = _curSnapshotInfo;
using (TextReader tr = new StreamReader(_curSnapshotInfo.HeaderFile))
{
string line;
for (int pos = 0; pos < _playersCount; ++pos)
{
line = tr.ReadLine();
IterationCounts[pos] = int.Parse(line);
}
line = tr.ReadLine();
}
_epsilonLog.Clear();
if (File.Exists(_curSnapshotInfo.EpsilonLog))
{
using (TextReader tr = new StreamReader(_curSnapshotInfo.EpsilonLog))
{
for (;;)
{
string line;
line = tr.ReadLine();
if (line == null)
{
break;
}
string[] data = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
_epsilonLog.Add(new EpsilonLogEntry
{
Epsilon = double.Parse(data[0]),
TotalIterationsCount = int.Parse(data[1]),
});
}
}
}
}
public static T Create <T, TId, TState>(TState initialState, IIdentity identity, Int32 version)
where T : AggregateRoot <TState, TId>
where TState : JarvisAggregateState, new()
where TId : EventStoreIdentity
{
if (identity == null)
{
throw new ArgumentNullException(nameof(identity));
}
var ctor = typeof(T).Constructor(Flags.Default, new Type[] { });
if (ctor == null)
{
throw new MissingMethodException(string.Format("{0} missing default ctor", typeof(T).FullName));
}
var aggregate = (T)ctor.CreateInstance();
//To restore the state from the test we need to pass from the snapshot
if (version > 0)
{
SnapshotInfo snapshot = new SnapshotInfo(
identity.ToString(),
version,
initialState,
initialState.VersionSignature);
aggregate.Init(identity.ToString());
var restoreResult = ((ISnapshottable)aggregate).TryRestore(snapshot);
if (!restoreResult)
{
throw new Machine.Specifications.SpecificationException("Unable to restore snapshot into the aggregate under test");
}
}
else if (initialState != null)
{
throw new Machine.Specifications.SpecificationException("If you specify a not null initialState version should be greater than zero. Pass null as state if you want to create a new empty aggregate!!");
}
aggregate.Init(identity.AsString());
return(aggregate);
}
public void TestSnapshotInfoSerialization_Valid()
{
var snapshotInfo = new SnapshotInfo();
snapshotInfo.Time = DateTime.Now.ToUniversalTime();
var xml = snapshotInfo.Serialize();
var roundTrip = new SnapshotInfo();
Assert.IsTrue(roundTrip.Validate(xml));
roundTrip.Deserialize(xml);
Assert.IsNotNull(snapshotInfo);
Assert.IsNotNull(roundTrip);
Assert.AreEqual <Guid>(snapshotInfo.Id, roundTrip.Id);
Assert.AreEqual <DateTime>(snapshotInfo.Time, roundTrip.Time);
}
/// <summary>
/// See <see cref="IDatabaseServices.DeleteSnapshot(SnapshotInfo)"/>.
/// </summary>
public void DeleteSnapshot(SnapshotInfo snapshot)
{
ArgumentChecks.AssertNotNull(snapshot, nameof(snapshot));
try
{
snapshot.Database.Connection.DbServer.Services.Snapshots.DeleteSnapshot(
snapshot.Name,
new DbServerConnectionData(
snapshot.Database.Connection.Host,
snapshot.Database.Connection.UsesIntegratedSecurity,
snapshot.Database.Connection.UserId,
snapshot.Database.Connection.Password));
}
catch (Exception ex)
{
var message = string.Format(CultureInfo.CurrentCulture, Messages.DeleteSnapshotFailed, snapshot);
throw new SnapshotException(message, ex);
}
}
bool ISnapshottable.TryRestore(SnapshotInfo snapshotInfo)
{
if (snapshotInfo == null)
{
throw new ArgumentNullException(nameof(snapshotInfo));
}
var processed = PreprocessSnapshot(snapshotInfo);
if (processed == null || processed.IsEmpty)
{
return(false);
}
this.InternalInit(
processed.SourceId,
processed.SourceVersion,
(TState)processed.Payload
);
return(true);
}
/// <summary>
/// See <see cref="ISnapshotRepository.TryDeleteSnapshot(SnapshotInfo)"/>.
/// </summary>
public SuccessResult TryDeleteSnapshot(SnapshotInfo snapshot)
{
ArgumentChecks.AssertNotNull(snapshot, nameof(snapshot));
try
{
this._databaseServices.DeleteSnapshot(snapshot);
// If this snapshot and his friends from the same database were already loaded...
if (this._snapshotsPerDatabaseDict.ContainsKey(snapshot.Database))
{
// ...we try to reload them.
return(this.TryLoadSnapshots(snapshot.Database));
}
return(SuccessResult.CreateSuccessful());
}
catch (SnapshotException ex)
{
return(SuccessResult.CreateFailed($"{ex.Message} ({ex.InnerException.Message})"));
}
}
public bool TryRestore(SnapshotInfo snapshotInfo)
{
if (snapshotInfo == null)
{
throw new ArgumentNullException(nameof(snapshotInfo));
}
var processed = PreprocessSnapshot(snapshotInfo);
if (processed == null || processed.IsEmpty)
{
return(false);
}
var state = (TState)processed.Payload;
if (snapshotInfo.SchemaVersion != _state.VersionSignature)
{
return(false);
}
_state = state;
return(true);
}
/// <summary>
/// Give chance to upcast state or just drop snapshot with empty default state
/// </summary>
/// <param name="snapshotInfo"></param>
/// <returns></returns>
protected virtual SnapshotInfo PreprocessSnapshot(SnapshotInfo snapshotInfo)
{
return(snapshotInfo);
}
/// <summary>
/// Delegate for logging core actions.
/// </summary>
/// <param name="core">The core the request was made for.</param>
/// <param name="request">The original request.</param>
/// <param name="action">The action taken.</param>
private void RequestProcessed(Core core, CoreRequest request, CoreAction action)
{
if (core == _core)
{
if (action != null)
{
Auditors?.Invoke(action);
if (action.Type != CoreAction.Types.CreateSnapshot &&
action.Type != CoreAction.Types.DeleteSnapshot &&
action.Type != CoreAction.Types.RevertToSnapshot)
{
HistoryEvent e = _history.AddCoreAction(action);
switch (action.Type)
{
case CoreRequest.Types.LoadDisc:
Status = (action.MediaBuffer.GetBytes() != null) ? "Loaded disc" : "Ejected disc";
break;
case CoreRequest.Types.LoadTape:
Status = (action.MediaBuffer.GetBytes() != null) ? "Loaded tape" : "Ejected tape";
break;
case CoreRequest.Types.Reset:
Status = "Reset";
break;
}
}
if (action.Type == CoreAction.Types.RunUntil)
{
lock (_snapshots)
{
SnapshotInfo newSnapshot = _snapshots.LastOrDefault();
if (newSnapshot != null && action.AudioSamples != null)
{
newSnapshot.AudioBuffer.Write(action.AudioSamples);
}
}
}
else if (action.Type == CoreAction.Types.RevertToSnapshot)
{
HistoryEvent historyEvent = ((SnapshotInfo)request.UserData).HistoryEvent;
if (_history.CurrentEvent != historyEvent)
{
_history.CurrentEvent = historyEvent;
}
Display.CopyScreenAsync();
}
else if (action.Type == CoreAction.Types.CreateSnapshot)
{
lock (_snapshots)
{
// Figure out what history event should be set as current if we revert to this snapshot.
// If the current event is a RunUntil, it may not be "finalized" yet (i.e. it may still
// be updated), so go with its parent.
HistoryEvent historyEvent = _history.MostRecentClosedEvent(_history.CurrentEvent);
SnapshotInfo newSnapshot = new SnapshotInfo(action.SnapshotId, historyEvent);
_snapshots.Add(newSnapshot);
while (_snapshots.Count > _snapshotLimit)
{
SnapshotInfo snapshot = _snapshots[0];
_snapshots.RemoveAt(0);
_core.PushRequest(CoreRequest.DeleteSnapshot(snapshot.Id));
}
}
}
}
}
}
public async Task <IAggregate> GetByIdAsync(Type aggregateType, string id, CancellationToken cancellationToken)
{
if (_trackingAggregates.TryGetValue(id, out IAggregate aggregate))
{
return(aggregate);
}
aggregate = _factory.Create(aggregateType);
var persister = (IEventSourcedAggregate)aggregate;
SnapshotInfo snapshot = null;
if (_snapshots != null && aggregate is ISnapshottable snapshottable)
{
snapshot = await _snapshots.GetLastAsync(id, cancellationToken).ConfigureAwait(false);
if (snapshot != null)
{
//@@REVIEW: invalidate snapshot on false?
snapshottable.TryRestore(snapshot);
}
}
if (!aggregate.IsInitialized)
{
aggregate.Init(id);
}
_trackingAggregates.Add(id, aggregate);
var stream = OpenStream(id);
int readCount = 0;
var subscription = new LambdaSubscription(data =>
{
readCount++;
persister.ApplyChanges((Changeset)data.Payload);
return(Task.FromResult(true));
});
var consumer = ConfigureConsumer(subscription, cancellationToken);
// we use aggregate.Version because snapshot could be rejected
// Starting point is inclusive, so almost one changeset should be loaded
// aggregate will ignore because ApplyChanges is idempotent
await stream.ReadAsync(consumer, aggregate.Version, long.MaxValue, cancellationToken).ConfigureAwait(false);
//Check lambda subscription for errors.
if (subscription.Failed)
{
throw new RepositoryReadException($"Error reading aggregate {id}", subscription.LastError);
}
persister.Loaded();
// no data from stream, we cannot validate the aggregate
if (snapshot != null && readCount == 0)
{
throw new StaleSnapshotException(snapshot.SourceId, snapshot.SourceVersion);
}
return(aggregate);
}
