public static ValueTask <Commit?> ReadCommitAsync(this IChasmRepository chasmRepository, CommitId?commitId, CancellationToken cancellationToken)
{
if (chasmRepository == null)
{
throw new ArgumentNullException(nameof(chasmRepository));
}
return(commitId.HasValue
? chasmRepository.ReadCommitAsync(commitId.Value, cancellationToken)
: default);
public HybridChasmRepo(IChasmRepository repository, IChasmSerializer serializer, CompressionLevel compressionLevel, int maxDop)
: base(serializer, compressionLevel, maxDop)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
Chain = new IChasmRepository[1] {
repository
};
}
public static Task <IChasmBlob> ReadObjectAsync(this IChasmRepository chasmRepository, Sha1?objectId, ChasmRequestContext requestContext = default, CancellationToken cancellationToken = default)
{
if (chasmRepository == null)
{
throw new ArgumentNullException(nameof(chasmRepository));
}
requestContext = ChasmRequestContext.Ensure(requestContext);
return(objectId.HasValue
? chasmRepository.ReadObjectAsync(objectId.Value, requestContext, cancellationToken)
: default);
public HybridChasmRepo(IChasmRepository repository1, IChasmRepository repository2, IChasmRepository repository3, IChasmSerializer serializer, CompressionLevel compressionLevel, int maxDop)
: base(serializer, compressionLevel, maxDop)
{
if (repository1 == null)
{
throw new ArgumentNullException(nameof(repository1));
}
if (repository2 == null)
{
throw new ArgumentNullException(nameof(repository2));
}
if (repository3 == null)
{
throw new ArgumentNullException(nameof(repository3));
}
Chain = new IChasmRepository[3] {
repository1, repository2, repository3
};
}
private static async Task TestRepository(IChasmRepository repository)
{
var g = Guid.NewGuid();
var data = g.ToByteArray();
var sha = Sha1.Hash(data);
// Unknown SHA
var usha = Sha1.Hash(Guid.NewGuid().ToByteArray());
var usha2 = Sha1.Hash(Guid.NewGuid().ToByteArray());
// Blob
await repository.WriteObjectAsync(sha, new ArraySegment <byte>(data), false, default);
var rdata = (await repository.ReadObjectAsync(sha, default));
Assert.True(rdata.HasValue);
Assert.Equal(16, rdata.Value.Length);
Assert.Equal(g, rdata.Value.Span.NonPortableCast <byte, Guid>()[0]);
var urdata = await repository.ReadObjectAsync(usha, default);
Assert.False(urdata.HasValue);
// Tree
var tree = new TreeNodeMap(
new TreeNode("firstItem", NodeKind.Blob, sha),
new TreeNode("secondItem", NodeKind.Blob, sha)
);
var treeId = await repository.WriteTreeAsync(tree, default);
var rtree = await repository.ReadTreeAsync(treeId, default);
Assert.True(rtree.HasValue);
Assert.Equal(tree, rtree.Value);
var urtree = await repository.ReadTreeAsync(new TreeId(usha), default);
Assert.False(urtree.HasValue);
// Commit
var commit = new Commit(
new CommitId?(),
treeId,
new Audit("User1", DateTimeOffset.UtcNow.AddDays(-1)),
new Audit("User2", DateTimeOffset.UtcNow),
"Initial commit"
);
var commitId = await repository.WriteCommitAsync(commit, default);
var rcommit = await repository.ReadCommitAsync(commitId, default);
Assert.True(rcommit.HasValue);
Assert.Equal(commit, rcommit);
var urcommit = await repository.ReadCommitAsync(new CommitId(usha), default);
Assert.False(urcommit.HasValue);
// CommitRef
var commitRefName = Guid.NewGuid().ToString("N");
var commitRef = new CommitRef("production", commitId);
await repository.WriteCommitRefAsync(null, commitRefName, commitRef, default);
var rcommitRef = await repository.ReadCommitRefAsync(commitRefName, commitRef.Branch, default);
Assert.True(rcommit.HasValue);
Assert.Equal(commitRef, rcommitRef);
var urcommitRef = await repository.ReadCommitRefAsync(commitRefName + "_", commitRef.Branch, default);
Assert.False(urcommit.HasValue);
await Assert.ThrowsAsync <ChasmConcurrencyException>(() =>
repository.WriteCommitRefAsync(null, commitRefName, new CommitRef("production", new CommitId(usha)), default));
await Assert.ThrowsAsync <ChasmConcurrencyException>(() =>
repository.WriteCommitRefAsync(new CommitId(usha2), commitRefName, new CommitRef("production", new CommitId(usha)), default));
await repository.WriteCommitRefAsync(null, commitRefName, new CommitRef("dev", commitId), default);
await repository.WriteCommitRefAsync(null, commitRefName, new CommitRef("staging", new CommitId(usha)), default);
await repository.WriteCommitRefAsync(null, commitRefName + "_1", new CommitRef("production", new CommitId(usha)), default);
var names = await repository.GetNamesAsync(default);
private static async Task TestRepository(IChasmRepository repository)
{
var g = Guid.NewGuid();
var cx = new ChasmRequestContext {
CorrelationId = Guid.NewGuid().ToString("D")
};
byte[] buffer = g.ToByteArray();
Sha1 sha = s_hasher.HashData(buffer);
// Unknown SHA
Sha1 usha1 = s_hasher.HashData(Guid.NewGuid().ToByteArray());
Sha1 usha2 = s_hasher.HashData(Guid.NewGuid().ToByteArray());
// Blob
var metadata = new ChasmMetadata("application/json", "file123.txt");
Sha1 sha2 = await repository.WriteObjectAsync(new ReadOnlyMemory <byte>(buffer), metadata, false, cx, default);
Assert.Equal(sha, sha2);
IChasmBlob rdata = await repository.ReadObjectAsync(sha, default);
Assert.True(rdata != null);
Assert.Equal(16, rdata.Content.Length);
Assert.Equal(g, new Guid(rdata.Content.ToArray()));
Assert.Equal("application/json", rdata.Metadata.ContentType);
Assert.Equal("file123.txt", rdata.Metadata.Filename);
IChasmBlob urdata = await repository.ReadObjectAsync(usha1, default);
Assert.False(urdata != null);
//
metadata = new ChasmMetadata("application/text", null);
sha2 = await repository.WriteObjectAsync(buffer, metadata, true, cx, default);
Assert.Equal(sha, sha2);
IChasmBlob cnt2 = await repository.ReadObjectAsync(sha2, default);
Assert.Equal(buffer, cnt2.Content.ToArray());
Assert.Equal("application/text", cnt2.Metadata.ContentType);
Assert.Null(cnt2.Metadata.Filename);
using (IChasmStream stream2 = await repository.ReadStreamAsync(sha2, cx, default))
using (var ms = new MemoryStream())
{
stream2.Content.CopyTo(ms);
Assert.Equal(buffer, ms.ToArray());
}
using (Stream stream2 = new MemoryStream(buffer))
{
sha2 = await repository.WriteObjectAsync(stream2, null, true, cx, default);
}
Assert.Equal(sha, sha2);
using (IChasmStream stream2 = await repository.ReadStreamAsync(sha2, cx, default))
using (var ms = new MemoryStream())
{
stream2.Content.CopyTo(ms);
Assert.Equal(buffer, ms.ToArray());
}
// Tree
var tree = new TreeNodeMap(
new TreeNode("firstItem", NodeKind.Blob, sha),
new TreeNode("secondItem", NodeKind.Blob, sha)
);
TreeId treeId = await repository.WriteTreeAsync(tree, cx, default);
TreeNodeMap?rtree = await repository.ReadTreeAsync(treeId, cx, default);
Assert.True(rtree.HasValue);
Assert.Equal(tree, rtree.Value);
TreeNodeMap?urtree = await repository.ReadTreeAsync(new TreeId(usha1), cx, default);
Assert.False(urtree.HasValue);
}
