public async Task BlockBlobWriteStreamFlushTestAsync()
{
byte[] buffer = GetRandomBuffer(512 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blob = container.GetBlockBlobReference("blob1");
blob.StreamWriteSizeInBytes = 1 * 1024 * 1024;
using (MemoryStream wholeBlob = new MemoryStream())
{
OperationContext opContext = new OperationContext();
using (ICloudBlobStream blobStream = await blob.OpenWriteAsync(null, null, opContext))
{
for (int i = 0; i < 3; i++)
{
await blobStream.WriteAsync(buffer.AsBuffer());
await wholeBlob.WriteAsync(buffer, 0, buffer.Length);
}
Assert.AreEqual(1, opContext.RequestResults.Count);
await blobStream.FlushAsync();
Assert.AreEqual(2, opContext.RequestResults.Count);
await blobStream.FlushAsync();
Assert.AreEqual(2, opContext.RequestResults.Count);
await blobStream.WriteAsync(buffer.AsBuffer());
await wholeBlob.WriteAsync(buffer, 0, buffer.Length);
Assert.AreEqual(2, opContext.RequestResults.Count);
await blobStream.CommitAsync();
Assert.AreEqual(4, opContext.RequestResults.Count);
}
Assert.AreEqual(4, opContext.RequestResults.Count);
using (MemoryStream downloadedBlob = new MemoryStream())
{
await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream());
TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob);
}
}
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task PageBlobWriteStreamFlushTestAsync()
{
byte[] buffer = GetRandomBuffer(512);
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamWriteSizeInBytes = 1024;
using (MemoryStream wholeBlob = new MemoryStream())
{
BlobRequestOptions options = new BlobRequestOptions()
{
StoreBlobContentMD5 = true
};
OperationContext opContext = new OperationContext();
using (ICloudBlobStream blobStream = await blob.OpenWriteAsync(4 * 512, null, options, opContext))
{
for (int i = 0; i < 3; i++)
{
await blobStream.WriteAsync(buffer.AsBuffer());
await wholeBlob.WriteAsync(buffer, 0, buffer.Length);
}
Assert.AreEqual(2, opContext.RequestResults.Count);
await blobStream.FlushAsync();
Assert.AreEqual(3, opContext.RequestResults.Count);
await blobStream.FlushAsync();
Assert.AreEqual(3, opContext.RequestResults.Count);
await blobStream.WriteAsync(buffer.AsBuffer());
await wholeBlob.WriteAsync(buffer, 0, buffer.Length);
Assert.AreEqual(3, opContext.RequestResults.Count);
await blobStream.CommitAsync();
Assert.AreEqual(5, opContext.RequestResults.Count);
}
Assert.AreEqual(5, opContext.RequestResults.Count);
using (MemoryOutputStream downloadedBlob = new MemoryOutputStream())
{
await blob.DownloadToStreamAsync(downloadedBlob);
TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob.UnderlyingStream);
}
}
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task CloudBlobClientMaximumExecutionTimeoutShouldNotBeHonoredForStreamsAsync()
{
CloudBlobClient blobClient = GenerateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(Guid.NewGuid().ToString("N"));
byte[] buffer = BlobTestBase.GetRandomBuffer(1024 * 1024);
try
{
await container.CreateAsync();
blobClient.MaximumExecutionTime = TimeSpan.FromSeconds(30);
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
CloudPageBlob pageBlob = container.GetPageBlobReference("blob2");
blockBlob.StreamWriteSizeInBytes = 1024 * 1024;
blockBlob.StreamMinimumReadSizeInBytes = 1024 * 1024;
blockBlob.StreamMinimumReadSizeInBytes = 1024 * 1024;
pageBlob.StreamMinimumReadSizeInBytes = 1024 * 1024;
using (ICloudBlobStream bos = await blockBlob.OpenWriteAsync())
{
DateTime start = DateTime.Now;
for (int i = 0; i < 7; i++)
{
await bos.WriteAsync(buffer.AsBuffer());
}
// Sleep to ensure we are over the Max execution time when we do the last write
int msRemaining = (int)(blobClient.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
await bos.WriteAsync(buffer.AsBuffer());
await bos.CommitAsync();
}
using (Stream bis = (await blockBlob.OpenReadAsync()).AsStreamForRead())
{
DateTime start = DateTime.Now;
int total = 0;
while (total < 7 * 1024 * 1024)
{
total += await bis.ReadAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last read
int msRemaining = (int)(blobClient.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
while (true)
{
int count = await bis.ReadAsync(buffer, 0, buffer.Length);
total += count;
if (count == 0)
{
break;
}
}
}
using (ICloudBlobStream bos = await pageBlob.OpenWriteAsync(8 * 1024 * 1024))
{
DateTime start = DateTime.Now;
for (int i = 0; i < 7; i++)
{
await bos.WriteAsync(buffer.AsBuffer());
}
// Sleep to ensure we are over the Max execution time when we do the last write
int msRemaining = (int)(blobClient.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
await bos.WriteAsync(buffer.AsBuffer());
await bos.CommitAsync();
}
using (Stream bis = (await pageBlob.OpenReadAsync()).AsStreamForRead())
{
DateTime start = DateTime.Now;
int total = 0;
while (total < 7 * 1024 * 1024)
{
total += await bis.ReadAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last read
int msRemaining = (int)(blobClient.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
while (true)
{
int count = await bis.ReadAsync(buffer, 0, buffer.Length);
total += count;
if (count == 0)
{
break;
}
}
}
}
finally
{
blobClient.MaximumExecutionTime = null;
container.DeleteIfExistsAsync().AsTask().Wait();
}
}