public FileAsyncCopyController( TransferScheduler transferScheduler, TransferJob transferJob, CancellationToken cancellationToken) : base(transferScheduler, transferJob, cancellationToken) { if (transferJob.Destination.Type != TransferLocationType.AzureFile) { throw new ArgumentException( string.Format( CultureInfo.CurrentCulture, Resources.ParameterCannotBeNullException, "Dest.AzureFile"), "transferJob"); } if (transferJob.Source.Type != TransferLocationType.SourceUri && transferJob.Source.Type != TransferLocationType.AzureBlob && transferJob.Source.Type != TransferLocationType.AzureFile) { throw new ArgumentException( string.Format( CultureInfo.CurrentCulture, Resources.ProvideExactlyOneOfThreeParameters, "Source.SourceUri", "Source.Blob", "Source.AzureFile"), "transferJob"); } this.destLocation = this.TransferJob.Destination as AzureFileLocation; this.destFile = this.destLocation.AzureFile; }
private void CopyFromFile2File(Action <CloudFileShare> SetSourceContext, Func <CloudFileShare, object> getDestContext) { string destShareName = Utility.GenNameString("destshare"); CloudFileShare destShare = fileUtil.EnsureFileShareExists(destShareName); string sourceShareName = Utility.GenNameString("sourceshare"); CloudFileShare sourceShare = fileUtil.EnsureFileShareExists(sourceShareName); try { StorageFile.CloudFile sourceFile = fileUtil.CreateFile(sourceShare.GetRootDirectoryReference(), Utility.GenNameString("SourceFile")); object destContext = getDestContext(destShare); SetSourceContext(sourceShare); string destFileName = Utility.GenNameString("destfile"); Test.Assert(CommandAgent.StartFileCopyFromFile(sourceShareName, sourceFile.Name, destShareName, destFileName, destContext), "Copy to file with sas token credential should succeed."); var destFile = fileUtil.GetFileReference(destShare.GetRootDirectoryReference(), destFileName); Test.Assert(CommandAgent.GetFileCopyState(destFile, destContext, true), "Get file copy state should succeed."); CloudFileUtil.ValidateCopyResult(sourceFile, destFile); } finally { fileUtil.DeleteFileShareIfExists(sourceShareName); fileUtil.DeleteFileShareIfExists(destShareName); } }
public void StartCopyFromNonPublicUriCrossAccount() { string shareName = Utility.GenNameString("share"); CloudFileShare share = fileUtil2.EnsureFileShareExists(shareName); string destShareName = Utility.GenNameString("destshare"); CloudFileShare destShare = fileUtil.EnsureFileShareExists(destShareName); try { string fileName = Utility.GenNameString("fileName"); StorageFile.CloudFile sourceFile = fileUtil2.CreateFile(share, fileName); StorageFile.CloudFile destFile = fileUtil.GetFileReference(destShare.GetRootDirectoryReference(), fileName); Agent.Context = null; Test.Assert(!CommandAgent.StartFileCopy(sourceFile.Uri.ToString(), destFile), "Copy from non public non sas uri should fail."); ExpectedContainErrorMessage("The specified resource does not exist."); } finally { fileUtil2.DeleteFileShareIfExists(shareName); fileUtil.DeleteFileShareIfExists(destShareName); } }
public void CopyCrossAccountFromFile2SASFile() { string destShareName = Utility.GenNameString("destshare"); CloudFileShare destShare = fileUtil2.EnsureFileShareExists(destShareName); string sourceShareName = Utility.GenNameString("sourceshare"); CloudFileShare sourceShare = fileUtil.EnsureFileShareExists(sourceShareName); try { StorageFile.CloudFile sourceFile = fileUtil.CreateFile(sourceShare.GetRootDirectoryReference(), Utility.GenNameString("SourceFile")); string destFileName = Utility.GenNameString("destfile"); string destSasToken = destShare.GetSharedAccessSignature(new SharedAccessFilePolicy() { Permissions = SharedAccessFilePermissions.Read | SharedAccessFilePermissions.Write, SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddHours(1) }); object destContext = CommandAgent.GetStorageContextWithSASToken(StorageAccount2, destSasToken); Test.Assert(CommandAgent.StartFileCopy(sourceFile, destShareName, destFileName, destContext), "Copy to file with sas token credential should fail."); Test.Assert(CommandAgent.GetFileCopyState(destShareName, destFileName, destContext, true), "Get file copy state should succeed."); CloudFileUtil.ValidateCopyResult(sourceFile, destShare.GetRootDirectoryReference().GetFileReference(destFileName)); } finally { fileUtil.DeleteFileShareIfExists(sourceShareName); fileUtil2.DeleteFileShareIfExists(destShareName); } }
internal CloudFileWriter( TransferScheduler scheduler, SyncTransferController controller, CancellationToken cancellationToken) : base(scheduler, controller, cancellationToken) { this.cloudFile = this.TransferJob.Destination.AzureFile; }
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, accessCondition, options, operationContext); return encoding.GetString(stream.ToArray(), 0, (int)stream.Length); } }
public CloudFileReader( TransferScheduler scheduler, SyncTransferController controller, CancellationToken cancellationToken) :base(scheduler, controller, cancellationToken) { this.file = this.SharedTransferData.TransferJob.Source.AzureFile; Debug.Assert(null != this.file, "Initializing a CloudFileReader, the source location should be a CloudFile instance."); }
/// <summary> /// Initializes a new instance of the <see cref="AzureFileLocation"/> class. /// </summary> /// <param name="azureFile">CloudFile instance as a location in a transfer job. /// It could be a source, a destination.</param> public AzureFileLocation(CloudFile azureFile) { if (null == azureFile) { throw new ArgumentNullException("azureFile"); } this.AzureFile = azureFile; }
public static void WaitForCopyTask(CloudFile file) { bool copyInProgress = true; while (copyInProgress) { Thread.Sleep(1000); file.FetchAttributesAsync().Wait(); copyInProgress = (file.CopyState.Status == CopyStatus.Pending); } }
public static async Task WaitForCopyAsync(CloudFile file) { bool copyInProgress = true; while (copyInProgress) { await Task.Delay(1000); await file.FetchAttributesAsync(); copyInProgress = (file.CopyState.Status == CopyStatus.Pending); } }
public static async Task UploadTextAsync(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; await file.UploadFromStreamAsync(stream, accessCondition, options, operationContext); } }
public static void AssertAreEqual(CloudFile expected, CloudFile actual) { if (expected == null) { Assert.IsNull(actual); } else { Assert.IsNotNull(actual); Assert.AreEqual(expected.Uri, actual.Uri); Assert.AreEqual(expected.StorageUri, actual.StorageUri); AssertAreEqual(expected.Properties, actual.Properties); } }
public void GetCopyStateWithSAS() { string destShareName = Utility.GenNameString("destshare"); CloudFileShare destShare = fileUtil.EnsureFileShareExists(destShareName); try { string fileName = Utility.GenNameString("DestFile"); StorageFile.CloudFile destFile = fileUtil.GetFileReference(destShare.GetRootDirectoryReference(), fileName); object destContext; if (lang == Language.PowerShell) { destContext = PowerShellAgent.GetStorageContext(StorageAccount.ToString(true)); } else { destContext = NodeJSAgent.GetStorageContext(StorageAccount.ToString(true)); } string bigBlobUri = Test.Data.Get("BigBlobUri"); Test.Assert(CommandAgent.StartFileCopy(bigBlobUri, destShareName, fileName, destContext), "Copy to file should succeed."); string sasToken = destShare.GetSharedAccessSignature(new SharedAccessFilePolicy() { Permissions = SharedAccessFilePermissions.Read, SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddHours(1) }); CommandAgent.SetStorageContextWithSASToken(StorageAccount.Credentials.AccountName, sasToken); Test.Assert(CommandAgent.GetFileCopyState(destShareName, fileName, destContext), "Get copy state with sas token should succeed."); string copyId = null; if (lang == Language.NodeJS) { copyId = ((JObject)CommandAgent.Output[0]["copy"])["id"].ToString(); } NodeJSAgent.AgentConfig.ConnectionString = StorageAccount.ToString(true); Test.Assert(CommandAgent.StopFileCopy(destFile, copyId), "Stop file copy should succeed."); } finally { fileUtil.DeleteFileShareIfExists(destShareName); } }
public void StopFileCopyWithInvalidCredential() { string shareName = Utility.GenNameString("share"); CloudFileShare share = fileUtil.EnsureFileShareExists(shareName); try { StorageFile.CloudFile file = fileUtil.CreateFile(share.GetRootDirectoryReference(), Utility.GenNameString("")); Test.Assert(!CommandAgent.StopFileCopy(shareName, file.Name, Guid.NewGuid().ToString()), "Stop file copy with invalid credential should fail."); CheckErrorMessage(); } finally { fileUtil.DeleteFileShareIfExists(shareName); } }
/// <summary> /// Stop copy operation by CloudBlob object /// </summary> /// <param name="blob">CloudBlob object</param> /// <param name="copyId">Copy id</param> private async Task StopCopyFile(long taskId, IStorageFileManagement localChannel, CloudFile file, string copyId) { FileRequestOptions requestOptions = RequestOptions; //Set no retry to resolve the 409 conflict exception requestOptions.RetryPolicy = new NoRetry(); string abortCopyId = string.Empty; if (string.IsNullOrEmpty(copyId) || Force) { //Make sure we use the correct copy id to abort //Use default retry policy for FetchBlobAttributes FileRequestOptions options = RequestOptions; await localChannel.FetchFileAttributesAsync(file, null, options, OperationContext, CmdletCancellationToken); if (file.CopyState == null || string.IsNullOrEmpty(file.CopyState.CopyId)) { ArgumentException e = new ArgumentException(String.Format(Resources.FileCopyTaskNotFound, file.Uri.ToString())); OutputStream.WriteError(taskId, e); } else { abortCopyId = file.CopyState.CopyId; } if (!Force) { string confirmation = String.Format(Resources.ConfirmAbortFileCopyOperation, file.Uri.ToString(), abortCopyId); if (!await OutputStream.ConfirmAsync(confirmation)) { string cancelMessage = String.Format(Resources.StopCopyOperationCancelled, file.Uri.ToString()); OutputStream.WriteVerbose(taskId, cancelMessage); } } } else { abortCopyId = copyId; } await localChannel.AbortCopyAsync(file, abortCopyId, null, requestOptions, OperationContext, CmdletCancellationToken); string message = String.Format(Resources.StopCopyFileSuccessfully, file.Uri.ToString()); OutputStream.WriteObject(taskId, message); }
/// <summary> /// Initializes a new instance of the <see cref="FileReadStreamBase"/> class. /// </summary> /// <param name="file">File reference to read from</param> /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the access conditions for the file. If <c>null</c>, no condition is used.</param> /// <param name="options">An <see cref="FileRequestOptions"/> object that specifies additional options for the request.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param> protected FileReadStreamBase(CloudFile file, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext) { if (options.UseTransactionalMD5.Value) { CommonUtility.AssertInBounds("StreamMinimumReadSizeInBytes", file.StreamMinimumReadSizeInBytes, 1, Constants.MaxRangeGetContentMD5Size); } this.file = file; this.fileProperties = new FileProperties(file.Properties); this.currentOffset = 0; this.streamMinimumReadSizeInBytes = this.file.StreamMinimumReadSizeInBytes; this.internalBuffer = new MultiBufferMemoryStream(file.ServiceClient.BufferManager); this.accessCondition = accessCondition; this.options = options; this.operationContext = operationContext; this.fileMD5 = (this.options.DisableContentMD5Validation.Value || string.IsNullOrEmpty(this.fileProperties.ContentMD5)) ? null : new MD5Wrapper(); this.lastException = null; }
internal static void SetFile(ref SerializableCloudFile fileSerialization, CloudFile value) { if (null == fileSerialization && null == value) { return; } if (null != fileSerialization) { fileSerialization.File = value; } else { fileSerialization = new SerializableCloudFile() { File = value }; } }
public void StartCopyFromInvalidContext() { string destShareName = Utility.GenNameString("destshare"); CloudFileShare destShare = fileUtil.EnsureFileShareExists(destShareName); string sourceShareName = Utility.GenNameString("sourceshare"); CloudFileShare sourceShare = fileUtil.EnsureFileShareExists(sourceShareName); try { StorageFile.CloudFile sourceFile = fileUtil.CreateFile(sourceShare.GetRootDirectoryReference(), Utility.GenNameString("SourceFile")); object destContext; if (lang == Language.PowerShell) { destContext = PowerShellAgent.GetStorageContext(StorageAccount.ToString(true)); } else { destContext = NodeJSAgent.GetStorageContext(StorageAccount.ToString(true)); } string sasToken = sourceShare.GetSharedAccessSignature(new SharedAccessFilePolicy() { Permissions = SharedAccessFilePermissions.Write, SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddHours(1) }); CommandAgent.SetStorageContextWithSASToken(StorageAccount.Credentials.AccountName, sasToken); string destFileName = Utility.GenNameString("destfile"); Test.Assert(!CommandAgent.StartFileCopyFromFile(sourceShareName, sourceFile.Name, destShareName, destFileName, destContext), "Copy to file with invalid sas token credential should fail."); ExpectedContainErrorMessage("This request is not authorized to perform this operation using this permission."); } finally { fileUtil.DeleteFileShareIfExists(sourceShareName); fileUtil.DeleteFileShareIfExists(destShareName); } }
/// <summary> /// Initializes a new instance of the FileWriteStreamBase 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 <see cref="AccessCondition"/> object that represents the access conditions for the file. If <c>null</c>, no condition is used.</param> /// <param name="options">An <see cref="FileRequestOptions"/> object that specifies additional options for the request.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param> protected FileWriteStreamBase(CloudFile file, long fileSize, bool createNew, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext) : base() { this.internalBuffer = new MultiBufferMemoryStream(file.ServiceClient.BufferManager); this.currentOffset = 0; this.accessCondition = accessCondition; this.options = options; this.operationContext = operationContext; this.noPendingWritesEvent = new CounterEvent(); this.fileMD5 = this.options.StoreFileContentMD5.Value ? new MD5Wrapper() : null; this.rangeMD5 = this.options.UseTransactionalMD5.Value ? new MD5Wrapper() : null; this.parallelOperationSemaphore = new AsyncSemaphore(options.ParallelOperationThreadCount.Value); this.lastException = null; this.committed = false; this.disposed = false; this.currentFileOffset = 0; this.file = file; this.fileSize = fileSize; this.streamWriteSizeInBytes = file.StreamWriteSizeInBytes; this.newFile = createNew; }
public void StopFinishedCopyFromFileTest() { string srcShareName = Utility.GenNameString("share"); CloudFileShare srcShare = fileUtil.EnsureFileShareExists(srcShareName); string destContainerName = Utility.GenNameString("container"); CloudBlobContainer destContainer = blobUtil.CreateContainer(destContainerName); try { string fileName = Utility.GenNameString("fileName"); StorageFile.CloudFile file = fileUtil.CreateFile(srcShare.GetRootDirectoryReference(), fileName); CloudBlockBlob blob = destContainer.GetBlockBlobReference(Utility.GenNameString("destBlobName")); Test.Assert(CommandAgent.StartAzureStorageBlobCopy(file, destContainer.Name, blob.Name, PowerShellAgent.Context), "Start azure storage copy from file to blob should succeed."); while (true) { blob.FetchAttributes(); if (blob.CopyState.Status != CopyStatus.Pending) { break; } Thread.Sleep(2000); } Test.Assert(!CommandAgent.StopAzureStorageBlobCopy(destContainerName, blob.Name, null, true), "Stop blob copy should fail"); ExpectedContainErrorMessage("There is currently no pending copy operation."); } finally { fileUtil.DeleteFileShareIfExists(srcShareName); blobUtil.RemoveContainer(destContainerName); } }
private static string GetFileSASToken(CloudFile file) { if (null == file.ServiceClient.Credentials || file.ServiceClient.Credentials.IsAnonymous) { return string.Empty; } else if (file.ServiceClient.Credentials.IsSAS) { return file.ServiceClient.Credentials.SASToken; } // SAS life time is at least 10 minutes. TimeSpan sasLifeTime = TimeSpan.FromMinutes(CopySASLifeTimeInMinutes); SharedAccessFilePolicy policy = new SharedAccessFilePolicy() { SharedAccessExpiryTime = DateTime.Now.Add(sasLifeTime), Permissions = SharedAccessFilePermissions.Read, }; return file.GetSharedAccessSignature(policy); }
private bool CloudFileDirectorySetup(CloudFileShare share) { try { CloudFileDirectory rootDirectory = share.GetRootDirectoryReference(); for (int i = 1; i < 3; i++) { CloudFileDirectory topDirectory = rootDirectory.GetDirectoryReference("TopDir" + i); topDirectory.Create(); for (int j = 1; j < 3; j++) { CloudFileDirectory midDirectory = topDirectory.GetDirectoryReference("MidDir" + j); midDirectory.Create(); for (int k = 1; k < 3; k++) { CloudFileDirectory endDirectory = midDirectory.GetDirectoryReference("EndDir" + k); endDirectory.Create(); CloudFile file1 = endDirectory.GetFileReference("EndFile" + k); file1.Create(0); } } CloudFile file2 = topDirectory.GetFileReference("File" + i); file2.Create(0); } return(true); } catch (StorageException e) { throw e; } }
public void CloudFileDirectoryDelimitersInARow() { CloudFileClient client = GenerateCloudFileClient(); string name = GetRandomShareName(); CloudFileShare share = client.GetShareReference(name); CloudFile file = share.GetRootDirectoryReference().GetFileReference(NavigationHelper.Slash + NavigationHelper.Slash + NavigationHelper.Slash + "File1"); ////Traverse from leaf to root CloudFileDirectory directory1 = file.Parent; Assert.AreEqual(directory1.Name, NavigationHelper.Slash + NavigationHelper.Slash + NavigationHelper.Slash); CloudFileDirectory directory2 = directory1.Parent; Assert.AreEqual(directory2.Name, NavigationHelper.Slash + NavigationHelper.Slash); CloudFileDirectory directory3 = directory2.Parent; Assert.AreEqual(directory3.Name, NavigationHelper.Slash); ////Traverse from root to leaf CloudFileDirectory directory4 = share.GetRootDirectoryReference().GetDirectoryReference(NavigationHelper.Slash); CloudFileDirectory directory5 = directory4.GetDirectoryReference(NavigationHelper.Slash); Assert.AreEqual(directory5.Name, NavigationHelper.Slash + NavigationHelper.Slash); CloudFileDirectory directory6 = directory5.GetDirectoryReference(NavigationHelper.Slash); Assert.AreEqual(directory6.Name, NavigationHelper.Slash + NavigationHelper.Slash + NavigationHelper.Slash); CloudFile file2 = directory6.GetFileReference("File1"); Assert.AreEqual(file2.Name, NavigationHelper.Slash + NavigationHelper.Slash + NavigationHelper.Slash + "File1"); Assert.AreEqual(file2.Uri, file.Uri); }
private async Task DoDownloadRangeToByteArrayNegativeTestsAsync(CloudFile file) { int fileLength = 1024; int resultBufSize = 1024; byte[] buffer = GetRandomBuffer(fileLength); byte[] resultBuffer = new byte[resultBufSize]; using (MemoryStream stream = new MemoryStream(buffer)) { await file.UploadFromStreamAsync(stream); OperationContext context = new OperationContext(); await TestHelper.ExpectedExceptionAsync(async () => await file.DownloadRangeToByteArrayAsync(resultBuffer, 0, 1024, 1, null, null, context), context, "Try invalid length", HttpStatusCode.RequestedRangeNotSatisfiable); StorageException ex = await TestHelper.ExpectedExceptionAsync<StorageException>(async () => await file.DownloadToByteArrayAsync(resultBuffer, 1024), "Provide invalid offset"); Assert.IsInstanceOfType(ex.InnerException, typeof(NotSupportedException)); ex = await TestHelper.ExpectedExceptionAsync<StorageException>(async () => await file.DownloadRangeToByteArrayAsync(resultBuffer, 1023, 0, 2), "Should fail when offset + length required is greater than size of the buffer"); Assert.IsInstanceOfType(ex.InnerException, typeof(NotSupportedException)); ex = await TestHelper.ExpectedExceptionAsync<StorageException>(async () => await file.DownloadRangeToByteArrayAsync(resultBuffer, 0, 0, -10), "Fail when a negative length is specified"); Assert.IsInstanceOfType(ex.InnerException, typeof(ArgumentOutOfRangeException)); await TestHelper.ExpectedExceptionAsync<ArgumentOutOfRangeException>(async () => await file.DownloadRangeToByteArrayAsync(resultBuffer, -10, 0, 20), "Fail if a negative offset is provided"); ex = await TestHelper.ExpectedExceptionAsync<StorageException>(async () => await file.DownloadRangeToByteArrayAsync(resultBuffer, 0, -10, 20), "Fail if a negative file offset is provided"); Assert.IsInstanceOfType(ex.InnerException, typeof(ArgumentOutOfRangeException)); } }
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(); } }
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 async Task FileDownloadToStreamRangeTestAsync() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudFile file = this.testShare.GetRootDirectoryReference().GetFileReference("file1"); using (MemoryStream wholeFile = new MemoryStream(buffer)) { await file.UploadFromStreamAsync(wholeFile); byte[] testBuffer = new byte[1024]; MemoryStream fileStream = new MemoryStream(testBuffer); Exception ex = await TestHelper.ExpectedExceptionAsync <Exception>( async() => await file.DownloadRangeToStreamAsync(fileStream, 0, 0), "Requesting 0 bytes when downloading range should not work"); Assert.IsInstanceOfType(ex.InnerException, typeof(ArgumentOutOfRangeException)); await file.DownloadRangeToStreamAsync(fileStream, 0, 1024); Assert.AreEqual(fileStream.Position, 1024); TestHelper.AssertStreamsAreEqualAtIndex(fileStream, wholeFile, 0, 0, 1024); CloudFile file2 = this.testShare.GetRootDirectoryReference().GetFileReference("file1"); MemoryStream fileStream2 = new MemoryStream(testBuffer); ex = await TestHelper.ExpectedExceptionAsync <Exception>( async() => await file2.DownloadRangeToStreamAsync(fileStream, 1024, 0), "Requesting 0 bytes when downloading range should not work"); Assert.IsInstanceOfType(ex.InnerException, typeof(ArgumentOutOfRangeException)); await file2.DownloadRangeToStreamAsync(fileStream2, 1024, 1024); TestHelper.AssertStreamsAreEqualAtIndex(fileStream2, wholeFile, 0, 1024, 1024); AssertAreEqual(file, file2); } }
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; } } }
/// <summary> /// Write copy progress /// </summary> /// <param name="file">CloudFile instance</param> /// <param name="progress">Progress record</param> internal void WriteCopyProgress(CloudFile file, ProgressRecord progress) { if (file.CopyState == null) return; long bytesCopied = file.CopyState.BytesCopied ?? 0; long totalBytes = file.CopyState.TotalBytes ?? 0; int percent = 0; if (totalBytes != 0) { percent = (int)(bytesCopied * 100 / totalBytes); progress.PercentComplete = percent; } string activity = String.Format(Resources.CopyFileStatus, file.CopyState.Status.ToString(), file.GetFullPath(), file.Share.Name, file.CopyState.Source.ToString()); progress.Activity = activity; string message = String.Format(Resources.CopyPendingStatus, percent, file.CopyState.BytesCopied, file.CopyState.TotalBytes); progress.StatusDescription = message; OutputStream.WriteProgress(progress); }
public Task<bool> FileExistsAsync(CloudFile file, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { return file.ExistsAsync(options, operationContext, cancellationToken); }
/// <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) { }
public virtual ICancellableAsyncResult BeginStartCopy(CloudFile source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { return this.BeginStartCopy(CloudFile.SourceFileToUri(source), sourceAccessCondition, destAccessCondition, options, operationContext, callback, state); }
public virtual Task<string> StartCopyAsync(CloudFile source, CancellationToken cancellationToken) { return AsyncExtensions.TaskFromApm(this.BeginStartCopy, this.EndStartCopy, source, cancellationToken); }
public async Task CloudFileListRangesAsync() { byte[] buffer = GetRandomBuffer(1024); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); await file.CreateAsync(4 * 1024); using (MemoryStream memoryStream = new MemoryStream(buffer)) { await file.WriteRangeAsync(memoryStream.AsInputStream(), 512, null); } using (MemoryStream memoryStream = new MemoryStream(buffer)) { await file.WriteRangeAsync(memoryStream.AsInputStream(), 3 * 1024, null); } await file.ClearRangeAsync(1024, 1024); await file.ClearRangeAsync(0, 512); IEnumerable <FileRange> fileRanges = await file.ListRangesAsync(); List <string> expectedFileRanges = new List <string>() { new FileRange(512, 1023).ToString(), new FileRange(3 * 1024, 4 * 1024 - 1).ToString(), }; foreach (FileRange fileRange in fileRanges) { Assert.IsTrue(expectedFileRanges.Remove(fileRange.ToString())); } Assert.AreEqual(0, expectedFileRanges.Count); fileRanges = await file.ListRangesAsync(1024, 1024, null, null, null); Assert.AreEqual(0, fileRanges.Count()); fileRanges = await file.ListRangesAsync(512, 3 * 1024, null, null, null); expectedFileRanges = new List <string>() { new FileRange(512, 1023).ToString(), new FileRange(3 * 1024, 7 * 512 - 1).ToString(), }; foreach (FileRange fileRange in fileRanges) { Assert.IsTrue(expectedFileRanges.Remove(fileRange.ToString())); } Assert.AreEqual(0, expectedFileRanges.Count); OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await file.ListRangesAsync(1024, null, null, null, opContext), opContext, "List Ranges with an offset but no count should fail", HttpStatusCode.Unused); Assert.IsInstanceOfType(opContext.LastResult.Exception.InnerException, typeof(ArgumentNullException)); } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
public virtual string StartCopy(CloudFile source, AccessCondition sourceAccessCondition = null, AccessCondition destAccessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null) { return this.StartCopy(CloudFile.SourceFileToUri(source), sourceAccessCondition, destAccessCondition, options, operationContext); }
/// <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) { }
internal FileReadStream(CloudFile file, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext) : base(file, accessCondition, options, operationContext) { throw new System.NotImplementedException(); }
public void CloudFileSASSharedProtocolsQueryParam() { 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 }; byte[] target = new byte[4]; fileWithKey.UploadFromByteArray(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 = Uri.UriSchemeHttp, port = httpPort }, new { scheme = Uri.UriSchemeHttps, 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, Uri.UriSchemeHttp) == 0) { file = new CloudFile(fileSASUri); TestHelper.ExpectedException(() => file.FetchAttributes(), "Access a file using SAS with a shared protocols that does not match", HttpStatusCode.Unused); file = new CloudFile(fileSASStorageUri, null); TestHelper.ExpectedException(() => file.FetchAttributes(), "Access a file using SAS with a shared protocols that does not match", HttpStatusCode.Unused); } else { 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]); } 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]); } } } } } finally { share.DeleteIfExists(); } }
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 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 virtual Task<string> StartCopyAsync(CloudFile source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { return AsyncExtensions.TaskFromApm(this.BeginStartCopy, this.EndStartCopy, source, sourceAccessCondition, destAccessCondition, options, operationContext, cancellationToken); }
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 (var 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 (var 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 CloudFileWriteRangeAsync() { byte[] buffer = GetRandomBuffer(4 * 1024 * 1024); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); await file.CreateAsync(4 * 1024 * 1024); using (MemoryStream memoryStream = new MemoryStream()) { await TestHelper.ExpectedExceptionAsync <ArgumentOutOfRangeException>( async() => await file.WriteRangeAsync(memoryStream, 0, null), "Zero-length WriteRange should fail"); } using (MemoryStream resultingData = new MemoryStream()) { using (MemoryStream memoryStream = new MemoryStream(buffer)) { OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await file.WriteRangeAsync(memoryStream, 512, null, null, null, opContext), opContext, "Writing out-of-range ranges should fail", HttpStatusCode.RequestedRangeNotSatisfiable, "InvalidRange"); memoryStream.Seek(0, SeekOrigin.Begin); await file.WriteRangeAsync(memoryStream, 0, null); resultingData.Write(buffer, 0, buffer.Length); int offset = buffer.Length - 1024; memoryStream.Seek(offset, SeekOrigin.Begin); await file.WriteRangeAsync(memoryStream, 0, null); resultingData.Seek(0, SeekOrigin.Begin); resultingData.Write(buffer, offset, buffer.Length - offset); offset = buffer.Length - 2048; memoryStream.Seek(offset, SeekOrigin.Begin); await file.WriteRangeAsync(memoryStream, 1024, null); resultingData.Seek(1024, SeekOrigin.Begin); resultingData.Write(buffer, offset, buffer.Length - offset); } using (MemoryStream fileData = new MemoryStream()) { await file.DownloadToStreamAsync(fileData); Assert.AreEqual(resultingData.Length, fileData.Length); Assert.IsTrue(fileData.ToArray().SequenceEqual(resultingData.ToArray())); } } } finally { share.DeleteIfExistsAsync().Wait(); } }
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 (var 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 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 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 CloudFileWriteRangeAsync() { byte[] buffer = GetRandomBuffer(4 * 1024 * 1024); CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); hasher.Append(buffer.AsBuffer()); string contentMD5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); await file.CreateAsync(4 * 1024 * 1024); using (MemoryStream memoryStream = new MemoryStream()) { await TestHelper.ExpectedExceptionAsync <ArgumentOutOfRangeException>( async() => await file.WriteRangeAsync(memoryStream.AsInputStream(), 0, null), "Zero-length WriteRange should fail"); memoryStream.SetLength(4 * 1024 * 1024 + 1); await TestHelper.ExpectedExceptionAsync <ArgumentOutOfRangeException>( async() => await file.WriteRangeAsync(memoryStream.AsInputStream(), 0, null), ">4MB WriteRange should fail"); } using (MemoryStream resultingData = new MemoryStream()) { using (MemoryStream memoryStream = new MemoryStream(buffer)) { OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await file.WriteRangeAsync(memoryStream.AsInputStream(), 512, null, null, null, opContext), opContext, "Writing out-of-range ranges should fail", HttpStatusCode.RequestedRangeNotSatisfiable, "InvalidFileRange"); memoryStream.Seek(0, SeekOrigin.Begin); await file.WriteRangeAsync(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 file.WriteRangeAsync(memoryStream.AsInputStream(), 0, contentMD5, null, null, opContext), opContext, "Invalid MD5 should fail with mismatch", HttpStatusCode.BadRequest, "Md5Mismatch"); memoryStream.Seek(offset, SeekOrigin.Begin); await file.WriteRangeAsync(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 file.WriteRangeAsync(memoryStream.AsInputStream(), 1024, null); resultingData.Seek(1024, SeekOrigin.Begin); resultingData.Write(buffer, offset, buffer.Length - offset); } using (MemoryStream fileData = new MemoryStream()) { await file.DownloadToStreamAsync(fileData.AsOutputStream()); Assert.AreEqual(resultingData.Length, fileData.Length); Assert.IsTrue(fileData.ToArray().SequenceEqual(resultingData.ToArray())); } } } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudFileInvalidApisInShareSnapshotAsync() { CloudFileClient client = GenerateCloudFileClient(); string name = GetRandomShareName(); CloudFileShare share = client.GetShareReference(name); await share.CreateAsync(); CloudFileShare snapshot = share.SnapshotAsync().Result; CloudFile file = snapshot.GetRootDirectoryReference().GetDirectoryReference("dir1").GetFileReference("file"); try { await file.CreateAsync(1024); Assert.Fail("API should fail in a snapshot"); } catch (InvalidOperationException e) { Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message); } try { await file.DeleteAsync(); Assert.Fail("API should fail in a snapshot"); } catch (InvalidOperationException e) { Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message); } try { await file.SetMetadataAsync(); Assert.Fail("API should fail in a snapshot"); } catch (InvalidOperationException e) { Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message); } try { await file.AbortCopyAsync(null); Assert.Fail("API should fail in a snapshot"); } catch (InvalidOperationException e) { Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message); } try { await file.ClearRangeAsync(0, 1024); Assert.Fail("API should fail in a snapshot"); } catch (InvalidOperationException e) { Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message); } try { await file.StartCopyAsync(file); Assert.Fail("API should fail in a snapshot"); } catch (InvalidOperationException e) { Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message); } try { await file.UploadFromByteArrayAsync(new byte[1024], 0, 1024); Assert.Fail("API should fail in a snapshot"); } catch (InvalidOperationException e) { Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message); } await snapshot.DeleteAsync(); await share.DeleteAsync(); }
public virtual ICancellableAsyncResult BeginStartCopy(CloudFile source, AsyncCallback callback, object state) { return this.BeginStartCopy(CloudFile.SourceFileToUri(source), callback, state); }
public async Task CloudFileSetPropertiesAsync() { CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); await file.CreateAsync(1024); string eTag = file.Properties.ETag; DateTimeOffset lastModified = file.Properties.LastModified.Value; await Task.Delay(1000); file.Properties.CacheControl = "no-transform"; #if !ASPNET_K file.Properties.ContentEncoding = "gzip"; #endif file.Properties.ContentLanguage = "tr,en"; file.Properties.ContentMD5 = "MDAwMDAwMDA="; file.Properties.ContentType = "text/html"; await file.SetPropertiesAsync(); Assert.IsTrue(file.Properties.LastModified > lastModified); Assert.AreNotEqual(eTag, file.Properties.ETag); CloudFile file2 = share.GetRootDirectoryReference().GetFileReference("file1"); await file2.FetchAttributesAsync(); Assert.AreEqual("no-transform", file2.Properties.CacheControl); #if !ASPNET_K Assert.AreEqual("gzip", file2.Properties.ContentEncoding); #endif Assert.AreEqual("tr,en", file2.Properties.ContentLanguage); Assert.AreEqual("MDAwMDAwMDA=", file2.Properties.ContentMD5); Assert.AreEqual("text/html", file2.Properties.ContentType); CloudFile file3 = share.GetRootDirectoryReference().GetFileReference("file1"); using (MemoryStream stream = new MemoryStream()) { FileRequestOptions options = new FileRequestOptions() { DisableContentMD5Validation = true, }; await file3.DownloadToStreamAsync(stream, null, options, null); } AssertAreEqual(file2.Properties, file3.Properties); CloudFileDirectory rootDirectory = share.GetRootDirectoryReference(); IEnumerable <IListFileItem> results = await ListFilesAndDirectoriesAsync(rootDirectory, null, null, null); CloudFile file4 = (CloudFile)results.First(); Assert.AreEqual(file2.Properties.Length, file4.Properties.Length); } finally { share.DeleteIfExistsAsync().Wait(); } }
public virtual Task<string> StartCopyAsync(CloudFile source) { return this.StartCopyAsync(source, CancellationToken.None); }
/// <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 <see cref="AccessCondition"/> object that represents the access conditions for the file. If <c>null</c>, no condition is used.</param> /// <param name="options">An <see cref="FileRequestOptions"/> object that specifies additional options for the request.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param> internal FileWriteStream(CloudFile file, long fileSize, bool createNew, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext) : base(file, fileSize, createNew, accessCondition, options, operationContext) { }
public virtual Task<string> StartCopyAsync(CloudFile source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, BlobRequestOptions options, OperationContext operationContext) { return this.StartCopyAsync(source, sourceAccessCondition, destAccessCondition, options, operationContext, CancellationToken.None); }
public Task<bool> FileExistsAsync(CloudFile file, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { return TaskEx.FromResult(true); }
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(); } }
public Task DeleteFileAsync(CloudFile file, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { return TaskEx.FromResult(true); }
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 Task DeleteFileAsync(CloudFile file, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { return file.DeleteAsync(accessCondition, options, operationContext, cancellationToken); }
/// <summary> /// Single put file and get file. /// </summary> /// <param name="fileSize">The file size.</param> /// <param name="bufferSize">The output buffer size.</param> /// <param name="bufferOffset">The output buffer offset.</param> /// <param name="fileOffset">The file offset.</param> /// <param name="length">Length of the data range to download.</param> /// <param name="isOverload">True when the overloaded method for DownloadRangeToByteArrayAsync is called. False when the basic method is called.</param> private async Task DoDownloadRangeToByteArrayAsyncTest(CloudFile file, int fileSize, int bufferSize, int bufferOffset, long? fileOffset, long? length, bool isOverload) { int downloadLength; byte[] buffer = GetRandomBuffer(fileSize); byte[] resultBuffer = new byte[bufferSize]; byte[] resultBuffer2 = new byte[bufferSize]; using (MemoryStream originalFile = new MemoryStream(buffer)) { if (!isOverload) { await file.UploadFromStreamAsync(originalFile); downloadLength = await file.DownloadRangeToByteArrayAsync(resultBuffer, bufferOffset, fileOffset, length); } else { await file.UploadFromStreamAsync(originalFile); OperationContext context = new OperationContext(); downloadLength = await file.DownloadRangeToByteArrayAsync(resultBuffer, bufferOffset, fileOffset, length, null, null, context); } int downloadSize = Math.Min(fileSize - (int)(fileOffset.HasValue ? fileOffset.Value : 0), bufferSize - bufferOffset); if (length.HasValue && (length.Value < downloadSize)) { downloadSize = (int)length.Value; } Assert.AreEqual(downloadSize, downloadLength); for (int i = 0; i < bufferOffset; i++) { Assert.AreEqual(0, resultBuffer[i]); } for (int j = 0; j < downloadLength; j++) { Assert.AreEqual(buffer[(fileOffset.HasValue ? fileOffset.Value : 0) + j], resultBuffer[bufferOffset + j]); } for (int k = bufferOffset + downloadLength; k < bufferSize; k++) { Assert.AreEqual(0, resultBuffer[k]); } } }