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;
share.DeleteIfExistsAsync().Wait();
}
}
public async Task CloudFileListSharesWithSnapshotAsync()
{
CloudFileShare share = GetRandomShareReference();
await share.CreateAsync();
share.Metadata["key1"] = "value1";
await share.SetMetadataAsync();
CloudFileShare snapshot = await share.SnapshotAsync();
share.Metadata["key2"] = "value2";
await share.SetMetadataAsync();
CloudFileClient client = GenerateCloudFileClient();
List <CloudFileShare> listedShares = new List <CloudFileShare>();
FileContinuationToken token = null;
do
{
ShareResultSegment resultSegment = await client.ListSharesSegmentedAsync(share.Name, ShareListingDetails.All, null, token, null, null);
token = resultSegment.ContinuationToken;
foreach (CloudFileShare listResultShare in resultSegment.Results)
{
listedShares.Add(listResultShare);
}
}while (token != null);
int count = 0;
bool originalFound = false;
bool snapshotFound = false;
foreach (CloudFileShare listShareItem in listedShares)
{
if (listShareItem.Name.Equals(share.Name) && !listShareItem.IsSnapshot && !originalFound)
{
count++;
originalFound = true;
Assert.AreEqual(2, listShareItem.Metadata.Count);
Assert.AreEqual("value2", listShareItem.Metadata["key2"]);
Assert.AreEqual("value1", listShareItem.Metadata["key1"]);
Assert.AreEqual(share.StorageUri, listShareItem.StorageUri);
}
else if (listShareItem.Name.Equals(share.Name) &&
listShareItem.IsSnapshot && !snapshotFound)
{
count++;
snapshotFound = true;
Assert.AreEqual(1, listShareItem.Metadata.Count);
Assert.AreEqual("value1", listShareItem.Metadata["key1"]);
Assert.AreEqual(snapshot.StorageUri, listShareItem.StorageUri);
}
}
Assert.AreEqual(2, count);
await snapshot.DeleteAsync();
await share.DeleteAsync();
}
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();
}
}
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
{
await share.DeleteAsync();
}
}
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
{
await share.DeleteAsync();
}
}
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
{
await share.DeleteAsync();
}
}
private static async Task CloudFileCopyAsync(bool sourceIsSas, bool destinationIsSas)
{
CloudFileShare share = GetRandomShareReference();
try
{
await share.CreateAsync();
// Create Source on server
CloudFile source = share.GetRootDirectoryReference().GetFileReference("source");
string data = "String data";
await UploadTextAsync(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
await source.SetMetadataAsync();
// Create Destination on server
CloudFile destination = share.GetRootDirectoryReference().GetFileReference("destination");
await destination.CreateAsync(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 = await copyDestination.StartCopyAsync(TestHelper.Defiddler(copySource));
await WaitForCopyAsync(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
OperationContext context = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await copyDestination.AbortCopyAsync(copyId, null, null, context),
context,
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
}
await source.FetchAttributesAsync();
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 = await DownloadTextAsync(destination, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of file not equal.");
await destination.FetchAttributesAsync();
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");
await destination.DeleteAsync();
await source.DeleteAsync();
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
