public async Task <Stream> OpenReadAsync(string fullPath, CancellationToken cancellationToken = default)
{
GenericValidation.CheckBlobFullPath(fullPath);
fullPath = StoragePath.Normalize(fullPath, false);
GetObjectResponse response = await GetObjectAsync(fullPath).ConfigureAwait(false);
if (response == null)
{
return(null);
}
return(new FixedStream(response.ResponseStream, length: response.ContentLength, (Action <FixedStream>)null));
}
private Stream CreateStream(string fullPath, bool overwrite = true)
{
GenericValidation.CheckBlobFullPath(fullPath);
if (!Directory.Exists(_directoryFullName))
{
Directory.CreateDirectory(_directoryFullName);
}
string path = GetFilePath(fullPath);
Stream s = overwrite ? File.Create(path) : File.OpenWrite(path);
s.Seek(0, SeekOrigin.End);
return(s);
}
/// <summary>
/// S3 doesnt support this natively and will cache everything in MemoryStream until disposed.
/// </summary>
public async Task WriteAsync(string fullPath, Stream dataStream, bool append = false,
CancellationToken cancellationToken = default)
{
if (append)
{
throw new NotSupportedException();
}
GenericValidation.CheckBlobFullPath(fullPath);
fullPath = StoragePath.Normalize(fullPath, false);
//http://docs.aws.amazon.com/AmazonS3/latest/dev/HLuploadFileDotNet.html
await _fileTransferUtility.UploadAsync(dataStream, _bucketName, fullPath, cancellationToken).ConfigureAwait(false);
}
public async Task <Stream> OpenReadAsync(string id, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobId(id);
id = StoragePath.Normalize(id, false);
GetObjectResponse response = await GetObjectAsync(id);
if (response == null)
{
return(null);
}
return(new FixedStream(response.ResponseStream, length: response.ContentLength));
}
public async Task WriteAsync(string id, Stream sourceStream, bool append, CancellationToken cancellationToken)
{
if (append)
{
throw new NotSupportedException();
}
GenericValidation.CheckBlobId(id);
GenericValidation.CheckSourceStream(sourceStream);
//http://docs.aws.amazon.com/AmazonS3/latest/dev/HLuploadFileDotNet.html
id = StoragePath.Normalize(id, false);
await _fileTransferUtility.UploadAsync(sourceStream, _bucketName, id, cancellationToken);
}
/// <summary>
/// Get native Azure blob absolute URI by blob ID
/// </summary>
/// <param name="id">Blob ID</param>
/// <returns>URI of the blob or null if blob doesn't exist</returns>
public async Task <Uri> GetNativeBlobUriAsync(string id)
{
GenericValidation.CheckBlobId(id);
CloudBlockBlob blob = _blobContainer.GetBlockBlobReference(StoragePath.Normalize(id, false));
bool exists = await blob.ExistsAsync();
if (!exists)
{
return(null);
}
return(blob.Uri);
}
public async Task WriteAsync(string fullPath, Stream dataStream, bool append, CancellationToken cancellationToken)
{
if (dataStream is null)
{
throw new ArgumentNullException(nameof(dataStream));
}
GenericValidation.CheckBlobFullPath(fullPath);
fullPath = StoragePath.Normalize(fullPath, false);
using (Stream stream = CreateStream(fullPath, !append))
{
await dataStream.CopyToAsync(stream).ConfigureAwait(false);
}
}
public async Task <IEnumerable <bool> > ExistsAsync(IEnumerable <string> ids, CancellationToken cancellationToken)
{
var result = new List <bool>();
foreach (string id in ids)
{
GenericValidation.CheckBlobId(id);
CloudBlockBlob blob = _blobContainer.GetBlockBlobReference(StoragePath.Normalize(id, false));
bool exists = await blob.ExistsAsync();
result.Add(exists);
}
return(result);
}
public async Task <Stream> OpenReadAsync(string id, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobId(id);
DataLakeStoreFileSystemManagementClient client = await GetFsClient();
try
{
return(await client.FileSystem.OpenAsync(_accountName, id));
}
catch (CloudException ex) when(ex.Response.StatusCode == HttpStatusCode.NotFound)
{
throw new StorageException(ErrorCode.NotFound, ex);
}
}
public async Task <AccessControl> GetAccessControlAsync(string fullPath, bool getUpn)
{
GenericValidation.CheckBlobFullPath(fullPath);
DecomposePath(fullPath, out string fs, out string rp);
ApiResponse <string> response = await _restApi.GetPathPropertiesAsync(fs, rp, "getAccessControl", upn : getUpn).ConfigureAwait(false);
await response.EnsureSuccessStatusCodeAsync().ConfigureAwait(false);
return(new AccessControl(
response.GetHeader("x-ms-owner"),
response.GetHeader("x-ms-group"),
response.GetHeader("x-ms-permissions"),
response.GetHeader("x-ms-acl")));
}
private async Task <(CloudBlobContainer, string)> GetPartsAsync(string path, bool createContainer = true)
{
GenericValidation.CheckBlobId(path);
path = StoragePath.Normalize(path);
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (_fixedContainer != null)
{
return(_fixedContainer, path);
}
if (_fixedContainerName != null)
{
CloudBlobContainer fxc = _client.GetContainerReference(_fixedContainerName);
await fxc.CreateIfNotExistsAsync();
return(fxc, path);
}
int idx = path.IndexOf(StoragePath.PathSeparator);
if (idx == -1)
{
throw new ArgumentException("blob path must contain container name", nameof(path));
}
string containerName = path.Substring(0, idx);
string relativePath = path.Substring(idx + 1);
if (!_containerNameToContainer.TryGetValue(containerName, out CloudBlobContainer container))
{
if (!createContainer)
{
return(null, null);
}
container = _client.GetContainerReference(containerName);
await container.CreateIfNotExistsAsync();
_containerNameToContainer[containerName] = container;
}
return(container, relativePath);
}
private async Task DeleteAsync(string fullPath, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobFullPath(fullPath);
var info = new PathInformation(fullPath);
Properties properties = await Client.GetPropertiesAsync(info.Filesystem, info.Path, cancellationToken);
if (properties.IsDirectory)
{
await Client.DeleteDirectoryAsync(info.Filesystem, info.Path, true, cancellationToken);
return;
}
await Client.DeleteFileAsync(info.Filesystem, info.Path, cancellationToken);
}
public async Task DeleteAsync(IEnumerable <string> ids, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobId(ids);
using (ServiceFabricTransaction tx = GetTransaction())
{
IReliableDictionary <string, byte[]> coll = await OpenCollectionAsync();
foreach (string id in ids)
{
await coll.TryRemoveAsync(tx.Tx, ToId(id));
}
await tx.CommitAsync();
}
}
public Task<Stream> OpenWriteAsync(string fullPath, bool append, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobFullPath(fullPath);
ValidateSecretName(fullPath);
if (append) throw new ArgumentException("appending to secrets is not supported", nameof(append));
var callbackStream = new FixedStream(new MemoryStream(), null, async fx =>
{
string value = Encoding.UTF8.GetString(((MemoryStream)fx.Parent).ToArray());
await _vaultClient.SetSecretAsync(_vaultUri, fullPath, value).ConfigureAwait(false);
});
return Task.FromResult<Stream>(callbackStream);
}
public async Task DeleteAsync(IEnumerable <string> fullPaths, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobFullPaths(fullPaths);
using (ServiceFabricTransaction tx = GetTransaction())
{
IReliableDictionary <string, byte[]> coll = await OpenCollectionAsync().ConfigureAwait(false);
foreach (string fullPath in fullPaths)
{
await coll.TryRemoveAsync(tx.Tx, ToFullPath(fullPath)).ConfigureAwait(false);
}
await tx.CommitAsync().ConfigureAwait(false);
}
}
private async Task <bool> ExistsAsync(string fullPath)
{
GenericValidation.CheckBlobFullPath(fullPath);
fullPath = NormaliseSecretName(fullPath);
try
{
await _client.GetSecretAsync(fullPath).ConfigureAwait(false);
}
catch (RequestFailedException ex) when(ex.Status == 404)
{
return(false);
}
return(true);
}
private async Task <bool> ExistsAsync(AmazonS3Client client, string fullPath, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobFullPath(fullPath);
try
{
fullPath = StoragePath.Normalize(fullPath, true);
await client.GetObjectMetadataAsync(_bucketName, fullPath, cancellationToken).ConfigureAwait(false);
return(true);
}
catch (AmazonS3Exception ex) when(ex.StatusCode == HttpStatusCode.NotFound)
{
}
return(false);
}
public async Task <IReadOnlyCollection <bool> > ExistsAsync(IEnumerable <string> fullPaths, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobFullPaths(fullPaths);
AdlsClient client = await GetAdlsClientAsync().ConfigureAwait(false);
var result = new List <bool>();
foreach (string fullPath in fullPaths)
{
bool exists = client.CheckExists(fullPath);
result.Add(exists);
}
return(result);
}
public async Task <Stream> OpenReadAsync(string fullPath, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobFullPath(fullPath);
AdlsClient client = await GetAdlsClientAsync().ConfigureAwait(false);
try
{
AdlsInputStream response = await client.GetReadStreamAsync(fullPath, cancellationToken).ConfigureAwait(false);
return(response);
}
catch (AdlsException ex) when(ex.HttpStatus == HttpStatusCode.NotFound)
{
return(null);
}
}
/// <summary>
/// Checks if files exist on disk
/// </summary>
public Task <IReadOnlyCollection <bool> > ExistsAsync(IEnumerable <string> ids, CancellationToken cancellationToken)
{
var result = new List <bool>();
if (ids != null)
{
GenericValidation.CheckBlobId(ids);
foreach (string id in ids)
{
bool exists = File.Exists(GetFilePath(StoragePath.Normalize(id, false)));
result.Add(exists);
}
}
return(Task.FromResult((IReadOnlyCollection <bool>)result));
}
public VendaItem(Produto produto, decimal valorUnitario, int quantidade)
{
/* Produto */
GenericValidation.ObjectNotNull(produto, EXCEPTION_MESSAGE_VENDA_ITEM_PRODUTO_REQUIRED);
/* Valor unitário */
GenericValidation.ObjectNotNull(valorUnitario, EXCEPTION_MESSAGE_VENDA_ITEM_VALOR_UNITARIO_REQUIRED);
GenericValidation.DecimalMinValue(valorUnitario, (decimal)0.01, EXCEPTION_MESSAGE_VENDA_ITEM_VALOR_UNITARIO_MIN_VALUE);
/* Quantidade */
GenericValidation.ObjectNotNull(quantidade, EXCEPTION_MESSAGE_VENDA_ITEM_QUANTIDADE_REQUIRED);
GenericValidation.IntMinValue(quantidade, 1, EXCEPTION_MESSAGE_VENDA_ITEM_QUANTIDADE_MIN_VALUE);
Produto = produto;
ValorUnitario = valorUnitario;
Quantidade = quantidade;
}
/// <summary>
/// Returns the list of blob names in this storage, optionally filtered by prefix
/// </summary>
public Task <IReadOnlyCollection <Blob> > ListAsync(ListOptions options, CancellationToken cancellationToken)
{
if (options == null)
{
options = new ListOptions();
}
GenericValidation.CheckBlobPrefix(options.FilePrefix);
if (!Directory.Exists(_directoryFullName))
{
return(Task.FromResult <IReadOnlyCollection <Blob> >(new List <Blob>()));
}
string fullPath = GetFolder(options?.FolderPath, false);
if (fullPath == null)
{
return(Task.FromResult <IReadOnlyCollection <Blob> >(new List <Blob>()));
}
string[] fileIds = Directory.GetFiles(
fullPath,
string.IsNullOrEmpty(options.FilePrefix)
? "*"
: options.FilePrefix + "*",
options.Recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
string[] directoryIds = Directory.GetDirectories(
fullPath,
string.IsNullOrEmpty(options.FilePrefix)
? "*"
: options.FilePrefix + "*",
options.Recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
var result = new List <Blob>();
result.AddRange(directoryIds.Select(id => ToBlobItem(id, BlobItemKind.Folder, options.IncludeAttributes)));
result.AddRange(
fileIds.Where(fid => !fid.EndsWith(AttributesFileExtension)).Select(id => ToBlobItem(id, BlobItemKind.File, options.IncludeAttributes)));
result = result
.Where(i => options.BrowseFilter == null || options.BrowseFilter(i))
.Take(options.MaxResults == null ? int.MaxValue : options.MaxResults.Value)
.ToList();
return(Task.FromResult <IReadOnlyCollection <Blob> >(result));
}
private async Task <Blob?> GetBlobAsync(string fullPath)
{
GenericValidation.CheckBlobFullPath(fullPath);
fullPath = StoragePath.Normalize(fullPath);
AmazonS3Client amazonS3Client = await this.GetClientAsync().ConfigureAwait(false);
try
{
return((await amazonS3Client.GetObjectMetadataAsync(this._bucketName, fullPath)
.ConfigureAwait(false)).ToBlob(fullPath));
}
catch (AmazonS3Exception ex) when(ex.StatusCode == HttpStatusCode.NotFound)
{
}
return(null);
}
public async Task <Stream> OpenReadAsync(string id, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobId(id);
AdlsClient client = await GetAdlsClient();
try
{
AdlsInputStream response = await client.GetReadStreamAsync(id, cancellationToken);
return(response);
}
catch (AdlsException ex) when(ex.HttpStatus == HttpStatusCode.NotFound)
{
return(null);
}
}
public Task WriteAsync(string fullPath, Stream dataStream, bool append, CancellationToken cancellationToken)
{
if (dataStream is null)
{
throw new ArgumentNullException(nameof(dataStream));
}
GenericValidation.CheckBlobFullPath(fullPath);
fullPath = StoragePath.Normalize(fullPath);
using (Stream stream = CreateStream(fullPath, !append))
{
dataStream.CopyTo(stream);
}
return(Task.FromResult(true));
}
public async Task <IReadOnlyCollection <bool> > ExistsAsync(IEnumerable <string> ids, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobId(ids);
AdlsClient client = await GetAdlsClient();
var result = new List <bool>();
foreach (string id in ids)
{
bool exists = client.CheckExists(id);
result.Add(exists);
}
return(result);
}
/// <summary>
/// Gets file metadata
/// </summary>
public Task <IEnumerable <BlobMeta> > GetMetaAsync(IEnumerable <string> ids, CancellationToken cancellationToken)
{
if (ids == null)
{
return(null);
}
GenericValidation.CheckBlobId(ids);
var result = new List <BlobMeta>();
foreach (string id in ids)
{
result.Add(BlobMetaFromId(id));
}
return(Task.FromResult((IEnumerable <BlobMeta>)result));
}
protected override async Task <bool> ExistsAsync(string fullPath, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobFullPath(fullPath);
try
{
await _client.GetObjectAsync(
_bucketName, NormalisePath(fullPath),
null,
cancellationToken).ConfigureAwait(false);
return(true);
}
catch (GoogleApiException ex) when(ex.HttpStatusCode == HttpStatusCode.NotFound)
{
return(false);
}
}
public Task <Stream> OpenWriteAsync(string id, bool append, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobId(id);
ValidateSecretName(id);
if (append)
{
throw new ArgumentException("appending to secrets is not supported", nameof(append));
}
var callbackStream = new FixedStream(new MemoryStream(), null, fx =>
{
string value = Encoding.UTF8.GetString(((MemoryStream)fx.Parent).ToArray());
_vaultClient.SetSecretAsync(_vaultUri, id, value).Wait();
});
return(Task.FromResult <Stream>(callbackStream));
}
public async Task <Stream> OpenReadAsync(string fullPath, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobFullPath(fullPath);
fullPath = NormaliseSecretName(fullPath);
try
{
Response <KeyVaultSecret> secret = await _client.GetSecretAsync(fullPath, cancellationToken : cancellationToken).ConfigureAwait(false);
string value = secret.Value.Value;
return(value.ToMemoryStream());
}
catch (RequestFailedException ex) when(ex.Status == 404)
{
return(null);
}
}
