public virtual async Task <IReadOnlyList <WriteResult <Sha1> > > WriteObjectsAsync(IEnumerable <IChasmBlob> blobs, bool forceOverwrite, ChasmRequestContext requestContext = default, CancellationToken cancellationToken = default)
{
if (blobs == null || !blobs.Any())
{
return(Array.Empty <WriteResult <Sha1> >());
}
requestContext = ChasmRequestContext.Ensure(requestContext);
var tasks = new List <Task <WriteResult <Sha1> > >();
foreach (IChasmBlob blob in blobs)
{
// Concurrency: instantiate tasks without await
Task <WriteResult <Sha1> > task = WriteObjectAsync(blob.Content, blob.Metadata, forceOverwrite, requestContext, cancellationToken);
tasks.Add(task);
}
// Await the tasks
var list = new WriteResult <Sha1> [tasks.Count];
for (var i = 0; i < tasks.Count; i++)
{
list[i] = await tasks[i]
.ConfigureAwait(false);
}
return(list);
}
public virtual async ValueTask <TreeNodeMap?> ReadTreeAsync(TreeId treeId, ChasmRequestContext requestContext = default, CancellationToken cancellationToken = default)
{
requestContext = ChasmRequestContext.Ensure(requestContext);
// Read bytes
IChasmBlob blob = await ReadObjectAsync(treeId.Sha1, requestContext, cancellationToken)
.ConfigureAwait(false);
if (blob == null || blob.Content.IsEmpty)
{
return(default);
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 static ChasmRequestContext Ensure(ChasmRequestContext requestContext)
{
if (requestContext == null)
{
return new ChasmRequestContext {
CorrelationId = $"{Guid.NewGuid():D}"
}
}
;
if (string.IsNullOrWhiteSpace(requestContext.CorrelationId))
{
requestContext.CorrelationId = $"{Guid.NewGuid():D}";
}
return(requestContext);
}
}
public virtual async Task <IReadOnlyDictionary <Sha1, IChasmBlob> > ReadObjectBatchAsync(IEnumerable <Sha1> objectIds, ChasmRequestContext requestContext = default, CancellationToken cancellationToken = default)
{
if (objectIds == null)
{
return(EmptyDictionary.Empty <Sha1, IChasmBlob>());
}
requestContext = ChasmRequestContext.Ensure(requestContext);
// Enumerate
var dict = new Dictionary <Sha1, Task <IChasmBlob> >(Sha1Comparer.Default);
foreach (Sha1 objectId in objectIds)
{
dict[objectId] = ReadObjectAsync(objectId, requestContext, cancellationToken);
}
// Await
await Task.WhenAll(dict.Values)
.ConfigureAwait(false);
// Return
var dict2 = new Dictionary <Sha1, IChasmBlob>(Sha1Comparer.Default);
foreach (KeyValuePair <Sha1, Task <IChasmBlob> > task in dict)
{
if (task.Value == null || task.Value.Result == null)
{
continue;
}
dict2[task.Key] = task.Value.Result;
}
return(dict2);
}
public abstract Task <WriteResult <Sha1> > WriteObjectAsync(Func <Stream, ValueTask> beforeHash, ChasmMetadata metadata, bool forceOverwrite, ChasmRequestContext requestContext = default, CancellationToken cancellationToken = default);
public abstract Task <WriteResult <Sha1> > WriteObjectAsync(ReadOnlyMemory <byte> buffer, ChasmMetadata metadata, bool forceOverwrite, ChasmRequestContext requestContext = default, CancellationToken cancellationToken = default);
public abstract Task <IChasmStream> ReadStreamAsync(Sha1 objectId, ChasmRequestContext requestContext = default, CancellationToken cancellationToken = default);
public abstract Task <bool> ExistsAsync(Sha1 objectId, ChasmRequestContext requestContext = default, CancellationToken cancellationToken = default);
protected static ChasmConcurrencyException BuildConcurrencyException(string name, string branch, Exception innerException, ChasmRequestContext chasmContext)
=> new ChasmConcurrencyException($"Concurrent write detected on {name}/{branch} ({chasmContext?.CorrelationId})", innerException);
