private async Task <IFile> CreateFileAsync(AdapterHolder adapterHolder, string key, CancellationToken cancellationToken)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
var file =
await FileRegister.GetOrDefaultAsync(adapterHolder.Scheme, key, cancellationToken);
if (file != null)
{
return(file);
}
var adapter = await adapterHolder.GetAdapterAsync();
if (adapter is IFileFactory fileFactory)
{
file = await fileFactory.CreateFileAsync(key, this, cancellationToken);
}
else
{
file = new File(adapterHolder.Scheme, key, this);
}
await FileRegister.StoreAsync(adapterHolder.Scheme, key, file, cancellationToken);
return(file);
}
private Task WriteAsync(AdapterHolder adapterHolder, string key, byte[] bytes, bool overwrite, CancellationToken cancellationToken)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(WriteAsyncImpl());
async Task WriteAsyncImpl()
{
if (!overwrite)
{
var exists = await ExistsAsync(adapterHolder, key, cancellationToken);
if (exists)
{
throw new FileAlreadyExistsException(key); //TODO Message
}
}
var adapter = await adapterHolder.GetAdapterAsync();
await adapter.WriteAsync(key, bytes, overwrite, cancellationToken);
}
}
private Task <byte[]> ReadAllBytesAsync(AdapterHolder adapterHolder, string key, CancellationToken cancellationToken)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(AdapterReadAllBytesAsync());
async Task <byte[]> AdapterReadAllBytesAsync()
{
await ThrowIfNotExistsAsync(adapterHolder, key, cancellationToken);
var adapter = await adapterHolder.GetAdapterAsync();
var content = await adapter.ReadAllBytesAsync(key, cancellationToken);
if (content == null)
{
throw new IOException($"Could not read the '{key} key content'");
}
return(content);
}
}
private Task ReadToStreamAsync(AdapterHolder adapterHolder, string key, Stream toStream, CancellationToken cancellationToken)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(ReadAllBytesAndCreateStreamAsync());
async Task ReadAllBytesAndCreateStreamAsync()
{
var adapter = await adapterHolder.GetAdapterAsync();
if (adapter is IStreamFactory streamFactory)
{
await streamFactory.ReadToStreamAsync(key, toStream, cancellationToken);
}
else
{
var bytes = await ReadAllBytesAsync(adapter, key, cancellationToken);
using (var memoryBytes = new MemoryStream(bytes))
await memoryBytes.CopyToAsync(toStream, cancellationToken);
}
}
}
private Task <string> GetChecksumAsync(AdapterHolder adapterHolder, string key, CancellationToken cancellationToken)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(GetChecksumAsyncImpl());
async Task <string> GetChecksumAsyncImpl()
{
var adapter = await adapterHolder.GetAdapterAsync();
await ThrowIfNotExistsAsync(adapter, key, cancellationToken);
if (adapter is IChecksumCalculator checksumCalculator)
{
return(await checksumCalculator.GetChecksumAsync(key, cancellationToken));
}
var bytes = await ReadAllBytesAsync(adapter, key, cancellationToken);
return(ChecksumHelper.FromContent(bytes));
}
}
private Task <long> GetSizeAsync(AdapterHolder adapterHolder, string key, CancellationToken cancellationToken)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(ReadAllBytesAndGetLengthAsync());
async Task <long> ReadAllBytesAndGetLengthAsync()
{
var adapter = await adapterHolder.GetAdapterAsync();
await ThrowIfNotExistsAsync(adapter, key, cancellationToken);
if (adapter is ISizeCalculator sizeCalculator)
{
return(await sizeCalculator.GetSizeAsync(key, cancellationToken));
}
var bytes = await ReadAllBytesAsync(adapter, key, cancellationToken);
return(bytes.LongLength);
}
}
private async Task ThrowIfNotExistsAsync(AdapterHolder adapterHolder, string key, CancellationToken cancellationToken)
{
var exists = await ExistsAsync(adapterHolder, key, cancellationToken);
if (!exists)
{
var adapter = await adapterHolder.GetAdapterAsync();
throw new FileNotFoundException($"FileSystem '{adapter.Scheme.Name}' could not find a file with key '{key}'", key);
}
}
private Task <bool> ExistsAsync(AdapterHolder adapterHolder, string key, CancellationToken cancellationToken)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(ExistsAsyncImpl());
async Task <bool> ExistsAsyncImpl()
{
var adapter = await adapterHolder.GetAdapterAsync();
var exists = await adapter.ExistsAsync(key, cancellationToken);
return(exists);
}
}
private Task <IFile> GetAsync(AdapterHolder adapterHolder, string key, bool create, CancellationToken cancellationToken)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(GetFileOrCreateOrThrowAsync());
async Task <IFile> GetFileOrCreateOrThrowAsync()
{
if (!create)
{
await ThrowIfNotExistsAsync(adapterHolder, key, cancellationToken);
}
return(await CreateFileAsync(adapterHolder, key, cancellationToken));
}
}
private Task RenameAsync(AdapterHolder sourceAdapterHolder, string sourceKey, AdapterHolder targetAdapterHolder, string targetKey, CancellationToken cancellationToken)
{
if (sourceKey == null)
{
throw new ArgumentNullException(nameof(sourceKey));
}
if (targetKey == null)
{
throw new ArgumentNullException(nameof(targetKey));
}
return(CheckTargetExistenceAndRenameAsync());
async Task CheckTargetExistenceAndRenameAsync()
{
await ThrowIfNotExistsAsync(sourceAdapterHolder, sourceKey, cancellationToken);
var exists = await ExistsAsync(targetAdapterHolder, targetKey, cancellationToken);
if (exists)
{
throw new UnexpectedFileException(targetKey); //TODO Message
}
var adapter = await targetAdapterHolder.GetAdapterAsync();
var renamedSuccess = await adapter.RenameAsync(sourceKey, targetKey, cancellationToken);
if (!renamedSuccess)
{
throw new IOException($"Could not rename the '{sourceKey}' key to '{targetKey}'");
}
var sourceFile =
await FileRegister.GetOrDefaultAsync(sourceAdapterHolder.Scheme, sourceKey, cancellationToken);
if (sourceFile != null)
{
await FileRegister.StoreAsync(targetAdapterHolder.Scheme, targetKey, sourceFile, cancellationToken);
await FileRegister.RemoveAsync(sourceAdapterHolder.Scheme, sourceKey, cancellationToken);
}
}
}
private Task DeleteAsync(AdapterHolder adapterHolder, string key, CancellationToken cancellationToken)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(AdapterDeleteAndRemoveFromFileRegisterAsync());
async Task AdapterDeleteAndRemoveFromFileRegisterAsync()
{
var adapter = await adapterHolder.GetAdapterAsync();
await ThrowIfNotExistsAsync(adapter, key, cancellationToken);
await adapter.DeleteAsync(key, cancellationToken);
await FileRegister.RemoveAsync(adapterHolder.Scheme, key, cancellationToken);
}
}
private Task <DateTime> GetLastModificationDateAsync(AdapterHolder adapterHolder, string key, CancellationToken cancellationToken)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(GetLastModificationDateAsyncImpl());
async Task <DateTime> GetLastModificationDateAsyncImpl()
{
var adapter = await adapterHolder.GetAdapterAsync();
await ThrowIfNotExistsAsync(adapter, key, cancellationToken);
var date = await adapter.GetLastModificationDateAsync(key, cancellationToken);
return(date);
}
}
private Task <string> GetMimeTypeAsync(AdapterHolder adapterHolder, string key, CancellationToken cancellationToken)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(GetMimeTypeAsyncImpl());
async Task <string> GetMimeTypeAsyncImpl()
{
var adapter = await adapterHolder.GetAdapterAsync();
await ThrowIfNotExistsAsync(adapter, key, cancellationToken);
if (adapter is IMimeTypeProvider mimeTypeProvider)
{
return(await mimeTypeProvider.GetMimeTypeAsync(key, cancellationToken));
}
throw new InvalidOperationException($"FileSystem Adapter '{adapter.GetType().Name}' cannot provide MIME type");
}
}
private async Task <ListKeysResult> ListKeysAsync(AdapterHolder adapterHolder, string prefix, CancellationToken cancellationToken)
{
var adapter = await adapterHolder.GetAdapterAsync();
if (adapter is IListKeysAware listKeysAware)
{
return(await listKeysAware.ListKeysAsync(prefix, cancellationToken));
}
var result = new ListKeysResult();
var checkPrefix = !string.IsNullOrWhiteSpace(prefix);
var keys = await GetKeysAsync(adapter, cancellationToken);
foreach (var key in keys)
{
cancellationToken.ThrowIfCancellationRequested();
if (!checkPrefix || key.StartsWith(prefix))
{
var isDirectory = await adapter.IsDirectoryAsync(key, cancellationToken);
if (isDirectory)
{
result.Directories.Add(key);
}
else
{
result.Keys.Add(key);
}
}
}
return(result);
}
private async Task <List <string> > GetKeysAsync(AdapterHolder adapterHolder, CancellationToken cancellationToken)
{
var adapter = await adapterHolder.GetAdapterAsync();
return(await adapter.GetKeysAsync(cancellationToken));
}
