public object GetSnapshot(SnapshotId snapshotId)
{
if (!File.Exists(snapshotId.FilePath))
{
return(null);
}
var fullSnapshot = JObject.Parse(File.ReadAllText(snapshotId.FilePath));
if (snapshotId.PrimaryId == null && snapshotId.SecondaryId == null)
{
return(fullSnapshot);
}
if (snapshotId.PrimaryId != null &&
fullSnapshot.TryGetValue(snapshotId.PrimaryId, out var partialSnapshot))
{
if (snapshotId.SecondaryId != null &&
partialSnapshot is JObject partialSnapshotJObject &&
partialSnapshotJObject.TryGetValue(snapshotId.SecondaryId, out partialSnapshot))
{
return(partialSnapshot);
}
return(partialSnapshot);
}
return(null);
}
public override int GetHashCode()
{
unchecked
{
return(((SnapshotId != null ? SnapshotId.GetHashCode() : 0) * 397) ^ EqualityComparer <T> .Default.GetHashCode(State));
}
}
public void CommittedSnapshot_AfterSerialization_IsValidAfterDeserialization()
{
var aggregateSequenceNumber = 3;
var aggregateId = TestAggregateId.New;
var aggregateSnapshot = new TestAggregateSnapshot(Enumerable.Range(0, aggregateSequenceNumber - 1).Select(x => new TestAggregateSnapshot.TestModel(Guid.NewGuid())).ToList());
var now = DateTimeOffset.UtcNow;
var snapshotId = SnapshotId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Snapshots,
$"{aggregateId.Value}-v{aggregateSequenceNumber}");
var snapshotMetadata = new SnapshotMetadata
{
SnapshotId = snapshotId,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = typeof(TestAggregate).GetAggregateName().Value,
AggregateId = aggregateId.Value,
};
var committedEvent =
new ComittedSnapshot <TestAggregate, TestAggregateId, TestAggregateSnapshot>(
aggregateId,
aggregateSnapshot,
snapshotMetadata,
now,
aggregateSequenceNumber);
committedEvent.SerializeDeserialize().Should().BeEquivalentTo(committedEvent);
}
public void MatchSnapshot(object snapshot, SnapshotId snapshotId)
{
var sanitisedSnapshot = _snapshotSanitiser.SanitiseSnapshot(snapshot);
var result = Snap(snapshotId, sanitisedSnapshot);
_snapshotAsserter.AssertSnapshot(result);
}
public override bool Equals(object obj)
{
if (GetType() == obj.GetType())
{
SnapshotId other = (SnapshotId)obj;
return(other.ParentId == ParentId &&
other.ChildId == ChildId);
}
else
{
return(false);
}
}
public virtual IEnumerable<SnapshotItem> GetDeletedItemsBetweenSnapshots(SnapshotId currentId, SnapshotId targetId)
{
//TODO: Allow for case sensitive compare if we ever port to Linux
HashSet<string> newPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (var item in GetSnapshotItems(targetId))
{
newPaths.Add(item.RelativePath);
}
foreach (var item in GetSnapshotItems(currentId))
{
if (!newPaths.Contains(item.RelativePath))
{
// this is missing in the newer snapshot, so it is a deletion.
yield return item;
}
}
}
protected SnapResult Snap(SnapshotId snapshotId, object newSnapshot)
{
var currentSnapshot = _snapshotStore.GetSnapshot(snapshotId);
if (ShouldUpdateSnapshot(currentSnapshot, newSnapshot))
{
_snapshotStore.StoreSnapshot(snapshotId, newSnapshot);
return(SnapResult.SnapshotUpdated(currentSnapshot, newSnapshot));
}
if (currentSnapshot == null)
{
return(SnapResult.SnapshotDoesNotExist(newSnapshot));
}
return(_snapshotComparer.CompareSnapshots(currentSnapshot, newSnapshot)
? SnapResult.SnapshotsMatch(currentSnapshot, newSnapshot)
: SnapResult.SnapshotsDoNotMatch(currentSnapshot, newSnapshot));
}
protected SnapResult Snap(SnapshotId snapshotId, object newSnapshot)
{
var currentSnapshot = _snapshotStore.GetSnapshot(snapshotId);
var areSnapshotsEqual = currentSnapshot != null &&
_snapshotComparer.CompareSnapshots(currentSnapshot, newSnapshot);
if (!areSnapshotsEqual && _snapshotUpdateDecider.ShouldUpdateSnapshot())
{
_snapshotStore.StoreSnapshot(snapshotId, newSnapshot);
return(SnapResult.SnapshotUpdated(currentSnapshot, newSnapshot));
}
if (currentSnapshot == null)
{
return(SnapResult.SnapshotDoesNotExist(newSnapshot));
}
return(areSnapshotsEqual
? SnapResult.SnapshotsMatch(currentSnapshot, newSnapshot)
: SnapResult.SnapshotsDoNotMatch(currentSnapshot, newSnapshot));
}
/// <summary>
/// The process record method.
/// </summary>
protected override void ProcessRecord()
{
ResponseType response = null;
base.ProcessRecord();
try
{
var request = new CreateSnapshotPreviewServerType
{
snapshotId = SnapshotId.ToString(),
serverName = Name,
serverDescription = Description,
targetClusterId = ClusterId,
serverStarted = IsStarted,
nicsConnected = NicsConnected
};
response = Connection.ApiClient.Snapshot.CreateSnapshotPreviewServer(request).Result;
}
catch (AggregateException ae)
{
ae.Handle(
e =>
{
if (e is ComputeApiException)
{
WriteError(new ErrorRecord(e, "-2", ErrorCategory.InvalidOperation, Connection));
}
else
{
// if (e is HttpRequestException)
ThrowTerminatingError(new ErrorRecord(e, "-1", ErrorCategory.ConnectionError, Connection));
}
return(true);
});
}
WriteObject(response);
}
public void StoreSnapshot(SnapshotId snapshotId, object value)
{
Directory.CreateDirectory(Path.GetDirectoryName(snapshotId.FilePath));
var newSnapshot = JObject.FromObject(value);
JToken newSnapshotToWrite;
if (snapshotId.PrimaryId == null && snapshotId.SecondaryId == null)
{
newSnapshotToWrite = newSnapshot;
}
else
{
var rawSnapshotContent = GetRawSnapshotContent(snapshotId.FilePath);
newSnapshotToWrite = rawSnapshotContent == null
? new JObject()
: JObject.Parse(rawSnapshotContent);
if (snapshotId.PrimaryId != null && snapshotId.SecondaryId == null)
{
newSnapshotToWrite[snapshotId.PrimaryId] = newSnapshot;
}
else if (snapshotId.PrimaryId != null && snapshotId.SecondaryId != null)
{
var firstLevel = newSnapshotToWrite[snapshotId.PrimaryId];
if (firstLevel == null)
{
newSnapshotToWrite[snapshotId.PrimaryId] = new JObject();
}
newSnapshotToWrite[snapshotId.PrimaryId][snapshotId.SecondaryId] = newSnapshot;
}
}
File.WriteAllText(snapshotId.FilePath, newSnapshotToWrite.ToString());
}
public override IEnumerable<SnapshotItem> GetSnapshotItems(SnapshotId snapshotId)
{
var commit = CommitFromSnapshotId(snapshotId);
var tstamp = commit.Author.When;
return FromTree("", commit.Tree, ignored => tstamp);
}
public void StoreSnapshot(SnapshotId snapshotId, object snapshot)
{
}
public abstract SnapshotInfo GetSnapshotInfo(SnapshotId snapshotId);
public abstract IEnumerable<SnapshotItem> GetSnapshotItems(SnapshotId token);
public void ResetWorkingDirectoryTo(SnapshotId id)
{
var commit = CommitFromSnapshotId(id);
GitRepo.Reset(ResetOptions.Hard, commit.Sha);
}
public abstract SnapshotId GetPreviousSnapshotId(SnapshotId snapshotId);
public override SnapshotInfo GetSnapshotInfo(SnapshotId snapshotId)
{
var commit = CommitFromSnapshotId(snapshotId);
return new SnapshotInfo(commit.Message, commit.Author.When, snapshotId);
}
public virtual IEnumerable<SnapshotItem> GetAddedItemsBetweenSnapshots(SnapshotId currentId, SnapshotId targetId)
{
// just swap the order to get additions.
return GetDeletedItemsBetweenSnapshots(targetId, currentId);
}
private Commit CommitFromSnapshotId(SnapshotId id)
{
var gitCommitId = (GitCommitId)id;
return (Commit)GitRepo.Lookup(gitCommitId.CommitId, ObjectType.Commit);
}
public EqualToSnapshotConstraint(SnapshotId snapshotId)
{
_snapshotId = snapshotId;
}
public SnapshotInfo(string comment, DateTimeOffset time, SnapshotId snapshotId)
{
Comment = comment;
Time = time;
SnapshotId = snapshotId;
}
public SnapResult MatchSnapshot(object snapshot, SnapshotId snapshotId)
{
var sanitisedSnapshot = _snapshotSanitiser.SanitiseSnapshot(snapshot);
return(Snap(snapshotId, sanitisedSnapshot));
}
public object GetSnapshot(SnapshotId snapshotId) => _snapshot;
/// <summary>
/// List snapshots between first id and last id inclusive.
/// </summary>
/// <param name="firstId">A more recently created snapshot.</param>
/// <param name="lastId">An id older than first Id</param>
/// <returns>Empty set on error</returns>
public virtual IEnumerable<SnapshotInfo> ListSnapshotsBetween(SnapshotId firstId, SnapshotId lastId)
{
List<SnapshotInfo> ret = new List<SnapshotInfo>();
var curr = GetLatestSnapshotId();
while (curr != null && !curr.Equals(firstId))
{
curr = GetPreviousSnapshotId(curr);
}
// ran out of ids
if (curr == null)
{
LogEvent.SnapshotIdNotFound(firstId);
// on error case return an empty enumeration.
ret.Clear();
return ret;
}
else
{
// add first id
ret.Add(GetSnapshotInfo(curr));
}
// if first is equal to last we are done.
if (firstId.Equals(lastId))
{
return ret;
}
// keep adding till we hit last.
while (curr != null && !curr.Equals(lastId))
{
ret.Add(GetSnapshotInfo(curr));
curr = GetPreviousSnapshotId(curr);
}
// ran out of ids.
if (curr == null)
{
LogEvent.SnapshotIdNotFound(lastId);
// on error case return an empty enumeration.
ret.Clear();
return ret;
}
else
{
// add last id
ret.Add(GetSnapshotInfo(curr));
}
return ret;
}
/// <summary>
/// Copies files from snapshot to dirRoot.
/// </summary>
/// <param name="snapshotId">The snapshot id</param>
/// <param name="dirRoot">Root to extract</param>
/// <remarks>
/// Doesn't delete any data, only adds or modifies data under dirRoot.
/// </remarks>
public virtual void PopulateDirectoryFromSnapshot(SnapshotId snapshotId, DirectoryInfo dirRoot)
{
if (snapshotId == null)
{
throw new ArgumentNullException("snapshotId");
}
if (dirRoot == null)
{
throw new ArgumentNullException("dirRoot");
}
var snapshotItems = GetSnapshotItems(snapshotId);
Parallel.ForEach(snapshotItems, item =>
{
var fullPath = SafeCombinePath(dirRoot, item.RelativePath);
if (fullPath == null)
{
LogEvent.UpdateOfItemSkipedBecauseOfError(item.RelativePath);
} else {
try
{
var itemDir = Path.GetDirectoryName(fullPath);
Directory.CreateDirectory(itemDir);
using (FileStream fs = new FileStream(fullPath, FileMode.Create))
{
item.ReadContent(content =>
{
content.CopyTo(fs);
content.Close();
});
fs.Close();
}
File.SetLastWriteTimeUtc(fullPath, item.LastModifiedTime.UtcDateTime);
LogEvent.ExtractedSnapshotContentTo(fullPath, item.Size, item.LastModifiedTime);
}
catch (Exception ex)
{
LogEvent.UnexpectedExceptionDuringPopulate(fullPath, ex);
}
}
});
}
public static EqualToSnapshotConstraint Snapshot(SnapshotId snapshotId)
{
return(new EqualToSnapshotConstraint(snapshotId));
}
public virtual void ProcessDeletionsBetweenSnapshot(SnapshotId currentId, SnapshotId targetId, DirectoryInfo dirRoot)
{
if (currentId.Equals(targetId))
{
return;
}
var deletions = GetDeletedItemsBetweenSnapshots(currentId, targetId);
foreach (var item in deletions)
{
var fullPath = SafeCombinePath(dirRoot, item.RelativePath);
if (fullPath == null)
{
LogEvent.DeleteOfItemSkipedBecauseOfError(item.RelativePath);
}
else
{
TryDeleteFile(fullPath);
}
}
}
/// <summary>
/// **EXPERIMENTAL**
/// <para>This method may be removed or changed in future versions.</para>
/// <para></para>
/// <para>
/// Compares the provided object with the stored snapshot.
/// It takes a <c>SnapshotId</c> for finer control of how and where the snapshot is stored.
/// </para>
/// </summary>
/// <param name="snapshot">The object to compare with the stored snapshot</param>
/// <param name="snapshotId">Describes how and where the snapshot is stored</param>
public static void ShouldMatchSnapshot(this object snapshot, SnapshotId snapshotId)
{
var snapper = SnapperFactory.GetJsonSnapper();
snapper.MatchSnapshot(snapshot, snapshotId);
}
public virtual void UpdateDirectoryFromSnapshot(SnapshotId currentId, SnapshotId targetId, DirectoryInfo dirRoot)
{
if (currentId.Equals(targetId))
{
return;
}
PopulateDirectoryFromSnapshot(targetId, dirRoot);
ProcessDeletionsBetweenSnapshot(currentId, targetId, dirRoot);
}
public new SnapResult Snap(SnapshotId snapshotId, object newSnapshot)
{
return(base.Snap(snapshotId, newSnapshot));
}
public override SnapshotId GetPreviousSnapshotId(SnapshotId snapshotId)
{
var commit = CommitFromSnapshotId(snapshotId);
if (commit != null)
{
var previousCommit = GetPreviousCommit(commit);
if (previousCommit != null)
{
return new GitCommitId(previousCommit.Id);
}
}
return null;
}
