public async Task PageBlobDownloadToStreamRangeTestAsync() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudPageBlob blob = this.testContainer.GetPageBlobReference("blob1"); using (MemoryStream wholeBlob = new MemoryStream(buffer)) { await blob.UploadFromStreamAsync(wholeBlob.AsInputStream()); byte[] testBuffer = new byte[1024]; MemoryStream blobStream = new MemoryStream(testBuffer); Exception ex = await TestHelper.ExpectedExceptionAsync<Exception>( async () => await blob.DownloadRangeToStreamAsync(blobStream.AsOutputStream(), 0, 0), "Requesting 0 bytes when downloading range should not work"); Assert.IsInstanceOfType(ex.InnerException.InnerException, typeof(ArgumentOutOfRangeException)); await blob.DownloadRangeToStreamAsync(blobStream.AsOutputStream(), 0, 1024); Assert.AreEqual(blobStream.Position, 1024); TestHelper.AssertStreamsAreEqualAtIndex(blobStream, wholeBlob, 0, 0, 1024); CloudPageBlob blob2 = this.testContainer.GetPageBlobReference("blob1"); MemoryStream blobStream2 = new MemoryStream(testBuffer); ex = await TestHelper.ExpectedExceptionAsync<Exception>( async () => await blob2.DownloadRangeToStreamAsync(blobStream.AsOutputStream(), 1024, 0), "Requesting 0 bytes when downloading range should not work"); Assert.IsInstanceOfType(ex.InnerException.InnerException, typeof(ArgumentOutOfRangeException)); await blob2.DownloadRangeToStreamAsync(blobStream2.AsOutputStream(), 1024, 1024); TestHelper.AssertStreamsAreEqualAtIndex(blobStream2, wholeBlob, 0, 1024, 1024); AssertAreEqual(blob, blob2); } }
public async Task InitializeAsync() { if (_isInitialized) { return; } IReadOnlyList<Size> availableCaptureResulotions = PhotoCaptureDevice.GetAvailableCaptureResolutions(CameraSensorLocation.Back); Device = await PhotoCaptureDevice.OpenAsync(CameraSensorLocation.Back, availableCaptureResulotions.First()); InitParameters(); Device.SetProperty(KnownCameraGeneralProperties.PlayShutterSoundOnCapture, true); _captureStream = new MemoryStream(); _captureSequence = Device.CreateCaptureSequence(1); _captureSequence.Frames[0].CaptureStream = _captureStream.AsOutputStream(); await Device.PrepareCaptureSequenceAsync(_captureSequence); CameraButtons.ShutterKeyHalfPressed += CameraButtons_ShutterKeyHalfPressed; CameraButtons.ShutterKeyPressed += CameraButtons_ShutterKeyPressed; CameraButtons.ShutterKeyReleased += CameraButtons_ShutterKeyReleased; _isInitialized = true; }
public async Task FileOpenWriteTestAsync() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); using (ICloudFileStream fileStream = await file.OpenWriteAsync(2048)) { Stream fileStreamForWrite = fileStream.AsStreamForWrite(); await fileStreamForWrite.WriteAsync(buffer, 0, 2048); await fileStreamForWrite.FlushAsync(); byte[] testBuffer = new byte[2048]; MemoryStream dstStream = new MemoryStream(testBuffer); await file.DownloadRangeToStreamAsync(dstStream.AsOutputStream(), null, null); MemoryStream memStream = new MemoryStream(buffer); TestHelper.AssertStreamsAreEqual(memStream, dstStream); } } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
public static async Task<string> DownloadTextAsync(CloudFile file, Encoding encoding, AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null) { using (MemoryStream stream = new MemoryStream()) { await file.DownloadToStreamAsync(stream.AsOutputStream(), accessCondition, options, operationContext); return encoding.GetString(stream.ToArray(), 0, (int)stream.Length); } }
public async Task FileDownloadToStreamRangeTestAsync() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); using (MemoryStream wholeFile = new MemoryStream(buffer)) { await file.UploadFromStreamAsync(wholeFile.AsInputStream()); byte[] testBuffer = new byte[1024]; MemoryStream fileStream = new MemoryStream(testBuffer); Exception ex = await TestHelper.ExpectedExceptionAsync<Exception>( async () => await file.DownloadRangeToStreamAsync(fileStream.AsOutputStream(), 0, 0), "Requesting 0 bytes when downloading range should not work"); Assert.IsInstanceOfType(ex.InnerException.InnerException, typeof(ArgumentOutOfRangeException)); await file.DownloadRangeToStreamAsync(fileStream.AsOutputStream(), 0, 1024); Assert.AreEqual(fileStream.Position, 1024); TestHelper.AssertStreamsAreEqualAtIndex(fileStream, wholeFile, 0, 0, 1024); CloudFile file2 = share.GetRootDirectoryReference().GetFileReference("file1"); MemoryStream fileStream2 = new MemoryStream(testBuffer); ex = await TestHelper.ExpectedExceptionAsync<Exception>( async () => await file2.DownloadRangeToStreamAsync(fileStream.AsOutputStream(), 1024, 0), "Requesting 0 bytes when downloading range should not work"); Assert.IsInstanceOfType(ex.InnerException.InnerException, typeof(ArgumentOutOfRangeException)); await file2.DownloadRangeToStreamAsync(fileStream2.AsOutputStream(), 1024, 1024); TestHelper.AssertStreamsAreEqualAtIndex(fileStream2, wholeFile, 0, 1024, 1024); AssertAreEqual(file, file2); } } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
private async void Button_Click_2(object sender, RoutedEventArgs e) { CameraCaptureSequence cameraCaptureSequence = _cam.CreateCaptureSequence(1); MemoryStream stream = new MemoryStream(); cameraCaptureSequence.Frames[0].CaptureStream = stream.AsOutputStream(); await _cam.PrepareCaptureSequenceAsync(cameraCaptureSequence); await cameraCaptureSequence.StartCaptureAsync(); stream.Seek(0, SeekOrigin.Begin); var library = new MediaLibrary(); library.SavePictureToCameraRoll("pic1.jpg", stream); }
public async Task RestoreAsync() { var file = await ApplicationData.Current.LocalFolder.GetFileAsync(SessionStateFileName); using (var inStream = await file.OpenSequentialReadAsync()) { using (var memoryStream = new MemoryStream()) { var provider = new DataProtectionProvider("LOCAL=user"); await provider.UnprotectStreamAsync(inStream, memoryStream.AsOutputStream()); memoryStream.Seek(0, SeekOrigin.Begin); var bytes = memoryStream.ToArray(); this.DeserializeState(bytes); } } this.LoadApplicationState(); }
private async void Button_Click_1(object sender, RoutedEventArgs e) { CameraCaptureSequence seq; seq = captureDevice.CreateCaptureSequence(1); seq.Frames[0].DesiredProperties[KnownCameraPhotoProperties.SceneMode] = CameraSceneMode.Portrait; MemoryStream captureStream1 = new MemoryStream(); seq.Frames[0].CaptureStream = captureStream1.AsOutputStream(); await captureDevice.PrepareCaptureSequenceAsync(seq); await seq.StartCaptureAsync(); captureStream1.Seek(0, SeekOrigin.Begin); MediaLibrary mediaLibrary = new MediaLibrary(); mediaLibrary.SavePictureToCameraRoll( "1111.jpg", captureStream1); }
private async void MainPage_Loaded(object sender, RoutedEventArgs e) { using (MemoryStream stream = new MemoryStream()) using (var camera = await PhotoCaptureDevice.OpenAsync(CameraSensorLocation.Back, PhotoCaptureDevice.GetAvailableCaptureResolutions(CameraSensorLocation.Back).First())) { var sequence = camera.CreateCaptureSequence(1); sequence.Frames[0].CaptureStream = stream.AsOutputStream(); camera.PrepareCaptureSequenceAsync(sequence); await sequence.StartCaptureAsync(); stream.Seek(0, SeekOrigin.Begin); using (var library = new MediaLibrary()) { library.SavePictureToCameraRoll("currentImage.jpg", stream); BitmapImage licoriceImage = new BitmapImage(new Uri("currentImage.jpg", UriKind.Relative)); imgPlace.Source = licoriceImage; } } }
public async Task CloudBlockBlobDownloadToStreamCancelAsync() { byte[] buffer = GetRandomBuffer(1 * 1024 * 1024); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudBlockBlob blob = container.GetBlockBlobReference("blob1"); using (MemoryStream originalBlob = new MemoryStream(buffer)) { await blob.UploadFromStreamAsync(originalBlob.AsInputStream()); using (MemoryStream downloadedBlob = new MemoryStream()) { OperationContext operationContext = new OperationContext(); IAsyncAction action = blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream(), null, null, operationContext); await Task.Delay(100); action.Cancel(); try { await action; } catch (Exception) { Assert.AreEqual(operationContext.LastResult.Exception.Message, "A task was canceled."); Assert.AreEqual(operationContext.LastResult.HttpStatusCode, 306); //Assert.AreEqual(operationContext.LastResult.HttpStatusMessage, "Unused"); } TestHelper.AssertNAttempts(operationContext, 1); } } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
private async Task CloudPageBlobUploadFromStreamAsync(CloudBlobContainer container, int size, AccessCondition accessCondition, OperationContext operationContext, int startOffset) { byte[] buffer = GetRandomBuffer(size); CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); hasher.Append(buffer.AsBuffer(startOffset, buffer.Length - startOffset)); string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamWriteSizeInBytes = 512; using (MemoryStream originalBlob = new MemoryStream()) { originalBlob.Write(buffer, startOffset, buffer.Length - startOffset); using (MemoryStream sourceStream = new MemoryStream(buffer)) { sourceStream.Seek(startOffset, SeekOrigin.Begin); BlobRequestOptions options = new BlobRequestOptions() { StoreBlobContentMD5 = true, }; await blob.UploadFromStreamAsync(sourceStream.AsInputStream(), accessCondition, options, operationContext); } await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryStream downloadedBlob = new MemoryStream()) { await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream()); TestHelper.AssertStreamsAreEqual(originalBlob, downloadedBlob); } } }
public async Task BlobOpenWriteTestAsync() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); using (ICloudBlobStream blobStream = await blob.OpenWriteAsync(2048)) { Stream blobStreamForWrite = blobStream.AsStreamForWrite(); await blobStreamForWrite.WriteAsync(buffer, 0, 2048); await blobStreamForWrite.FlushAsync(); byte[] testBuffer = new byte[2048]; MemoryStream dstStream = new MemoryStream(testBuffer); await blob.DownloadRangeToStreamAsync(dstStream.AsOutputStream(), null, null); MemoryStream memStream = new MemoryStream(buffer); TestHelper.AssertStreamsAreEqual(memStream, dstStream); } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudBlockBlobUploadDownloadNoDataAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudBlockBlob blob = container.GetBlockBlobReference("blob"); await TestHelper.ExpectedExceptionAsync<ArgumentNullException>( async () => await blob.UploadFromStreamAsync(null), "Uploading from a null stream should fail"); using (MemoryStream stream = new MemoryStream()) { await blob.UploadFromStreamAsync(stream.AsInputStream()); } await TestHelper.ExpectedExceptionAsync<ArgumentNullException>( async () => await blob.DownloadToStreamAsync(null), "Downloading to a null stream should fail"); using (MemoryStream stream = new MemoryStream()) { await blob.DownloadToStreamAsync(stream.AsOutputStream()); Assert.AreEqual(0, stream.Length); } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
private async Task StartCapturingAsync() { CameraCaptureSequence sequence = PhotoCaptureDevice.CreateCaptureSequence(1); var memoryStream = new MemoryStream(); sequence.Frames[0].CaptureStream = memoryStream.AsOutputStream(); try { PhotoCaptureDevice.SetProperty(KnownCameraPhotoProperties.FlashMode, FlashState.Off); PhotoCaptureDevice.SetProperty(KnownCameraPhotoProperties.SceneMode, CameraSceneMode.Macro); } catch { // one or more properties not supported } await PhotoCaptureDevice.PrepareCaptureSequenceAsync(sequence); }
public async Task<IBuffer> TakePicture() { if (m_captureDevice == null || commandeRunning) return null; try { commandeRunning = true; int angle = (int)(m_orientationAngle + m_captureDevice.SensorRotationInDegrees); if (angle < 0) angle += 360; if (m_sensorLocation == CameraSensorLocation.Back) { m_captureDevice.SetProperty(KnownCameraGeneralProperties.EncodeWithOrientation, angle); } else { m_captureDevice.SetProperty(KnownCameraGeneralProperties.EncodeWithOrientation, -angle); } m_captureDevice.SetProperty(KnownCameraGeneralProperties.SpecifiedCaptureOrientation, 0); var cameraCaptureSequence = m_captureDevice.CreateCaptureSequence(1); var stream = new MemoryStream(); cameraCaptureSequence.Frames[0].CaptureStream = stream.AsOutputStream(); await m_captureDevice.PrepareCaptureSequenceAsync(cameraCaptureSequence); await cameraCaptureSequence.StartCaptureAsync(); if (m_sensorLocation == CameraSensorLocation.Back) { return stream.GetWindowsRuntimeBuffer(); } else { return await JpegTools.FlipAndRotateAsync(stream.GetWindowsRuntimeBuffer(), FlipMode.Horizontal, Rotation.Rotate0, JpegOperation.AllowLossy); } } finally { commandeRunning = false; } return null; }
public async Task DisableContentMD5ValidationTestAsync() { byte[] buffer = new byte[1024]; Random random = new Random(); random.NextBytes(buffer); BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions() { DisableContentMD5Validation = true, StoreBlobContentMD5 = true, }; BlobRequestOptions optionsWithMD5 = new BlobRequestOptions() { DisableContentMD5Validation = false, StoreBlobContentMD5 = true, }; CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1"); using (Stream stream = new NonSeekableMemoryStream(buffer)) { await blockBlob.UploadFromStreamAsync(stream.AsInputStream(), null, optionsWithMD5, null); } using (Stream stream = new MemoryStream()) { await blockBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithMD5, null); await blockBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithNoMD5, null); using (IRandomAccessStreamWithContentType blobStream = await blockBlob.OpenReadAsync(null, optionsWithMD5, null)) { Stream blobStreamForRead = blobStream.AsStreamForRead(); int read; do { read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length); } while (read > 0); } using (IRandomAccessStreamWithContentType blobStream = await blockBlob.OpenReadAsync(null, optionsWithNoMD5, null)) { Stream blobStreamForRead = blobStream.AsStreamForRead(); int read; do { read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length); } while (read > 0); } blockBlob.Properties.ContentMD5 = "MDAwMDAwMDA="; await blockBlob.SetPropertiesAsync(); OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async () => await blockBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithMD5, opContext), opContext, "Downloading a blob with invalid MD5 should fail", HttpStatusCode.OK); await blockBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithNoMD5, null); using (IRandomAccessStreamWithContentType blobStream = await blockBlob.OpenReadAsync(null, optionsWithMD5, null)) { Stream blobStreamForRead = blobStream.AsStreamForRead(); TestHelper.ExpectedException<IOException>( () => { int read; do { read = blobStreamForRead.Read(buffer, 0, buffer.Length); } while (read > 0); }, "Downloading a blob with invalid MD5 should fail"); } using (IRandomAccessStreamWithContentType blobStream = await blockBlob.OpenReadAsync(null, optionsWithNoMD5, null)) { Stream blobStreamForRead = blobStream.AsStreamForRead(); int read; do { read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length); } while (read > 0); } } CloudPageBlob pageBlob = container.GetPageBlobReference("blob2"); using (Stream stream = new MemoryStream(buffer)) { await pageBlob.UploadFromStreamAsync(stream.AsInputStream(), null, optionsWithMD5, null); } using (Stream stream = new MemoryStream()) { await pageBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithMD5, null); await pageBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithNoMD5, null); using (IRandomAccessStreamWithContentType blobStream = await pageBlob.OpenReadAsync(null, optionsWithMD5, null)) { Stream blobStreamForRead = blobStream.AsStreamForRead(); int read; do { read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length); } while (read > 0); } using (IRandomAccessStreamWithContentType blobStream = await pageBlob.OpenReadAsync(null, optionsWithNoMD5, null)) { Stream blobStreamForRead = blobStream.AsStreamForRead(); int read; do { read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length); } while (read > 0); } pageBlob.Properties.ContentMD5 = "MDAwMDAwMDA="; await pageBlob.SetPropertiesAsync(); OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async () => await pageBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithMD5, opContext), opContext, "Downloading a blob with invalid MD5 should fail", HttpStatusCode.OK); await pageBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithNoMD5, null); using (IRandomAccessStreamWithContentType blobStream = await pageBlob.OpenReadAsync(null, optionsWithMD5, null)) { Stream blobStreamForRead = blobStream.AsStreamForRead(); TestHelper.ExpectedException<IOException>( () => { int read; do { read = blobStreamForRead.Read(buffer, 0, buffer.Length); } while (read > 0); }, "Downloading a blob with invalid MD5 should fail"); } using (IRandomAccessStreamWithContentType blobStream = await pageBlob.OpenReadAsync(null, optionsWithNoMD5, null)) { Stream blobStreamForRead = blobStream.AsStreamForRead(); int read; do { read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length); } while (read > 0); } } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task BlobUploadWithoutMD5ValidationAndStoreBlobContentTestAsync() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); BlobRequestOptions options = new BlobRequestOptions(); options.DisableContentMD5Validation = false; options.StoreBlobContentMD5 = false; OperationContext context = new OperationContext(); using (MemoryStream srcStream = new MemoryStream(buffer)) { await blob.UploadFromStreamAsync(srcStream.AsInputStream(), null, options, context); await blob.FetchAttributesAsync(); string md5 = blob.Properties.ContentMD5; blob.Properties.ContentMD5 = "MDAwMDAwMDA="; await blob.SetPropertiesAsync(null, options, context); byte[] testBuffer = new byte[2048]; MemoryStream dstStream = new MemoryStream(testBuffer); await TestHelper.ExpectedExceptionAsync(async () => await blob.DownloadRangeToStreamAsync(dstStream.AsOutputStream(), null, null, null, options, context), context, "Try to Download a stream with a corrupted md5 and DisableMD5Validation set to false", HttpStatusCode.OK); options.DisableContentMD5Validation = true; await blob.SetPropertiesAsync(null, options, context); byte[] testBuffer2 = new byte[2048]; MemoryStream dstStream2 = new MemoryStream(testBuffer2); await blob.DownloadRangeToStreamAsync(dstStream2.AsOutputStream(), null, null, null, options, context); } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
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 (var 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 BlobUploadFromStreamTestAsync() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudPageBlob blob = this.testContainer.GetPageBlobReference("blob1"); using (MemoryStream srcStream = new MemoryStream(buffer)) { await blob.UploadFromStreamAsync(srcStream.AsInputStream()); byte[] testBuffer = new byte[2048]; MemoryStream dstStream = new MemoryStream(testBuffer); await blob.DownloadRangeToStreamAsync(dstStream.AsOutputStream(), null, null); TestHelper.AssertStreamsAreEqual(srcStream, dstStream); } }
public async Task CloudBlockBlobUploadFromStreamInBlocksAsync() { byte[] buffer = GetRandomBuffer(2 * 1024 * 1024); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudBlockBlob blob = container.GetBlockBlobReference("blob1"); blob.ServiceClient.SingleBlobUploadThresholdInBytes = 1 * 1024 * 1024; blob.StreamWriteSizeInBytes = 512 * 1024; using (MemoryStream originalBlob = new MemoryStream(buffer)) { await blob.UploadFromStreamAsync(originalBlob.AsInputStream()); using (MemoryStream downloadedBlob = new MemoryStream()) { await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream()); TestHelper.AssertStreamsAreEqual(originalBlob, downloadedBlob); } } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task BlobUploadFromStreamTestAsync() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); using (MemoryStream srcStream = new MemoryStream(buffer)) { await blob.UploadFromStreamAsync(srcStream.AsInputStream()); byte[] testBuffer = new byte[2048]; MemoryStream dstStream = new MemoryStream(testBuffer); await blob.DownloadRangeToStreamAsync(dstStream.AsOutputStream(), null, null); TestHelper.AssertStreamsAreEqual(srcStream, dstStream); } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
private async Task CloudBlockBlobUploadFromStreamAsync(bool seekableSourceStream, int startOffset) { byte[] buffer = GetRandomBuffer(1 * 1024 * 1024); CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); hasher.Append(buffer.AsBuffer(startOffset, buffer.Length - startOffset)); string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudBlockBlob blob = container.GetBlockBlobReference("blob1"); using (MemoryStream originalBlob = new MemoryStream()) { originalBlob.Write(buffer, startOffset, buffer.Length - startOffset); Stream sourceStream; if (seekableSourceStream) { MemoryStream stream = new MemoryStream(buffer); stream.Seek(startOffset, SeekOrigin.Begin); sourceStream = stream; } else { NonSeekableMemoryStream stream = new NonSeekableMemoryStream(buffer); stream.ForceSeek(startOffset, SeekOrigin.Begin); sourceStream = stream; } using (sourceStream) { BlobRequestOptions options = new BlobRequestOptions() { StoreBlobContentMD5 = true, }; await blob.UploadFromStreamAsync(sourceStream.AsInputStream(), null, options, null); } await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryStream downloadedBlob = new MemoryStream()) { await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream()); TestHelper.AssertStreamsAreEqual(originalBlob, downloadedBlob); } } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudPageBlobWritePagesAsync() { byte[] buffer = GetRandomBuffer(4 * 1024 * 1024); #if ASPNET_K MD5 md5 = MD5.Create(); string contentMD5 = Convert.ToBase64String(md5.ComputeHash(buffer)); #else CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); hasher.Append(buffer.AsBuffer()); string contentMD5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); #endif CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); await blob.CreateAsync(4 * 1024 * 1024); using (MemoryStream memoryStream = new MemoryStream()) { await TestHelper.ExpectedExceptionAsync<ArgumentOutOfRangeException>( async () => await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, null), "Zero-length WritePages should fail"); memoryStream.SetLength(4 * 1024 * 1024 + 1); await TestHelper.ExpectedExceptionAsync<ArgumentOutOfRangeException>( async () => await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, null), ">4MB WritePages should fail"); } using (MemoryStream resultingData = new MemoryStream()) { using (MemoryStream memoryStream = new MemoryStream(buffer)) { OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async () => await blob.WritePagesAsync(memoryStream.AsInputStream(), 512, null, null, null, opContext), opContext, "Writing out-of-range pages should fail", HttpStatusCode.RequestedRangeNotSatisfiable, "InvalidPageRange"); memoryStream.Seek(0, SeekOrigin.Begin); await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, contentMD5); resultingData.Write(buffer, 0, buffer.Length); int offset = buffer.Length - 1024; memoryStream.Seek(offset, SeekOrigin.Begin); await TestHelper.ExpectedExceptionAsync( async () => await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, contentMD5, null, null, opContext), opContext, "Invalid MD5 should fail with mismatch", HttpStatusCode.BadRequest, "Md5Mismatch"); memoryStream.Seek(offset, SeekOrigin.Begin); await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, null); resultingData.Seek(0, SeekOrigin.Begin); resultingData.Write(buffer, offset, buffer.Length - offset); offset = buffer.Length - 2048; memoryStream.Seek(offset, SeekOrigin.Begin); await blob.WritePagesAsync(memoryStream.AsInputStream(), 1024, null); resultingData.Seek(1024, SeekOrigin.Begin); resultingData.Write(buffer, offset, buffer.Length - offset); } using (MemoryStream blobData = new MemoryStream()) { await blob.DownloadToStreamAsync(blobData.AsOutputStream()); Assert.AreEqual(resultingData.Length, blobData.Length); Assert.IsTrue(blobData.ToArray().SequenceEqual(resultingData.ToArray())); } } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public static async Task<string> DownloadTextAsync(CloudBlob blob, Encoding encoding, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null) { using (MemoryStream stream = new MemoryStream()) { await blob.DownloadToStreamAsync(stream.AsOutputStream(), accessCondition, options, operationContext); byte[] buffer = stream.ToArray(); return encoding.GetString(buffer, 0, buffer.Length); } }
public async Task RestoreSessionStateAsync() { _sessionState = new Dictionary<string, Dictionary<String, Object>>(); try { // Get the input stream for the SessionState file StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(Constants.SessionStateFileName); using (IInputStream inStream = await file.OpenSequentialReadAsync()) { var memoryStream = new MemoryStream(); var provider = new DataProtectionProvider("LOCAL=user"); // Decrypt the prevously saved session data. await provider.UnprotectStreamAsync(inStream, memoryStream.AsOutputStream()); memoryStream.Seek(0, SeekOrigin.Begin); // Deserialize the Session State DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, Dictionary<string, object>>), _knownTypes); _sessionState = (Dictionary<string, Dictionary<string, object>>)serializer.ReadObject(memoryStream); } } catch (Exception e) { throw new SessionStateServiceException(e); } }
public async Task BlockBlobWriteStreamBasicTestAsync() { byte[] buffer = GetRandomBuffer(3 * 1024 * 1024); CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); CloudBlobClient blobClient = GenerateCloudBlobClient(); blobClient.ParallelOperationThreadCount = 2; string name = GetRandomContainerName(); CloudBlobContainer container = blobClient.GetContainerReference(name); try { await container.CreateAsync(); CloudBlockBlob blob = container.GetBlockBlobReference("blob1"); using (MemoryStream wholeBlob = new MemoryStream()) { BlobRequestOptions options = new BlobRequestOptions() { StoreBlobContentMD5 = true, }; using (IOutputStream writeStream = await blob.OpenWriteAsync(null, options, null)) { Stream blobStream = writeStream.AsStreamForWrite(); for (int i = 0; i < 3; i++) { await blobStream.WriteAsync(buffer, 0, buffer.Length); await wholeBlob.WriteAsync(buffer, 0, buffer.Length); Assert.AreEqual(wholeBlob.Position, blobStream.Position); hasher.Append(buffer.AsBuffer()); } } string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryStream downloadedBlob = new MemoryStream()) { await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream()); TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob); } } } finally { container.DeleteAsync().AsTask().Wait(); } }
public async Task CloudBlockBlobPutBlockAsync() { byte[] buffer = GetRandomBuffer(4 * 1024 * 1024); #if ASPNET_K MD5 md5 = MD5.Create(); string contentMD5 = Convert.ToBase64String(md5.ComputeHash(buffer)); #else CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); hasher.Append(buffer.AsBuffer()); string contentMD5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); #endif CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudBlockBlob blob = container.GetBlockBlobReference("blob1"); List<string> blockList = GetBlockIdList(2); using (MemoryStream resultingData = new MemoryStream()) { using (MemoryStream memoryStream = new MemoryStream(buffer)) { memoryStream.Seek(0, SeekOrigin.Begin); await blob.PutBlockAsync(blockList[0], memoryStream.AsInputStream(), contentMD5); resultingData.Write(buffer, 0, buffer.Length); int offset = buffer.Length - 1024; memoryStream.Seek(offset, SeekOrigin.Begin); OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async () => await blob.PutBlockAsync(blockList[1], memoryStream.AsInputStream(), contentMD5, null, null, opContext), opContext, "Invalid MD5 should fail with mismatch", HttpStatusCode.BadRequest, "Md5Mismatch"); memoryStream.Seek(offset, SeekOrigin.Begin); await blob.PutBlockAsync(blockList[1], memoryStream.AsInputStream(), null); resultingData.Write(buffer, offset, buffer.Length - offset); } await blob.PutBlockListAsync(blockList); using (MemoryStream blobData = new MemoryStream()) { await blob.DownloadToStreamAsync(blobData.AsOutputStream()); Assert.AreEqual(resultingData.Length, blobData.Length); Assert.IsTrue(blobData.ToArray().SequenceEqual(resultingData.ToArray())); } } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task PageBlobWriteStreamBasicTestAsync() { byte[] buffer = GetRandomBuffer(6 * 512); CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); CloudBlobContainer container = GetRandomContainerReference(); container.ServiceClient.ParallelOperationThreadCount = 2; try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamWriteSizeInBytes = 8 * 512; using (MemoryStream wholeBlob = new MemoryStream()) { BlobRequestOptions options = new BlobRequestOptions() { StoreBlobContentMD5 = true, }; using (IOutputStream writeStream = await blob.OpenWriteAsync(buffer.Length * 3, null, options, null)) { Stream blobStream = writeStream.AsStreamForWrite(); for (int i = 0; i < 3; i++) { await blobStream.WriteAsync(buffer, 0, buffer.Length); await wholeBlob.WriteAsync(buffer, 0, buffer.Length); Assert.AreEqual(wholeBlob.Position, blobStream.Position); hasher.Append(buffer.AsBuffer()); } } string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryStream downloadedBlob = new MemoryStream()) { await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream()); TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob); } await TestHelper.ExpectedExceptionAsync<ArgumentException>( async () => await blob.OpenWriteAsync(null, null, options, null), "OpenWrite with StoreBlobContentMD5 on an existing page blob should fail"); using (IOutputStream writeStream = await blob.OpenWriteAsync(null)) { Stream blobStream = writeStream.AsStreamForWrite(); blobStream.Seek(buffer.Length / 2, SeekOrigin.Begin); wholeBlob.Seek(buffer.Length / 2, SeekOrigin.Begin); for (int i = 0; i < 2; i++) { blobStream.Write(buffer, 0, buffer.Length); wholeBlob.Write(buffer, 0, buffer.Length); Assert.AreEqual(wholeBlob.Position, blobStream.Position); } wholeBlob.Seek(0, SeekOrigin.End); } await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryStream downloadedBlob = new MemoryStream()) { options.DisableContentMD5Validation = true; await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream(), null, options, null); TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob); } } } finally { container.DeleteAsync().AsTask().Wait(); } }
public async Task CloudBlockBlobSetPropertiesAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudBlockBlob blob = container.GetBlockBlobReference("blob1"); await CreateForTestAsync(blob, 1, 1024); string eTag = blob.Properties.ETag; DateTimeOffset lastModified = blob.Properties.LastModified.Value; await Task.Delay(1000); blob.Properties.CacheControl = "no-transform"; blob.Properties.ContentDisposition = "attachment"; #if !ASPNET_K blob.Properties.ContentEncoding = "gzip"; #endif blob.Properties.ContentLanguage = "tr,en"; blob.Properties.ContentMD5 = "MDAwMDAwMDA="; blob.Properties.ContentType = "text/html"; await blob.SetPropertiesAsync(); Assert.IsTrue(blob.Properties.LastModified > lastModified); Assert.AreNotEqual(eTag, blob.Properties.ETag); CloudBlockBlob blob2 = container.GetBlockBlobReference("blob1"); await blob2.FetchAttributesAsync(); Assert.AreEqual("no-transform", blob2.Properties.CacheControl); Assert.AreEqual("attachment", blob2.Properties.ContentDisposition); #if !ASPNET_K Assert.AreEqual("gzip", blob2.Properties.ContentEncoding); #endif Assert.AreEqual("tr,en", blob2.Properties.ContentLanguage); Assert.AreEqual("MDAwMDAwMDA=", blob2.Properties.ContentMD5); Assert.AreEqual("text/html", blob2.Properties.ContentType); CloudBlockBlob blob3 = container.GetBlockBlobReference("blob1"); using (MemoryStream stream = new MemoryStream()) { BlobRequestOptions options = new BlobRequestOptions() { DisableContentMD5Validation = true, }; await blob3.DownloadToStreamAsync(stream.AsOutputStream(), null, options, null); } AssertAreEqual(blob2.Properties, blob3.Properties); BlobResultSegment results = await container.ListBlobsSegmentedAsync(null); CloudBlockBlob blob4 = (CloudBlockBlob)results.Results.First(); AssertAreEqual(blob2.Properties, blob4.Properties); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task PageBlobWriteStreamRandomSeekTestAsync() { byte[] buffer = GetRandomBuffer(3 * 1024 * 1024); CloudBlobContainer container = GetRandomContainerReference(); container.ServiceClient.ParallelOperationThreadCount = 2; try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); using (MemoryStream wholeBlob = new MemoryStream()) { using (IOutputStream writeStream = await blob.OpenWriteAsync(buffer.Length)) { Stream blobStream = writeStream.AsStreamForWrite(); TestHelper.ExpectedException<ArgumentOutOfRangeException>( () => blobStream.Seek(1, SeekOrigin.Begin), "Page blob stream should not allow unaligned seeks"); await blobStream.WriteAsync(buffer, 0, buffer.Length); await wholeBlob.WriteAsync(buffer, 0, buffer.Length); Random random = new Random(); for (int i = 0; i < 10; i++) { int offset = random.Next(buffer.Length / 512) * 512; SeekRandomly(blobStream, offset); await blobStream.WriteAsync(buffer, 0, buffer.Length - offset); wholeBlob.Seek(offset, SeekOrigin.Begin); await wholeBlob.WriteAsync(buffer, 0, buffer.Length - offset); } } wholeBlob.Seek(0, SeekOrigin.End); await blob.FetchAttributesAsync(); Assert.IsNull(blob.Properties.ContentMD5); using (MemoryStream downloadedBlob = new MemoryStream()) { await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream()); TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob); } } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }