private async Task <bool> CloudFileDirectorySetupAsync(CloudFileShare share)
{
try
{
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
for (int i = 1; i < 3; i++)
{
CloudFileDirectory topDirectory = rootDirectory.GetDirectoryReference("TopDir" + i);
await topDirectory.CreateAsync();
for (int j = 1; j < 3; j++)
{
CloudFileDirectory midDirectory = topDirectory.GetDirectoryReference("MidDir" + j);
await midDirectory.CreateAsync();
for (int k = 1; k < 3; k++)
{
CloudFileDirectory endDirectory = midDirectory.GetDirectoryReference("EndDir" + k);
await endDirectory.CreateAsync();
CloudFile file1 = endDirectory.GetFileReference("EndFile" + k);
await file1.CreateAsync(0);
}
}
CloudFile file2 = topDirectory.GetFileReference("File" + i);
await file2.CreateAsync(0);
}
return(true);
}
catch (Exception e)
{
throw e;
}
}
public void FileSeekTest()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
using (MemoryStream srcStream = new MemoryStream(buffer))
{
file.UploadFromStream(srcStream);
Stream fileStream = file.OpenRead();
fileStream.Seek(2048, 0);
byte[] buff = new byte[100];
int numRead = fileStream.Read(buff, 0, 100);
Assert.AreEqual(numRead, 0);
}
}
finally
{
share.DeleteIfExists();
}
}
/// <summary>
/// Selects the protocol response.
/// </summary>
/// <param name="protocolItem">The protocol item.</param>
/// <returns>The parsed <see cref="IListFileItem"/>.</returns>
private IListFileItem SelectListFileItem(IListFileEntry protocolItem)
{
ListFileEntry file = protocolItem as ListFileEntry;
if (file != null)
{
CloudFile cloudFile = this.GetFileReference(file.Name);
cloudFile.Properties = file.Properties;
cloudFile.attributes = file.Attributes;
return(cloudFile);
}
ListFileDirectoryEntry fileDirectory = protocolItem as ListFileDirectoryEntry;
if (fileDirectory != null)
{
CloudFileDirectory directory = this.GetDirectoryReference(fileDirectory.Name);
directory.Properties = fileDirectory.Properties;
return(directory);
}
throw new InvalidOperationException(SR.InvalidFileListItem);
}
public static void UploadTextTask(CloudFile file, string text, Encoding encoding, AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null)
{
byte[] textAsBytes = encoding.GetBytes(text);
using (MemoryStream stream = new MemoryStream())
{
stream.Write(textAsBytes, 0, textAsBytes.Length);
stream.Seek(0, SeekOrigin.Begin);
file.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2;
try
{
file.UploadFromStreamAsync(stream, accessCondition, options, operationContext).Wait();
}
catch (AggregateException ex)
{
if (ex.InnerException != null)
{
throw ex.InnerException;
}
throw;
}
}
}
public async Task FileWriteStreamBasicTestAsync()
{
byte[] buffer = GetRandomBuffer(6 * 512);
#if NETCORE
MD5 hasher = MD5.Create();
#else
CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash();
#endif
CloudFileShare share = GetRandomShareReference();
share.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2;
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
file.StreamWriteSizeInBytes = 8 * 512;
using (MemoryStream wholeFile = new MemoryStream())
{
FileRequestOptions options = new FileRequestOptions()
{
StoreFileContentMD5 = true,
};
using (CloudFileStream writeStream = await file.OpenWriteAsync(buffer.Length * 3, null, options, null))
{
Stream fileStream = writeStream;
for (int i = 0; i < 3; i++)
{
await fileStream.WriteAsync(buffer, 0, buffer.Length);
await wholeFile.WriteAsync(buffer, 0, buffer.Length);
Assert.AreEqual(wholeFile.Position, fileStream.Position);
#if !NETCORE
hasher.Append(buffer.AsBuffer());
#endif
}
await fileStream.FlushAsync();
}
#if NETCORE
string md5 = Convert.ToBase64String(hasher.ComputeHash(wholeFile.ToArray()));
#else
string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset());
#endif
await file.FetchAttributesAsync();
Assert.AreEqual(md5, file.Properties.ContentMD5);
using (MemoryOutputStream downloadedFile = new MemoryOutputStream())
{
await file.DownloadToStreamAsync(downloadedFile);
TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile.UnderlyingStream);
}
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
async() => await file.OpenWriteAsync(null, null, options, null),
"OpenWrite with StoreFileContentMD5 on an existing file should fail");
using (CloudFileStream writeStream = await file.OpenWriteAsync(null))
{
Stream fileStream = writeStream;
fileStream.Seek(buffer.Length / 2, SeekOrigin.Begin);
wholeFile.Seek(buffer.Length / 2, SeekOrigin.Begin);
for (int i = 0; i < 2; i++)
{
fileStream.Write(buffer, 0, buffer.Length);
wholeFile.Write(buffer, 0, buffer.Length);
Assert.AreEqual(wholeFile.Position, fileStream.Position);
}
await fileStream.FlushAsync();
}
await file.FetchAttributesAsync();
Assert.AreEqual(md5, file.Properties.ContentMD5);
using (MemoryOutputStream downloadedFile = new MemoryOutputStream())
{
options.DisableContentMD5Validation = true;
await file.DownloadToStreamAsync(downloadedFile, null, options, null);
TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile.UnderlyingStream);
}
}
}
finally
{
share.DeleteAsync().Wait();
}
}
public async Task CloudFileClientMaximumExecutionTimeoutShouldNotBeHonoredForStreamsAsync()
{
CloudFileClient fileClient = GenerateCloudFileClient();
CloudFileShare share = fileClient.GetShareReference(Guid.NewGuid().ToString("N"));
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
byte[] buffer = FileTestBase.GetRandomBuffer(1024 * 1024);
try
{
await share.CreateAsync();
fileClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(30);
CloudFile file = rootDirectory.GetFileReference("file");
file.StreamMinimumReadSizeInBytes = 1024 * 1024;
using (CloudFileStream fileStream = await file.OpenWriteAsync(8 * 1024 * 1024))
{
Stream fos = fileStream;
DateTime start = DateTime.Now;
for (int i = 0; i < 7; i++)
{
await fos.WriteAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last write
int msRemaining = (int)(fileClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
await fos.WriteAsync(buffer, 0, buffer.Length);
await fileStream.CommitAsync();
}
using (Stream fileStream = await file.OpenReadAsync())
{
Stream fis = fileStream;
DateTime start = DateTime.Now;
int total = 0;
while (total < 7 * 1024 * 1024)
{
total += await fis.ReadAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last read
int msRemaining = (int)(fileClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
while (true)
{
int count = await fis.ReadAsync(buffer, 0, buffer.Length);
total += count;
if (count == 0)
{
break;
}
}
}
}
finally
{
fileClient.DefaultRequestOptions.MaximumExecutionTime = null;
await share.DeleteAsync();
}
}
public void CloudFileCopyIgnoreReadOnlyAndSetArchiveTest()
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
// Create Source on server
CloudFile source = share.GetRootDirectoryReference().GetFileReference("source");
string data = "String data";
UploadText(source, data, Encoding.UTF8);
// Create Destination on server
CloudFile destination = share.GetRootDirectoryReference().GetFileReference("destination");
destination.Create(1);
destination.Properties.NtfsAttributes = CloudFileNtfsAttributes.Hidden | CloudFileNtfsAttributes.ReadOnly;
destination.SetProperties();
string permission = "O:S-1-5-21-2127521184-1604012920-1887927527-21560751G:S-1-5-21-2127521184-1604012920-1887927527-513D:AI(A;;FA;;;SY)(A;;FA;;;BA)(A;;0x1200a9;;;S-1-5-21-397955417-626881126-188441444-3053964)";
string permissionKey = share.CreateFilePermission(permission);
destination.Properties.FilePermissionKey = permissionKey;
CloudFile copySource = source;
CloudFile copyDestination = destination;
// Start copy and wait for completion
string copyId = copyDestination.StartCopy(TestHelper.Defiddler(copySource),
null,
null,
new FileCopyOptions()
{
PreservePermissions = false,
IgnoreReadOnly = true,
SetArchive = true
},
null,
null);
WaitForCopy(destination);
// Check original file references for equality
Assert.AreEqual(CopyStatus.Success, destination.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, destination.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, destination.CopyState.TotalBytes);
Assert.AreEqual(data.Length, destination.CopyState.BytesCopied);
Assert.AreEqual(copyId, destination.CopyState.CopyId);
Assert.IsTrue(destination.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
TestHelper.ExpectedException(
() => copyDestination.AbortCopy(copyId),
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
source.FetchAttributes();
Assert.IsNotNull(destination.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, destination.Properties.ETag);
Assert.IsTrue(destination.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
string copyData = DownloadText(destination, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of file not equal.");
destination.FetchAttributes();
FileProperties prop1 = destination.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(CloudFileNtfsAttributes.Archive, destination.Properties.NtfsAttributes.Value);
Assert.IsNotNull(destination.Properties.FilePermissionKey);
Assert.IsNull(destination.FilePermission);
destination.Delete();
source.Delete();
}
finally
{
share.DeleteIfExists();
}
}
public void FileReadLockToETagTestAPM()
{
byte[] outBuffer = new byte[1 * 1024 * 1024];
byte[] buffer = GetRandomBuffer(2 * outBuffer.Length);
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
file.StreamMinimumReadSizeInBytes = outBuffer.Length;
using (MemoryStream wholeFile = new MemoryStream(buffer))
{
file.UploadFromStream(wholeFile);
}
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result = file.BeginOpenRead(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
using (Stream fileStream = file.EndOpenRead(result))
{
fileStream.Read(outBuffer, 0, outBuffer.Length);
file.SetMetadata();
TestHelper.ExpectedException(
() => fileStream.Read(outBuffer, 0, outBuffer.Length),
"File read stream should fail if file is modified during read",
HttpStatusCode.PreconditionFailed);
}
result = file.BeginOpenRead(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
using (Stream fileStream = file.EndOpenRead(result))
{
long length = fileStream.Length;
file.SetMetadata();
TestHelper.ExpectedException(
() => fileStream.Read(outBuffer, 0, outBuffer.Length),
"File read stream should fail if file is modified during read",
HttpStatusCode.PreconditionFailed);
}
/*
* AccessCondition accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(DateTimeOffset.Now.Subtract(TimeSpan.FromHours(1)));
* file.SetMetadata();
* result = file.BeginOpenRead(
* accessCondition,
* null,
* null,
* ar => waitHandle.Set(),
* null);
* waitHandle.WaitOne();
* TestHelper.ExpectedException(
* () => file.EndOpenRead(result),
* "File read stream should fail if file is modified during read",
* HttpStatusCode.PreconditionFailed);
*/
}
}
finally
{
share.DeleteIfExists();
}
}
public void FileUseTransactionalMD5GetTestAPM()
{
FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
{
UseTransactionalMD5 = false,
};
FileRequestOptions optionsWithMD5 = new FileRequestOptions()
{
UseTransactionalMD5 = true,
};
byte[] buffer = GetRandomBuffer(3 * 1024 * 1024);
MD5 hasher = MD5.Create();
string md5 = Convert.ToBase64String(hasher.ComputeHash(buffer));
string lastCheckMD5 = null;
int checkCount = 0;
OperationContext opContextWithMD5Check = new OperationContext();
opContextWithMD5Check.ResponseReceived += (_, args) =>
{
if (long.Parse(HttpResponseParsers.GetContentLength(args.Response)) >= buffer.Length)
{
lastCheckMD5 = HttpResponseParsers.GetContentMD5(args.Response);
checkCount++;
}
};
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result;
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file2");
using (Stream fileStream = file.OpenWrite(buffer.Length * 2))
{
fileStream.Write(buffer, 0, buffer.Length);
fileStream.Write(buffer, 0, buffer.Length);
}
checkCount = 0;
using (Stream stream = new MemoryStream())
{
result = file.BeginDownloadToStream(stream, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadRangeToStream(result);
Assert.IsNull(lastCheckMD5);
result = file.BeginDownloadToStream(stream, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
StorageException storageEx = TestHelper.ExpectedException <StorageException>(
() => file.EndDownloadRangeToStream(result),
"File will not have MD5 set by default; with UseTransactional, download should fail");
result = file.BeginDownloadRangeToStream(stream, buffer.Length, buffer.Length, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadRangeToStream(result);
Assert.IsNull(lastCheckMD5);
result = file.BeginDownloadRangeToStream(stream, buffer.Length, buffer.Length, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadRangeToStream(result);
Assert.AreEqual(md5, lastCheckMD5);
result = file.BeginDownloadRangeToStream(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadRangeToStream(result);
Assert.IsNull(lastCheckMD5);
result = file.BeginDownloadRangeToStream(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
storageEx = TestHelper.ExpectedException <StorageException>(
() => file.EndDownloadRangeToStream(result),
"Downloading more than 4MB with transactional MD5 should not be supported");
Assert.IsInstanceOfType(storageEx.InnerException, typeof(ArgumentOutOfRangeException));
result = file.BeginOpenRead(null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
using (Stream fileStream = file.EndOpenRead(result))
{
fileStream.CopyTo(stream);
Assert.IsNotNull(lastCheckMD5);
}
result = file.BeginOpenRead(null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
using (Stream fileStream = file.EndOpenRead(result))
{
fileStream.CopyTo(stream);
Assert.IsNull(lastCheckMD5);
}
}
Assert.AreEqual(9, checkCount);
}
}
finally
{
share.DeleteIfExists();
}
}
public void FileDisableContentMD5ValidationTestAPM()
{
FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
{
DisableContentMD5Validation = true,
StoreFileContentMD5 = true,
};
FileRequestOptions optionsWithMD5 = new FileRequestOptions()
{
DisableContentMD5Validation = false,
StoreFileContentMD5 = true,
};
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result;
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file2");
using (Stream stream = new MemoryStream())
{
file.UploadFromStream(stream, null, optionsWithMD5);
}
using (Stream stream = new MemoryStream())
{
result = file.BeginDownloadToStream(stream, null, optionsWithMD5, null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadToStream(result);
result = file.BeginDownloadToStream(stream, null, optionsWithNoMD5, null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadToStream(result);
file.Properties.ContentMD5 = "MDAwMDAwMDA=";
file.SetProperties();
result = file.BeginDownloadToStream(stream, null, optionsWithMD5, null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
TestHelper.ExpectedException(
() => file.EndDownloadToStream(result),
"Downloading a file with invalid MD5 should fail",
HttpStatusCode.OK);
result = file.BeginDownloadToStream(stream, null, optionsWithNoMD5, null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadToStream(result);
}
}
}
finally
{
share.DeleteIfExists();
}
}
public void CloudFileSASIPAddressHelper(Func <IPAddressOrRange> generateInitialIPAddressOrRange, Func <IPAddress, IPAddressOrRange> generateFinalIPAddressOrRange)
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file;
SharedAccessFilePolicy policy = new SharedAccessFilePolicy()
{
Permissions = SharedAccessFilePermissions.Read,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
CloudFile fileWithKey = share.GetRootDirectoryReference().GetFileReference("filefile");
byte[] data = new byte[] { 0x1, 0x2, 0x3, 0x4 };
fileWithKey.UploadFromByteArray(data, 0, 4);
// We need an IP address that will never be a valid source
IPAddressOrRange ipAddressOrRange = generateInitialIPAddressOrRange();
string fileToken = fileWithKey.GetSharedAccessSignature(policy, null, null, null, ipAddressOrRange);
StorageCredentials fileSAS = new StorageCredentials(fileToken);
Uri fileSASUri = fileSAS.TransformUri(fileWithKey.Uri);
StorageUri fileSASStorageUri = fileSAS.TransformUri(fileWithKey.StorageUri);
file = new CloudFile(fileSASUri);
byte[] target = new byte[4];
OperationContext opContext = new OperationContext();
IPAddress actualIP = null;
opContext.ResponseReceived += (sender, e) =>
{
Stream stream = HttpResponseParsers.GetResponseStream(e.Response);
stream.Seek(0, SeekOrigin.Begin);
using (StreamReader reader = new StreamReader(stream))
{
string text = reader.ReadToEnd();
XDocument xdocument = XDocument.Parse(text);
actualIP = IPAddress.Parse(xdocument.Descendants("SourceIP").First().Value);
}
};
bool exceptionThrown = false;
try
{
file.DownloadRangeToByteArray(target, 0, 0, 4, null, null, opContext);
}
catch (StorageException)
{
exceptionThrown = true;
//The IP should not be included in the error details for security reasons
Assert.IsNull(actualIP);
}
Assert.IsTrue(exceptionThrown);
ipAddressOrRange = null;
fileToken = fileWithKey.GetSharedAccessSignature(policy, null, null, null, ipAddressOrRange);
fileSAS = new StorageCredentials(fileToken);
fileSASUri = fileSAS.TransformUri(fileWithKey.Uri);
fileSASStorageUri = fileSAS.TransformUri(fileWithKey.StorageUri);
file = new CloudFile(fileSASUri);
file.DownloadRangeToByteArray(target, 0, 0, 4, null, null, null);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(data[i], target[i]);
}
Assert.IsTrue(file.StorageUri.PrimaryUri.Equals(fileWithKey.Uri));
Assert.IsNull(file.StorageUri.SecondaryUri);
file = new CloudFile(fileSASStorageUri, null);
file.DownloadRangeToByteArray(target, 0, 0, 4, null, null, null);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(data[i], target[i]);
}
Assert.IsTrue(file.StorageUri.Equals(fileWithKey.StorageUri));
}
finally
{
share.DeleteIfExists();
}
}
public async Task CloudFileDownloadRangeToByteArrayNegativeTestsAsync()
{
CloudFile file = this.testShare.GetRootDirectoryReference().GetFileReference("file1");
await this.DoDownloadRangeToByteArrayNegativeTestsAsync(file);
}
/// <summary>
/// Initializes a new instance of the FileReadStreamHelper class.
/// </summary>
/// <param name="file">File reference to read from</param>
/// <param name="accessCondition">An object that represents the access conditions for the file. If null, no condition is used.</param>
/// <param name="options">An object that specifies additional options for the request.</param>
internal FileReadStreamHelper(CloudFile file, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
{
this.originalStream = new FileReadStream(file, accessCondition, options, operationContext);
this.originalStreamAsInputStream = this.originalStream.AsInputStream();
}
public void CloudFileDownloadToStreamAPMRetry()
{
byte[] buffer = GetRandomBuffer(1 * 1024 * 1024);
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
using (MemoryStream originalFile = new MemoryStream(buffer))
{
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
ICancellableAsyncResult result = file.BeginUploadFromStream(originalFile,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndUploadFromStream(result);
using (MemoryStream downloadedFile = new MemoryStream())
{
Exception manglerEx = null;
using (HttpMangler proxy = new HttpMangler(false,
new[]
{
TamperBehaviors.TamperNRequestsIf(
session => ThreadPool.QueueUserWorkItem(state =>
{
Thread.Sleep(1000);
try
{
session.Abort();
}
catch (Exception e)
{
manglerEx = e;
}
}),
2,
AzureStorageSelectors.FileTraffic().IfHostNameContains(share.ServiceClient.Credentials.AccountName))
}))
{
OperationContext operationContext = new OperationContext();
result = file.BeginDownloadToStream(downloadedFile, null, null, operationContext,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndDownloadToStream(result);
TestHelper.AssertStreamsAreEqual(originalFile, downloadedFile);
}
if (manglerEx != null)
{
throw manglerEx;
}
}
}
}
}
finally
{
share.DeleteIfExists();
}
}
public async Task CloudFileCopyTestTask()
{
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile source = share.GetRootDirectoryReference().GetFileReference("source");
string data = "String data";
UploadTextTask(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
await source.SetMetadataAsync();
CloudFile copy = share.GetRootDirectoryReference().GetFileReference("copy");
string copyId = await copy.StartCopyAsync(TestHelper.Defiddler(source));
WaitForCopyTask(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.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
TestHelper.ExpectedExceptionTask(
copy.AbortCopyAsync(copyId),
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
await source.FetchAttributesAsync();
Assert.IsNotNull(copy.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag);
Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
string copyData = DownloadTextTask(copy, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of file not similar");
await copy.FetchAttributesAsync();
FileProperties 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");
await copy.DeleteAsync();
}
finally
{
await share.DeleteAsync();
}
}
private static void TestAccess(string sasToken, SharedAccessFilePermissions permissions, SharedAccessFileHeaders headers, CloudFileShare share, CloudFile file)
{
CloudFileShare SASshare = null;
CloudFile SASfile;
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
string fileText = "file";
if (share != null)
{
SASshare = new CloudFileShare(credentials.TransformUri(share.Uri));
SASfile = SASshare.GetRootDirectoryReference().GetFileReference(file.Name);
}
else
{
SASfile = new CloudFile(credentials.TransformUri(file.Uri));
}
if ((permissions & SharedAccessFilePermissions.Write) == SharedAccessFilePermissions.Write)
{
UploadText(SASfile, fileText, Encoding.UTF8);
}
else if ((permissions & SharedAccessFilePermissions.Create) == SharedAccessFilePermissions.Create)
{
SASfile.Create(Encoding.UTF8.GetBytes(fileText).Length);
TestHelper.ExpectedException(
() => UploadText(SASfile, fileText, Encoding.UTF8),
"UploadText SAS does not allow for writing",
HttpStatusCode.Forbidden);
UploadText(file, fileText, Encoding.UTF8);
}
else
{
TestHelper.ExpectedException(
() => SASfile.Create(Encoding.UTF8.GetBytes(fileText).Length),
"Create file succeeded but SAS does not allow for writing/creating",
HttpStatusCode.Forbidden);
TestHelper.ExpectedException(
() => UploadText(SASfile, fileText, Encoding.UTF8),
"UploadText SAS does not allow for writing/creating",
HttpStatusCode.Forbidden);
UploadText(file, fileText, Encoding.UTF8);
}
if (SASshare != null)
{
if ((permissions & SharedAccessFilePermissions.List) == SharedAccessFilePermissions.List)
{
SASshare.GetRootDirectoryReference().ListFilesAndDirectories().ToArray();
}
else
{
TestHelper.ExpectedException(
() => SASshare.GetRootDirectoryReference().ListFilesAndDirectories().ToArray(),
"List files while SAS does not allow for listing",
HttpStatusCode.Forbidden);
}
}
if ((permissions & SharedAccessFilePermissions.Read) == SharedAccessFilePermissions.Read)
{
SASfile.FetchAttributes();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, SASfile.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, SASfile.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, SASfile.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, SASfile.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, SASfile.Properties.ContentType);
}
}
}
else
{
TestHelper.ExpectedException(
() => SASfile.FetchAttributes(),
"Fetch file attributes while SAS does not allow for reading",
HttpStatusCode.Forbidden);
}
if ((permissions & SharedAccessFilePermissions.Write) == SharedAccessFilePermissions.Write)
{
SASfile.SetMetadata();
}
else
{
TestHelper.ExpectedException(
() => SASfile.SetMetadata(),
"Set file metadata while SAS does not allow for writing",
HttpStatusCode.Forbidden);
}
if ((permissions & SharedAccessFilePermissions.Delete) == SharedAccessFilePermissions.Delete)
{
SASfile.Delete();
}
else
{
TestHelper.ExpectedException(
() => SASfile.Delete(),
"Delete file while SAS does not allow for deleting",
HttpStatusCode.Forbidden);
}
}
public async Task FileWriteStreamFlushTestAsync()
{
byte[] buffer = GetRandomBuffer(512);
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
file.StreamWriteSizeInBytes = 1024;
using (MemoryStream wholeFile = new MemoryStream())
{
FileRequestOptions options = new FileRequestOptions()
{
StoreFileContentMD5 = true
};
OperationContext opContext = new OperationContext();
using (CloudFileStream fileStream = await file.OpenWriteAsync(4 * 512, null, options, opContext))
{
for (int i = 0; i < 3; i++)
{
await fileStream.WriteAsync(buffer, 0, buffer.Length);
await wholeFile.WriteAsync(buffer, 0, buffer.Length);
}
#if NETCORE
// todo: Make some other better logic for this test to be reliable.
System.Threading.Thread.Sleep(500);
#endif
Task.Delay(500).GetAwaiter().GetResult();
Assert.AreEqual(2, opContext.RequestResults.Count);
await fileStream.FlushAsync();
Assert.AreEqual(3, opContext.RequestResults.Count);
await fileStream.FlushAsync();
Assert.AreEqual(3, opContext.RequestResults.Count);
await fileStream.WriteAsync(buffer, 0, buffer.Length);
await wholeFile.WriteAsync(buffer, 0, buffer.Length);
Assert.AreEqual(3, opContext.RequestResults.Count);
await fileStream.CommitAsync();
Assert.AreEqual(5, opContext.RequestResults.Count);
}
Assert.AreEqual(5, opContext.RequestResults.Count);
using (MemoryOutputStream downloadedFile = new MemoryOutputStream())
{
await file.DownloadToStreamAsync(downloadedFile);
TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile.UnderlyingStream);
}
}
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
public void FileStoreContentMD5TestAPM()
{
FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
{
StoreFileContentMD5 = false,
};
FileRequestOptions optionsWithMD5 = new FileRequestOptions()
{
StoreFileContentMD5 = true,
};
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result;
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file4");
using (Stream stream = new MemoryStream())
{
result = file.BeginUploadFromStream(stream, null, optionsWithMD5, null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndUploadFromStream(result);
}
file.FetchAttributes();
Assert.IsNotNull(file.Properties.ContentMD5);
file = share.GetRootDirectoryReference().GetFileReference("file5");
using (Stream stream = new MemoryStream())
{
result = file.BeginUploadFromStream(stream, null, optionsWithNoMD5, null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndUploadFromStream(result);
}
file.FetchAttributes();
Assert.IsNull(file.Properties.ContentMD5);
file = share.GetRootDirectoryReference().GetFileReference("file6");
using (Stream stream = new MemoryStream())
{
result = file.BeginUploadFromStream(stream,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndUploadFromStream(result);
}
file.FetchAttributes();
Assert.IsNull(file.Properties.ContentMD5);
}
}
finally
{
share.DeleteIfExists();
}
}
private async Task DoUploadDownloadFileAsync(CloudFile file, int fileSize)
{
#if NETCORE
string inputFileName = Path.GetTempFileName();
string outputFileName = Path.GetTempFileName();
if (System.IO.File.Exists(outputFileName))
{
System.IO.File.Delete(outputFileName);
}
try
{
byte[] buffer = GetRandomBuffer(fileSize);
using (FileStream localFile = new FileStream(inputFileName, FileMode.Create, FileAccess.Write))
{
await localFile.WriteAsync(buffer, 0, buffer.Length);
}
#if !FACADE_NETCORE
await file.UploadFromFileAsync(inputFileName);
OperationContext context = new OperationContext();
await file.UploadFromFileAsync(inputFileName, null, null, context);
Assert.IsNotNull(context.LastResult.ServiceRequestID);
context = new OperationContext();
await file.DownloadToFileAsync(outputFileName, FileMode.CreateNew, null, null, context);
Assert.IsNotNull(context.LastResult.ServiceRequestID);
#endif
using (FileStream inputFile = new FileStream(inputFileName, FileMode.Open, FileAccess.Read),
outputFile = new FileStream(outputFileName, FileMode.Open, FileAccess.Read))
{
TestHelper.AssertStreamsAreEqual(inputFile, outputFile);
}
}
finally
{
System.IO.File.Delete(inputFileName);
System.IO.File.Delete(outputFileName);
}
#else
StorageFolder tempFolder = ApplicationData.Current.TemporaryFolder;
StorageFile inputFile = await tempFolder.CreateFileAsync("input.file", CreationCollisionOption.GenerateUniqueName);
StorageFile outputFile = await tempFolder.CreateFileAsync("output.file", CreationCollisionOption.GenerateUniqueName);
try
{
byte[] buffer = GetRandomBuffer(fileSize);
using (Stream localFile = await inputFile.OpenStreamForWriteAsync())
{
await localFile.WriteAsync(buffer, 0, buffer.Length);
}
await file.UploadFromFileAsync(inputFile);
OperationContext context = new OperationContext();
await file.UploadFromFileAsync(inputFile, null, null, context);
Assert.IsNotNull(context.LastResult.ServiceRequestID);
context = new OperationContext();
await file.DownloadToFileAsync(outputFile, null, null, context);
Assert.IsNotNull(context.LastResult.ServiceRequestID);
using (Stream inputFileStream = await inputFile.OpenStreamForReadAsync(),
outputFileStream = await outputFile.OpenStreamForReadAsync())
{
TestHelper.AssertStreamsAreEqual(inputFileStream, outputFileStream);
}
}
finally
{
inputFile.DeleteAsync().AsTask().Wait();
outputFile.DeleteAsync().AsTask().Wait();
}
#endif
}
private static void CloudFileCopy(bool sourceIsSas, bool destinationIsSas)
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
// Create Source on server
CloudFile source = share.GetRootDirectoryReference().GetFileReference("source");
string data = "String data";
UploadText(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
source.SetMetadata();
string permission = "O:S-1-5-21-2127521184-1604012920-1887927527-21560751G:S-1-5-21-2127521184-1604012920-1887927527-513D:AI(A;;FA;;;SY)(A;;FA;;;BA)(A;;0x1200a9;;;S-1-5-21-397955417-626881126-188441444-3053964)";
string permissionKey = share.CreateFilePermission(permission);
source.Properties.FilePermissionKey = permissionKey;
var attributes = CloudFileNtfsAttributes.NoScrubData | CloudFileNtfsAttributes.Temporary;
var creationTime = DateTimeOffset.UtcNow.AddDays(-1);
source.Properties.NtfsAttributes = attributes;
DateTimeOffset lastWriteTime = DateTimeOffset.UtcNow;
source.Properties.LastWriteTime = lastWriteTime;
source.Properties.CreationTime = creationTime;
source.SetProperties();
// Create Destination on server
CloudFile destination = share.GetRootDirectoryReference().GetFileReference("destination");
destination.Create(1);
CloudFile copySource = source;
CloudFile copyDestination = destination;
if (sourceIsSas)
{
// Source SAS must have read permissions
SharedAccessFilePermissions permissions = SharedAccessFilePermissions.Read;
SharedAccessFilePolicy policy = new SharedAccessFilePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = permissions,
};
string sasToken = share.GetSharedAccessSignature(policy);
// Get source
StorageCredentials credentials = new StorageCredentials(sasToken);
copySource = new CloudFile(credentials.TransformUri(source.Uri));
}
if (destinationIsSas)
{
Assert.IsTrue(sourceIsSas);
// Destination SAS must have write permissions
SharedAccessFilePermissions permissions = SharedAccessFilePermissions.Write;
SharedAccessFilePolicy policy = new SharedAccessFilePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = permissions,
};
string sasToken = destination.GetSharedAccessSignature(policy);
// Get destination
StorageCredentials credentials = new StorageCredentials(sasToken);
copyDestination = new CloudFile(credentials.TransformUri(destination.Uri));
}
// Start copy and wait for completion
string copyId = copyDestination.StartCopy(TestHelper.Defiddler(copySource),
null,
null,
new FileCopyOptions()
{
PreservePermissions = true,
PreserveCreationTime = true,
PreserveLastWriteTime = true,
PreserveNtfsAttributes = true,
SetArchive = false
},
null, null);
WaitForCopy(destination);
// Check original file references for equality
Assert.AreEqual(CopyStatus.Success, destination.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, destination.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, destination.CopyState.TotalBytes);
Assert.AreEqual(data.Length, destination.CopyState.BytesCopied);
Assert.AreEqual(copyId, destination.CopyState.CopyId);
Assert.IsTrue(destination.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
if (!destinationIsSas)
{
// Abort Copy is not supported for SAS destination
TestHelper.ExpectedException(
() => copyDestination.AbortCopy(copyId),
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
}
source.FetchAttributes();
Assert.IsNotNull(destination.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, destination.Properties.ETag);
Assert.IsTrue(destination.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
string copyData = DownloadText(destination, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of file not equal.");
destination.FetchAttributes();
FileProperties prop1 = destination.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(lastWriteTime, destination.Properties.LastWriteTime.Value);
Assert.AreEqual(creationTime, destination.Properties.CreationTime.Value);
Assert.AreEqual(attributes, destination.Properties.NtfsAttributes.Value);
Assert.IsNotNull(destination.Properties.FilePermissionKey);
Assert.IsNull(destination.FilePermission);
Assert.AreEqual("value", destination.Metadata["Test"], false, "Copied metadata not same");
destination.Delete();
source.Delete();
}
finally
{
share.DeleteIfExists();
}
}
/// <summary>
/// Initializes a new instance of the FileWriteStreamHelper class for a file.
/// </summary>
/// <param name="file">File reference to write to.</param>
/// <param name="fileSize">Size of the file.</param>
/// <param name="createNew">Use <c>true</c> if the file is newly created, <c>false</c> otherwise.</param>
/// <param name="accessCondition">An object that represents the access conditions for the file. If null, no condition is used.</param>
/// <param name="options">An object that specifies additional options for the request.</param>
internal FileWriteStreamHelper(CloudFile file, long fileSize, bool createNew, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
{
this.originalStream = new FileWriteStream(file, fileSize, createNew, accessCondition, options, operationContext);
this.originalStreamAsOutputStream = this.originalStream.AsOutputStream();
}
public async Task FileDisableContentMD5ValidationTestAsync()
{
byte[] buffer = new byte[1024];
Random random = new Random();
random.NextBytes(buffer);
FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
{
DisableContentMD5Validation = true,
StoreFileContentMD5 = true,
};
FileRequestOptions optionsWithMD5 = new FileRequestOptions()
{
DisableContentMD5Validation = false,
StoreFileContentMD5 = true,
};
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file2");
using (Stream stream = new MemoryStream(buffer))
{
await file.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
}
using (Stream stream = new MemoryStream())
{
await file.DownloadToStreamAsync(stream, null, optionsWithMD5, null);
await file.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null);
using (Stream fileStream = await file.OpenReadAsync(null, optionsWithMD5, null))
{
Stream fileStreamForRead = fileStream;
int read;
do
{
read = await fileStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
using (Stream fileStream = await file.OpenReadAsync(null, optionsWithNoMD5, null))
{
Stream fileStreamForRead = fileStream;
int read;
do
{
read = await fileStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
file.Properties.ContentMD5 = "MDAwMDAwMDA=";
await file.SetPropertiesAsync();
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await file.DownloadToStreamAsync(stream, null, optionsWithMD5, opContext),
opContext,
"Downloading a file with invalid MD5 should fail",
HttpStatusCode.OK);
await file.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null);
using (Stream fileStream = await file.OpenReadAsync(null, optionsWithMD5, null))
{
Stream fileStreamForRead = fileStream;
TestHelper.ExpectedException <IOException>(
() =>
{
int read;
do
{
read = fileStreamForRead.Read(buffer, 0, buffer.Length);
}while (read > 0);
},
"Downloading a file with invalid MD5 should fail");
}
using (Stream fileStream = await file.OpenReadAsync(null, optionsWithNoMD5, null))
{
Stream fileStreamForRead = fileStream;
int read;
do
{
read = await fileStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
}
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
public void FileDisableContentMD5ValidationTest()
{
byte[] buffer = new byte[1024];
Random random = new Random();
random.NextBytes(buffer);
FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
{
DisableContentMD5Validation = true,
StoreFileContentMD5 = true,
};
FileRequestOptions optionsWithMD5 = new FileRequestOptions()
{
DisableContentMD5Validation = false,
StoreFileContentMD5 = true,
};
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file2");
using (Stream stream = new MemoryStream(buffer))
{
file.UploadFromStream(stream, null, optionsWithMD5);
}
using (Stream stream = new MemoryStream())
{
file.DownloadToStream(stream, null, optionsWithMD5);
file.DownloadToStream(stream, null, optionsWithNoMD5);
using (Stream fileStream = file.OpenRead(null, optionsWithMD5))
{
int read;
do
{
read = fileStream.Read(buffer, 0, buffer.Length);
}while (read > 0);
}
using (Stream fileStream = file.OpenRead(null, optionsWithNoMD5))
{
int read;
do
{
read = fileStream.Read(buffer, 0, buffer.Length);
}while (read > 0);
}
file.Properties.ContentMD5 = "MDAwMDAwMDA=";
file.SetProperties();
TestHelper.ExpectedException(
() => file.DownloadToStream(stream, null, optionsWithMD5),
"Downloading a file with invalid MD5 should fail",
HttpStatusCode.OK);
file.DownloadToStream(stream, null, optionsWithNoMD5);
using (Stream fileStream = file.OpenRead(null, optionsWithMD5))
{
TestHelper.ExpectedException <IOException>(
() =>
{
int read;
do
{
read = fileStream.Read(buffer, 0, buffer.Length);
}while (read > 0);
},
"Downloading a file with invalid MD5 should fail");
}
using (Stream fileStream = file.OpenRead(null, optionsWithNoMD5))
{
int read;
do
{
read = fileStream.Read(buffer, 0, buffer.Length);
}while (read > 0);
}
}
}
finally
{
share.DeleteIfExists();
}
}
public void CloudFileCopyTestAPM()
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
CloudFile source = share.GetRootDirectoryReference().GetFileReference("source");
string data = "String data";
UploadText(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
source.SetMetadata();
CloudFile copy = share.GetRootDirectoryReference().GetFileReference("copy");
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result = copy.BeginStartCopy(TestHelper.Defiddler(source),
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
string copyId = copy.EndStartCopy(result);
WaitForCopy(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.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
result = copy.BeginAbortCopy(copyId,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
TestHelper.ExpectedException(
() => copy.EndAbortCopy(result),
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
}
source.FetchAttributes();
Assert.IsNotNull(copy.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag);
Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
string copyData = DownloadText(copy, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of file not similar");
copy.FetchAttributes();
FileProperties prop1 = copy.Properties;
FileProperties prop2 = source.Properties;
Assert.AreEqual(prop1.CacheControl, prop2.CacheControl);
Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding);
Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition);
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.Delete();
}
finally
{
share.DeleteIfExists();
}
}
public void FileUseTransactionalMD5PutTestAPM()
{
FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
{
UseTransactionalMD5 = false,
};
FileRequestOptions optionsWithMD5 = new FileRequestOptions()
{
UseTransactionalMD5 = true,
};
byte[] buffer = GetRandomBuffer(1024);
MD5 hasher = MD5.Create();
string md5 = Convert.ToBase64String(hasher.ComputeHash(buffer));
string lastCheckMD5 = null;
int checkCount = 0;
OperationContext opContextWithMD5Check = new OperationContext();
opContextWithMD5Check.SendingRequest += (_, args) =>
{
if (HttpRequestParsers.GetContentLength(args.Request) >= buffer.Length)
{
lastCheckMD5 = HttpRequestParsers.GetContentMD5(args.Request);
checkCount++;
}
};
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result;
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file2");
file.Create(buffer.Length);
checkCount = 0;
using (Stream fileData = new MemoryStream(buffer))
{
result = file.BeginWriteRange(fileData, 0, null, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndWriteRange(result);
Assert.IsNull(lastCheckMD5);
fileData.Seek(0, SeekOrigin.Begin);
result = file.BeginWriteRange(fileData, 0, null, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndWriteRange(result);
Assert.AreEqual(md5, lastCheckMD5);
fileData.Seek(0, SeekOrigin.Begin);
result = file.BeginWriteRange(fileData, 0, md5, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
file.EndWriteRange(result);
Assert.AreEqual(md5, lastCheckMD5);
}
Assert.AreEqual(3, checkCount);
}
}
finally
{
share.DeleteIfExists();
}
}
private static void CloudFileCopy(bool sourceIsSas, bool destinationIsSas)
{
CloudFileShare share = GetRandomShareReference();
try
{
share.Create();
// Create Source on server
CloudFile source = share.GetRootDirectoryReference().GetFileReference("source");
string data = "String data";
UploadText(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
source.SetMetadata();
// Create Destination on server
CloudFile destination = share.GetRootDirectoryReference().GetFileReference("destination");
destination.Create(1);
CloudFile copySource = source;
CloudFile copyDestination = destination;
if (sourceIsSas)
{
// Source SAS must have read permissions
SharedAccessFilePermissions permissions = SharedAccessFilePermissions.Read;
SharedAccessFilePolicy policy = new SharedAccessFilePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = permissions,
};
string sasToken = source.GetSharedAccessSignature(policy);
// Get source
StorageCredentials credentials = new StorageCredentials(sasToken);
copySource = new CloudFile(credentials.TransformUri(source.Uri));
}
if (destinationIsSas)
{
Assert.IsTrue(sourceIsSas);
// Destination SAS must have write permissions
SharedAccessFilePermissions permissions = SharedAccessFilePermissions.Write;
SharedAccessFilePolicy policy = new SharedAccessFilePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = permissions,
};
string sasToken = destination.GetSharedAccessSignature(policy);
// Get destination
StorageCredentials credentials = new StorageCredentials(sasToken);
copyDestination = new CloudFile(credentials.TransformUri(destination.Uri));
}
// Start copy and wait for completion
string copyId = copyDestination.StartCopy(TestHelper.Defiddler(copySource));
WaitForCopy(destination);
// Check original file references for equality
Assert.AreEqual(CopyStatus.Success, destination.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, destination.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, destination.CopyState.TotalBytes);
Assert.AreEqual(data.Length, destination.CopyState.BytesCopied);
Assert.AreEqual(copyId, destination.CopyState.CopyId);
Assert.IsTrue(destination.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
if (!destinationIsSas)
{
// Abort Copy is not supported for SAS destination
TestHelper.ExpectedException(
() => copyDestination.AbortCopy(copyId),
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
}
source.FetchAttributes();
Assert.IsNotNull(destination.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, destination.Properties.ETag);
Assert.IsTrue(destination.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
string copyData = DownloadText(destination, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of file not equal.");
destination.FetchAttributes();
FileProperties prop1 = destination.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", destination.Metadata["Test"], false, "Copied metadata not same");
destination.Delete();
source.Delete();
}
finally
{
share.DeleteIfExists();
}
}
/// <summary>
/// Initializes a new instance of the FileWriteStream class for a file.
/// </summary>
/// <param name="file">File reference to write to.</param>
/// <param name="fileSize">Size of the file.</param>
/// <param name="createNew">Use <c>true</c> if the file is newly created, <c>false</c> otherwise.</param>
/// <param name="accessCondition">An object that represents the access conditions for the file. If null, no condition is used.</param>
/// <param name="options">An object that specifies additional options for the request.</param>
internal FileWriteStream(CloudFile file, long fileSize, bool createNew, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
: base(file, fileSize, createNew, accessCondition, options, operationContext)
{
}
public async Task CloudFileSASSharedProtocolsQueryParamAsync()
{
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
CloudFile file;
SharedAccessFilePolicy policy = new SharedAccessFilePolicy()
{
Permissions = SharedAccessFilePermissions.Read,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
CloudFile fileWithKey = share.GetRootDirectoryReference().GetFileReference("filefile");
byte[] data = new byte[] { 0x1, 0x2, 0x3, 0x4 };
byte[] target = new byte[4];
await fileWithKey.UploadFromByteArrayAsync(data, 0, 4);
foreach (SharedAccessProtocol?protocol in new SharedAccessProtocol?[] { null, SharedAccessProtocol.HttpsOrHttp, SharedAccessProtocol.HttpsOnly })
{
string fileToken = fileWithKey.GetSharedAccessSignature(policy, null, null, protocol, null);
StorageCredentials fileSAS = new StorageCredentials(fileToken);
Uri fileSASUri = new Uri(fileWithKey.Uri + fileSAS.SASToken);
StorageUri fileSASStorageUri = new StorageUri(new Uri(fileWithKey.StorageUri.PrimaryUri + fileSAS.SASToken), new Uri(fileWithKey.StorageUri.SecondaryUri + fileSAS.SASToken));
int securePort = 443;
int httpPort = (fileSASUri.Port == securePort) ? 80 : fileSASUri.Port;
if (!string.IsNullOrEmpty(TestBase.TargetTenantConfig.FileSecurePortOverride))
{
securePort = Int32.Parse(TestBase.TargetTenantConfig.FileSecurePortOverride);
}
var schemesAndPorts = new[] {
new { scheme = "HTTP", port = httpPort },
new { scheme = "HTTPS", port = securePort }
};
foreach (var item in schemesAndPorts)
{
fileSASUri = TransformSchemeAndPort(fileSASUri, item.scheme, item.port);
fileSASStorageUri = new StorageUri(TransformSchemeAndPort(fileSASStorageUri.PrimaryUri, item.scheme, item.port), TransformSchemeAndPort(fileSASStorageUri.SecondaryUri, item.scheme, item.port));
if (protocol.HasValue && protocol == SharedAccessProtocol.HttpsOnly && string.CompareOrdinal(item.scheme, "HTTP") == 0)
{
file = new CloudFile(fileSASUri);
OperationContext context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await file.FetchAttributesAsync(null /* accessCondition */, null /* options */, context),
context,
"Access a file using SAS with a shared protocols that does not match",
HttpStatusCode.Unused,
"");
file = new CloudFile(fileSASStorageUri, null);
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await file.FetchAttributesAsync(null /* accessCondition */, null /* options */, context),
context,
"Access a file using SAS with a shared protocols that does not match",
HttpStatusCode.Unused,
"");
}
else
{
file = new CloudFile(fileSASUri);
await file.DownloadRangeToByteArrayAsync(target, 0, 0, 4, null, null, null);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(data[i], target[i]);
}
file = new CloudFile(fileSASStorageUri, null);
await file.DownloadRangeToByteArrayAsync(target, 0, 0, 4, null, null, null);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(data[i], target[i]);
}
}
}
}
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FileReadStream"/> class.
/// </summary>
/// <param name="file">File reference to read from.</param>
/// <param name="accessCondition">An object that represents the access conditions for the file. If null, no condition is used.</param>
/// <param name="options">An object that specifies additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
internal FileReadStream(CloudFile file, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
: base(file, accessCondition, options, operationContext)
{
}
private static async Task TestAccess(string sasToken, SharedAccessFilePermissions permissions, SharedAccessFileHeaders headers, CloudFileShare share, CloudFile file)
{
CloudFileShare SASshare = null;
CloudFile SASfile;
OperationContext context = new OperationContext();
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
string fileText = "file";
if (share != null)
{
SASshare = new CloudFileShare(credentials.TransformUri(share.Uri));
SASfile = SASshare.GetRootDirectoryReference().GetFileReference(file.Name);
}
else
{
SASfile = new CloudFile(credentials.TransformUri(file.Uri));
}
if ((permissions & SharedAccessFilePermissions.Write) == SharedAccessFilePermissions.Write)
{
await UploadTextAsync(SASfile, fileText, Encoding.UTF8);
}
else if ((permissions & SharedAccessFilePermissions.Create) == SharedAccessFilePermissions.Create)
{
await SASfile.CreateAsync(Encoding.UTF8.GetBytes(fileText).Length);
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await UploadTextAsync(SASfile, fileText, Encoding.UTF8, operationContext: context),
context,
"UploadText SAS does not allow for writing",
HttpStatusCode.Forbidden,
"");
await UploadTextAsync(file, fileText, Encoding.UTF8);
}
else
{
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await SASfile.CreateAsync(Encoding.UTF8.GetBytes(fileText).Length, null /* accessCondition */, null /* options */, context),
context,
"Create file succeeded but SAS does not allow for writing/creating",
HttpStatusCode.Forbidden,
"");
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await UploadTextAsync(SASfile, fileText, Encoding.UTF8, operationContext: context),
context,
"UploadText SAS does not allow for writing/creating",
HttpStatusCode.Forbidden,
"");
await UploadTextAsync(file, fileText, Encoding.UTF8);
}
if (SASshare != null)
{
if ((permissions & SharedAccessFilePermissions.List) == SharedAccessFilePermissions.List)
{
FileResultSegment results = await SASshare.GetRootDirectoryReference().ListFilesAndDirectoriesSegmentedAsync(null);
}
else
{
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => { FileResultSegment results = await SASshare.GetRootDirectoryReference().ListFilesAndDirectoriesSegmentedAsync(null /* maxResults */, null /* currentToken */, null /* options */, context); },
context,
"List files while SAS does not allow for listing",
HttpStatusCode.Forbidden,
"");
}
}
if ((permissions & SharedAccessFilePermissions.Read) == SharedAccessFilePermissions.Read)
{
await SASfile.FetchAttributesAsync();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, SASfile.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, SASfile.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, SASfile.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, SASfile.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, SASfile.Properties.ContentType);
}
}
}
else
{
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await SASfile.FetchAttributesAsync(null /* accessCondition */, null /* options */, context),
context,
"Fetch file attributes while SAS does not allow for reading",
HttpStatusCode.Forbidden,
"");
}
if ((permissions & SharedAccessFilePermissions.Write) == SharedAccessFilePermissions.Write)
{
await SASfile.SetMetadataAsync();
}
else
{
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await SASfile.SetMetadataAsync(null /* accessCondition */, null /* options */, context),
context,
"Set file metadata while SAS does not allow for writing",
HttpStatusCode.Forbidden,
"");
}
if ((permissions & SharedAccessFilePermissions.Delete) == SharedAccessFilePermissions.Delete)
{
await SASfile.DeleteAsync();
}
else
{
context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await SASfile.DeleteAsync(null /* accessCondition */, null /* options */, context),
context,
"Delete file while SAS does not allow for deleting",
HttpStatusCode.Forbidden,
"");
}
}