private async Task StartAsyncCopy(long taskId, CloudFile destFile, Func <bool> checkOverwrite, Func <Task <string> > startCopy)
{
bool destExist = true;
try
{
await destFile.FetchAttributesAsync(null, this.RequestOptions, this.OperationContext, this.CmdletCancellationToken).ConfigureAwait(false);
//Clean the Metadata of the destination file object, or the source metadata won't overwirte the dest file metadata. See https://docs.microsoft.com/en-us/rest/api/storageservices/copy-file
destFile.Metadata.Clear();
}
catch (StorageException ex)
{
if (!ex.IsNotFoundException())
{
throw;
}
destExist = false;
}
if (!destExist || checkOverwrite())
{
string copyId = await startCopy().ConfigureAwait(false);
this.OutputStream.WriteVerbose(taskId, String.Format(Resources.CopyDestinationBlobPending, destFile.GetFullPath(), destFile.Share.Name, copyId));
this.OutputStream.WriteObject(taskId, destFile);
}
}
private async Task StartAsyncCopy(long taskId, CloudFile destFile, Func <bool> checkOverwrite, Func <Task <string> > startCopy)
{
bool destExist = true;
try
{
await destFile.FetchAttributesAsync(null, this.RequestOptions, this.OperationContext, this.CmdletCancellationToken);
}
catch (StorageException ex)
{
if (!ex.IsNotFoundException())
{
throw;
}
destExist = false;
}
if (!destExist || checkOverwrite())
{
string copyId = await startCopy();
this.OutputStream.WriteVerbose(taskId, String.Format(Resources.CopyDestinationBlobPending, destFile.GetFullPath(), destFile.Share.Name, copyId));
this.OutputStream.WriteObject(taskId, destFile);
}
}
public override async Task CopyToLocationAsync(string destination, bool overwrite = false)
{
IStorageItem item = destination.CreateItem(Configuration);
using (Stream source = OpenRead())
{
await _file.FetchAttributesAsync();
using (Stream dest = item.OpenWrite(overwrite, _file.Properties.Length))
{
await source.CopyToAsync(dest);
await dest.FlushAsync();
}
}
}
/// <inheritdoc />
public async Task <IEnumerable <byte> > DownloadFileAsync(
string absolutePath,
CancellationToken cancellationToken)
{
byte[] toReturn = null;
Uri uri = new Uri(absolutePath, UriKind.Absolute);
CloudFile cloudFile = new CloudFile(uri, this.sourceStorageCredentials);
await cloudFile.FetchAttributesAsync().ConfigureAwait(false);
toReturn = new byte[cloudFile.Properties.Length];
this.loggerWrapper.Debug(
$"Downloading \"{absolutePath}\" ({toReturn.Length} " +
$"byte(s))...");
await cloudFile.DownloadToByteArrayAsync(toReturn, 0)
.ConfigureAwait(false);
this.loggerWrapper.Info(
$"Downloaded \"{absolutePath}\" ({toReturn.Length} byte(s)).");
return(toReturn);
}
public async Task <IDriveItem> GetItemByFileIdAysnc(string path)
{
var file = new CloudFile(new Uri(path), fileShare.ServiceClient.Credentials);
if (await file.ExistsAsync())
{
await file.FetchAttributesAsync();
return(new DriveFile(file.Uri.ToString(), file.Name, Root, DriveType, file.Properties.Length));
}
var dir = new CloudFileDirectory(new Uri(path), fileShare.ServiceClient.Credentials);
if (await dir.ExistsAsync())
{
return(new DriveFolder(dir.Uri.ToString(), dir.Name, Root, DriveType));
}
return(null);
//var split = new Queue<string>(path.Split(new[] { Delimiter }, StringSplitOptions.RemoveEmptyEntries));
//var folder = this._fileShare.GetRootDirectoryReference();
//while (split.Count > 1)
//{
// var current = split.Dequeue();
// folder = folder.GetDirectoryReference(current);
//}
//var name = split.Dequeue();
//var file = folder.GetFileReference(name);
//if (file.Exists())
//{
// await file.FetchAttributesAsync();
// return new DriveFile(file.Uri.ToString(), file.Name, Root, DriveType, file.Properties.Length);
//}
//var dir = folder.GetDirectoryReference(name);
//if (dir.Exists())
//{
// return new DriveFolder(dir.Uri.ToString(), dir.Name, Root, DriveType);
//}
//return null;
}
protected override async Task <Blob> GetBlobAsync(string fullPath, CancellationToken cancellationToken)
{
CloudFile file = await GetFileReferenceAsync(fullPath, false, cancellationToken).ConfigureAwait(false);
try
{
await file.FetchAttributesAsync(cancellationToken).ConfigureAwait(false);
return(AzConvert.ToBlob(StoragePath.GetParent(fullPath), file));
}
catch (AzStorageException ex) when(ex.RequestInformation.ErrorCode == "ShareNotFound")
{
return(null);
}
catch (AzStorageException ex) when(ex.RequestInformation.ErrorCode == "ResourceNotFound")
{
return(null);
}
}
/// <summary>
/// Reads the BLOB storing with the given key.
/// </summary>
/// <param name="key">The key.</param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public byte[] ReadBlob(string key)
{
CloudFile cloudFile = GetCloudFileFromKey(key);
try
{
if (!cloudFile.ExistsAsync().Result)
{
return(null);
}
cloudFile.FetchAttributesAsync().Wait();
byte[] content = new byte[cloudFile.Properties.Length];
cloudFile.DownloadToByteArrayAsync(content, 0).Wait();
return(content);
}
catch (Exception ex)
{
throw new LendsumException(S.Invariant($"The filename {key} cannot be read in {config.AzureSharedReference} "), ex);
}
}
/// <inheritdoc />
public byte[] ReadAllBytes(string fileName, string[] path)
{
#region validation
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException(nameof(fileName));
}
#endregion
CloudFileDirectory cloudFileDirectory = CloudFileShare.GetDirectoryReference(path: path);
CloudFile cloudFile = cloudFileDirectory.GetFileReference(fileName);
TaskUtilities.ExecuteSync(cloudFile.FetchAttributesAsync());
var cloudFileBytes = new byte[cloudFile.Properties.Length];
TaskUtilities.ExecuteSync(cloudFile.DownloadToByteArrayAsync(cloudFileBytes, 0));
return(cloudFileBytes);
}
/// <summary>
/// Manage file metadata
/// </summary>
/// <param name="cloudFileClient"></param>
/// <returns></returns>
private static async Task FileMetadataSample(CloudFileClient cloudFileClient)
{
Console.WriteLine();
// Create the share name -- use a guid in the name so it's unique.
string shareName = "demotest-" + Guid.NewGuid();
CloudFileShare share = cloudFileClient.GetShareReference(shareName);
try
{
// Create share
Console.WriteLine("Create Share");
await share.CreateIfNotExistsAsync();
// Create directory
Console.WriteLine("Create directory");
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
await rootDirectory.CreateIfNotExistsAsync();
CloudFile file = rootDirectory.GetFileReference("demofile");
// Set file metadata
Console.WriteLine("Set file metadata");
file.Metadata.Add("key1", "value1");
file.Metadata.Add("key2", "value2");
// Create file
Console.WriteLine("Create file");
await file.CreateAsync(1000);
// Fetch file attributes
// in this case this call is not need but is included for demo purposes
await file.FetchAttributesAsync();
Console.WriteLine("Get file metadata:");
foreach (var keyValue in file.Metadata)
{
Console.WriteLine(" {0}: {1}", keyValue.Key, keyValue.Value);
}
Console.WriteLine();
}
catch (StorageException exStorage)
{
Common.WriteException(exStorage);
Console.WriteLine(
"Please make sure your storage account is specified correctly in the app.config - then restart the sample.");
Console.WriteLine("Press any key to exit");
Console.ReadLine();
throw;
}
catch (Exception ex)
{
Console.WriteLine(" Exception thrown creating share.");
Common.WriteException(ex);
throw;
}
finally
{
// Delete share
Console.WriteLine("Delete share");
share.DeleteIfExists();
}
}
/// <summary>
/// Manage file properties
/// </summary>
/// <param name="cloudFileClient"></param>
/// <returns></returns>
private static async Task FilePropertiesSample(CloudFileClient cloudFileClient)
{
Console.WriteLine();
// Create the share name -- use a guid in the name so it's unique.
string shareName = "demotest-" + Guid.NewGuid();
CloudFileShare share = cloudFileClient.GetShareReference(shareName);
try
{
// Create share
Console.WriteLine("Create Share");
await share.CreateIfNotExistsAsync();
// Create directory
Console.WriteLine("Create directory");
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
await rootDirectory.CreateIfNotExistsAsync();
CloudFile file = rootDirectory.GetFileReference("demofile");
// Set file properties
file.Properties.ContentType = "plain/text";
file.Properties.ContentEncoding = "UTF-8";
file.Properties.ContentLanguage = "en";
// Create file
Console.WriteLine("Create file");
await file.CreateAsync(1000);
// Fetch file attributes
// in this case this call is not need but is included for demo purposes
await file.FetchAttributesAsync();
Console.WriteLine("Get file properties:");
Console.WriteLine(" ETag: {0}", file.Properties.ETag);
Console.WriteLine(" Content type: {0}", file.Properties.ContentType);
Console.WriteLine(" Cache control: {0}", file.Properties.CacheControl);
Console.WriteLine(" Content encoding: {0}", file.Properties.ContentEncoding);
Console.WriteLine(" Content language: {0}", file.Properties.ContentLanguage);
Console.WriteLine(" Content disposition: {0}", file.Properties.ContentDisposition);
Console.WriteLine(" Content MD5: {0}", file.Properties.ContentMD5);
Console.WriteLine(" Length: {0}", file.Properties.Length);
}
catch (StorageException exStorage)
{
Common.WriteException(exStorage);
Console.WriteLine(
"Please make sure your storage account is specified correctly in the app.config - then restart the sample.");
Console.WriteLine("Press any key to exit");
Console.ReadLine();
throw;
}
catch (Exception ex)
{
Console.WriteLine(" Exception thrown creating share.");
Common.WriteException(ex);
throw;
}
finally
{
// Delete share
Console.WriteLine("Delete share");
share.DeleteIfExists();
}
Console.WriteLine();
}
public Task FetchFileAttributesAsync(CloudFile file, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
{
return(file.FetchAttributesAsync(accessCondition, options, operationContext, token));
}
private static async Task CloudBlockBlobCopyFromCloudFileImpl(Func <CloudFile, CloudBlockBlob, string> copyFunc)
{
CloudFileClient fileClient = GenerateCloudFileClient();
string name = GetRandomContainerName();
CloudFileShare share = fileClient.GetShareReference(name);
CloudBlobContainer container = GetRandomContainerReference();
try
{
try
{
await container.CreateAsync();
await share.CreateAsync();
CloudFile source = share.GetRootDirectoryReference().GetFileReference("source");
byte[] data = GetRandomBuffer(1024);
await source.UploadFromByteArrayAsync(data, 0, data.Length);
source.Metadata["Test"] = "value";
source.SetMetadataAsync().Wait();
var sasToken = source.GetSharedAccessSignature(new SharedAccessFilePolicy
{
Permissions = SharedAccessFilePermissions.Read,
SharedAccessExpiryTime = DateTime.UtcNow.AddHours(24)
});
Uri fileSasUri = new Uri(source.StorageUri.PrimaryUri.ToString() + sasToken);
source = new CloudFile(fileSasUri);
CloudBlockBlob copy = container.GetBlockBlobReference("copy");
string copyId = copyFunc(source, copy);
Assert.AreEqual(BlobType.BlockBlob, copy.BlobType);
try
{
await WaitForCopyAsync(copy);
Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, copy.CopyState.TotalBytes);
Assert.AreEqual(data.Length, copy.CopyState.BytesCopied);
Assert.AreEqual(copyId, copy.CopyState.CopyId);
Assert.IsFalse(copy.Properties.IsIncrementalCopy);
Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
}
catch (NullReferenceException)
{
// potential null ref in the WaitForCopyTask and CopyState check implementation
}
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await copy.AbortCopyAsync(copyId, null, null, opContext),
opContext,
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
source.FetchAttributesAsync().Wait();
Assert.IsNotNull(copy.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag);
Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
byte[] copyData = new byte[source.Properties.Length];
await copy.DownloadToByteArrayAsync(copyData, 0);
Assert.IsTrue(data.SequenceEqual(copyData), "Data inside copy of blob not similar");
copy.FetchAttributesAsync().Wait();
BlobProperties prop1 = copy.Properties;
FileProperties prop2 = source.Properties;
Assert.AreEqual(prop1.CacheControl, prop2.CacheControl);
Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding);
Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage);
Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5);
Assert.AreEqual(prop1.ContentType, prop2.ContentType);
Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same");
copy.DeleteIfExistsAsync().Wait();
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
public static void FetchAttributes(this CloudFile file, AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null)
{
file.FetchAttributesAsync(accessCondition, options, operationContext).GetAwaiter().GetResult();
}
