public async Task CloudFileUploadTimeoutAsync()
{
CloudFileShare share = DefaultFileClient.GetShareReference(Guid.NewGuid().ToString("N"));
byte[] buffer = FileTestBase.GetRandomBuffer(4 * 1024 * 1024);
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
FileRequestOptions requestOptions = new FileRequestOptions()
{
MaximumExecutionTime = TimeSpan.FromSeconds(1),
RetryPolicy = new NoRetry()
};
using (MemoryStream ms = new MemoryStream(buffer))
{
await file.UploadFromStreamAsync(ms.AsInputStream(), null, requestOptions, null);
}
Assert.Fail();
}
catch (Exception e)
{
Assert.AreEqual(WindowsAzureErrorCode.TimeoutException, e.HResult);
}
finally
{
share.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task CloudFileUploadCancellationAsync()
{
CloudFileShare share = DefaultFileClient.GetShareReference(Guid.NewGuid().ToString("N"));
byte[] buffer = FileTestBase.GetRandomBuffer(4 * 1024 * 1024);
try
{
await share.CreateAsync();
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
FileRequestOptions requestOptions = new FileRequestOptions()
{
RetryPolicy = new NoRetry()
};
CancellationTokenSource cts = new CancellationTokenSource();
CancellationToken token = cts.Token;
new Task(() =>
{
new System.Threading.ManualResetEvent(false).WaitOne(10);
cts.Cancel(false);
}).Start();
using (MemoryStream ms = new MemoryStream(buffer))
{
#if ASPNET_K
file.UploadFromStreamAsync(ms, ms.Length, null, requestOptions, null, token).Wait();
#else
file.UploadFromStreamAsync(ms.AsInputStream(), null, requestOptions, null).AsTask(token).Wait();
#endif
}
Assert.Fail();
}
catch (AggregateException e)
{
TaskCanceledException ex = new TaskCanceledException();
Assert.AreEqual(ex.HResult, e.InnerException.HResult);
}
finally
{
share.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task CloudFileClientMaximumExecutionTimeoutAsync()
{
CloudFileClient fileClient = GenerateCloudFileClient();
CloudFileShare share = fileClient.GetShareReference(Guid.NewGuid().ToString("N"));
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
byte[] buffer = FileTestBase.GetRandomBuffer(80 * 1024 * 1024);
try
{
await share.CreateAsync();
fileClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(5);
CloudFile file = rootDirectory.GetFileReference("file");
file.StreamWriteSizeInBytes = 1 * 1024 * 1024;
using (MemoryStream ms = new MemoryStream(buffer))
{
try
{
await file.UploadFromStreamAsync(ms);
Assert.Fail();
}
catch (AggregateException ex)
{
#if !FACADE_NETCORE
Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).ExceptionInfo.Message);
#else
Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).Exception.Message);
#endif
}
catch (TaskCanceledException)
{
}
}
}
finally
{
fileClient.DefaultRequestOptions.MaximumExecutionTime = null;
share.DeleteIfExistsAsync().Wait();
}
}
public async Task CloudFileClientMaximumExecutionTimeoutAsync()
{
CloudFileClient fileClient = GenerateCloudFileClient();
CloudFileShare share = fileClient.GetShareReference(Guid.NewGuid().ToString("N"));
CloudFileDirectory rootDirectory = share.GetRootDirectoryReference();
byte[] buffer = FileTestBase.GetRandomBuffer(80 * 1024 * 1024);
try
{
await share.CreateAsync();
fileClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(5);
CloudFile file = rootDirectory.GetFileReference("file");
file.StreamWriteSizeInBytes = 1 * 1024 * 1024;
using (MemoryStream ms = new MemoryStream(buffer))
{
try
{
await file.UploadFromStreamAsync(ms);
Assert.Fail();
}
catch (TimeoutException ex)
{
Assert.IsInstanceOfType(ex, typeof(TimeoutException));
}
catch (StorageException ex)
{
Assert.IsInstanceOfType(ex.InnerException, typeof(TimeoutException));
}
}
}
finally
{
fileClient.DefaultRequestOptions.MaximumExecutionTime = null;
share.DeleteIfExistsAsync().Wait();
}
}
public void CloudFileClientMaximumExecutionTimeoutShouldNotBeHonoredForStreams()
{
CloudFileClient fileClient = GenerateCloudFileClient();
CloudFileShare share = fileClient.GetShareReference(Guid.NewGuid().ToString("N"));
byte[] buffer = FileTestBase.GetRandomBuffer(1024 * 1024);
try
{
share.Create();
fileClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(30);
CloudFile file = share.GetRootDirectoryReference().GetFileReference("file");
file.StreamWriteSizeInBytes = 1024 * 1024;
file.StreamMinimumReadSizeInBytes = 1024 * 1024;
using (CloudFileStream bos = file.OpenWrite(8 * 1024 * 1024))
{
DateTime start = DateTime.Now;
for (int i = 0; i < 7; i++)
{
bos.Write(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)
{
Thread.Sleep(msRemaining);
}
bos.Write(buffer, 0, buffer.Length);
}
using (Stream bis = file.OpenRead())
{
DateTime start = DateTime.Now;
int total = 0;
while (total < 7 * 1024 * 1024)
{
total += bis.Read(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)
{
Thread.Sleep(msRemaining);
}
while (true)
{
int count = bis.Read(buffer, 0, buffer.Length);
total += count;
if (count == 0)
{
break;
}
}
}
}
finally
{
fileClient.DefaultRequestOptions.MaximumExecutionTime = null;
share.DeleteIfExists();
}
}
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 (ICloudFileStream fileStream = await file.OpenWriteAsync(8 * 1024 * 1024))
{
Stream fos = fileStream.AsStreamForWrite();
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 (IRandomAccessStreamWithContentType fileStream = await file.OpenReadAsync())
{
Stream fis = fileStream.AsStreamForRead();
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().AsTask().Wait();
}
}