public AzureOperations(string connectionString, string shareName) { var account = CloudStorageAccount.Parse(connectionString); client = account.CreateCloudFileClient(); share = client.GetShareReference(shareName); share.CreateIfNotExists(); root = share.GetRootDirectoryReference(); }
public void TestCleanup() { this.testShare.Delete(); this.testShare = null; if (TestBase.FileBufferManager != null) { Assert.AreEqual(0, TestBase.FileBufferManager.OutstandingBufferCount); } }
public void TestInitialize() { this.testShare = GetRandomShareReference(); this.testShare.Create(); if (TestBase.FileBufferManager != null) { TestBase.FileBufferManager.OutstandingBufferCount = 0; } }
public async Task TestInitialize() { this.testShare = GetRandomShareReference(); await this.testShare.CreateIfNotExistsAsync(); if (TestBase.FileBufferManager != null) { TestBase.FileBufferManager.OutstandingBufferCount = 0; } }
public Task FetchShareAttributesAsync(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken token) { if (this.availableShareNames.Contains(share.Name)) { return TaskEx.FromResult(true); } else { throw new MockupException("ShareNotExist"); } }
/// <summary> /// Initializes a new instance of the <see cref="CloudFileDirectory"/> class given an address and a client. /// </summary> /// <param name="uri">The file directory's Uri.</param> /// <param name="directoryName">Name of the directory.</param> /// <param name="share">The share for the directory.</param> internal CloudFileDirectory(StorageUri uri, string directoryName, CloudFileShare share) { CommonUtility.AssertNotNull("uri", uri); CommonUtility.AssertNotNull("directoryName", directoryName); CommonUtility.AssertNotNull("share", share); this.Properties = new FileDirectoryProperties(); this.StorageUri = uri; this.ServiceClient = share.ServiceClient; this.share = share; this.Name = directoryName; }
/// <summary> /// Initializes a new instance of the <see cref="CloudFile"/> class using the specified file name and /// the parent share reference. /// </summary> /// <param name="uri">The file's Uri.</param> /// <param name="fileName">Name of the file.</param> /// <param name="share">The reference to the parent share.</param> internal CloudFile(StorageUri uri, string fileName, CloudFileShare share) { CommonUtility.AssertNotNull("uri", uri); CommonUtility.AssertNotNullOrEmpty("fileName", fileName); CommonUtility.AssertNotNull("share", share); this.attributes = new CloudFileAttributes(); this.attributes.StorageUri = uri; this.ServiceClient = share.ServiceClient; this.share = share; this.Name = fileName; }
public FileStorage(string fileShareName, string storageConnectionString ) { Validate.String(fileShareName, "fileShareName"); Validate.String(storageConnectionString, "storageConnectionString"); var cloudStorageAccount = CloudStorageAccount.Parse(storageConnectionString); var fileClient = cloudStorageAccount.CreateCloudFileClient(); cloudFileShare = fileClient.GetShareReference(fileShareName); cloudFileShare.CreateIfNotExists(); }
public static async Task<List<string>> CreateFilesAsync(CloudFileShare share, int count) { string name; List<string> files = new List<string>(); for (int i = 0; i < count; i++) { name = "ff" + Guid.NewGuid().ToString(); CloudFile file = share.GetRootDirectoryReference().GetFileReference(name); await file.CreateAsync(0); files.Add(name); } return files; }
public AzureSession(string connectionString, string shareName, string systemDir, int waitForLockMilliseconds = 5000, bool optimisticLocking = true, bool enableCache = true, CacheEnum objectCachingDefaultPolicy = CacheEnum.Yes) : base(systemDir, waitForLockMilliseconds, optimisticLocking, enableCache, objectCachingDefaultPolicy) { m_cloudStorageAccount = CloudStorageAccount.Parse(connectionString); if (Path.IsPathRooted(systemDir) == false) SystemDirectory = systemDir; m_shareName = shareName; m_cloudFileClient = m_cloudStorageAccount.CreateCloudFileClient(); m_cloudShare = m_cloudFileClient.GetShareReference(shareName); if (m_cloudShare.Exists()) { m_rootDir = m_cloudShare.GetRootDirectoryReference(); m_databaseDir = m_rootDir.GetDirectoryReference(systemDir); m_databaseDir.CreateIfNotExists(); } }
private void Initialise(LoggingEvent loggingEvent) { if (_storageAccount == null || AzureStorageConnectionString != _thisConnectionString) { _storageAccount = CloudStorageAccount.Parse(AzureStorageConnectionString); _thisConnectionString = AzureStorageConnectionString; _client = null; _share = null; _folder = null; _file = null; } if (_client == null) { _client = _storageAccount.CreateCloudFileClient(); _share = null; _folder = null; _file = null; } if (_share == null || _share.Name != ShareName) { _share = _client.GetShareReference(ShareName); _share.CreateIfNotExists(); _folder = null; _file = null; } if (_folder == null || Path != _thisFolder) { var pathElements = Path.Split(new[] {'\\', '/'}, StringSplitOptions.RemoveEmptyEntries); _folder = _share.GetRootDirectoryReference(); foreach (var element in pathElements) { _folder = _folder.GetDirectoryReference(element); _folder.CreateIfNotExists(); } _thisFolder = Path; _file = null; } var filename = Regex.Replace(File, @"\{(.+?)\}", _ => loggingEvent.TimeStamp.ToString(_.Result("$1"))); if (_file == null || filename != _thisFile) { _file = _folder.GetFileReference(filename); if (!_file.Exists()) _file.Create(0); _thisFile = filename; } }
public async Task CloudFileDirectoryGetParentAsync() { CloudFileClient client = GenerateCloudFileClient(); string name = GetRandomShareName(); CloudFileShare share = client.GetShareReference(name); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetDirectoryReference("Dir1").GetFileReference("File1"); Assert.AreEqual("File1", file.Name); // get the file's parent CloudFileDirectory parent = file.Parent; Assert.AreEqual(parent.Name, "Dir1"); // get share as parent CloudFileDirectory root = parent.Parent; Assert.AreEqual(root.Name, ""); // make sure the parent of the share dir is null CloudFileDirectory empty = root.Parent; Assert.IsNull(empty); // from share, get directory reference to share root = share.GetRootDirectoryReference(); Assert.AreEqual("", root.Name); Assert.AreEqual(share.Uri.AbsoluteUri, root.Uri.AbsoluteUri); // make sure the parent of the share dir is null empty = root.Parent; Assert.IsNull(empty); } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
public void FileOpenReadTest() { 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 dstStream = file.OpenRead(); TestHelper.AssertStreamsAreEqual(srcStream, dstStream); } } finally { share.DeleteIfExists(); } }
public void CloudFileShareListFilesAndDirectoriesSegmentedAPM() { CloudFileShare share = GetRandomShareReference(); try { share.Create(); List <string> fileNames = CreateFiles(share, 3); CloudFileDirectory rootDirectory = share.GetRootDirectoryReference(); using (AutoResetEvent waitHandle = new AutoResetEvent(false)) { FileContinuationToken token = null; do { IAsyncResult result = rootDirectory.BeginListFilesAndDirectoriesSegmented(1, token, null, null, ar => waitHandle.Set(), null); waitHandle.WaitOne(); FileResultSegment results = rootDirectory.EndListFilesAndDirectoriesSegmented(result); int count = 0; foreach (IListFileItem fileItem in results.Results) { Assert.IsInstanceOfType(fileItem, typeof(CloudFile)); Assert.IsTrue(fileNames.Remove(((CloudFile)fileItem).Name)); count++; } Assert.IsTrue(count <= 1); token = results.ContinuationToken; }while (token != null); Assert.AreEqual(0, fileNames.Count); } } finally { share.DeleteIfExists(); } }
public void CloudFileDirectoryDeleteIfExistsAPM() { CloudFileShare share = GetRandomShareReference(); share.Create(); try { using (AutoResetEvent waitHandle = new AutoResetEvent(false)) { CloudFileDirectory directory = share.GetRootDirectoryReference().GetDirectoryReference("directory1"); IAsyncResult result = directory.BeginDeleteIfExists( ar => waitHandle.Set(), null); waitHandle.WaitOne(); Assert.IsFalse(directory.EndDeleteIfExists(result)); result = directory.BeginCreate( ar => waitHandle.Set(), null); waitHandle.WaitOne(); directory.EndCreate(result); result = directory.BeginDeleteIfExists( ar => waitHandle.Set(), null); waitHandle.WaitOne(); Assert.IsTrue(directory.EndDeleteIfExists(result)); result = directory.BeginDeleteIfExists( ar => waitHandle.Set(), null); waitHandle.WaitOne(); Assert.IsFalse(directory.EndDeleteIfExists(result)); } } finally { share.Delete(); } }
public async Task CloudFileDownloadToStreamCancelAsync() { byte[] buffer = GetRandomBuffer(1 * 1024 * 1024); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); using (MemoryStream originalFile = new MemoryStream(buffer)) { await file.UploadFromStreamAsync(originalFile); using (MemoryStream downloadedFile = new MemoryStream()) { OperationContext operationContext = new OperationContext(); CancellationTokenSource source = new CancellationTokenSource(100); Task task = file.DownloadToStreamAsync(downloadedFile, null, null, operationContext, source.Token); try { await task; } catch (Exception) { Assert.AreEqual(operationContext.LastResult.Exception.Message, "Operation was canceled by user."); Assert.AreEqual(operationContext.LastResult.HttpStatusCode, 306); //Assert.AreEqual(operationContext.LastResult.HttpStatusMessage, "Unused"); } TestHelper.AssertNAttempts(operationContext, 1); } } } finally { share.DeleteIfExistsAsync().Wait(); } }
public void CloudFileClientMaximumExecutionTimeout() { CloudFileClient fileClient = GenerateCloudFileClient(); CloudFileShare share = fileClient.GetShareReference(GetRandomShareName()); CloudFileDirectory rootDirectory = share.GetRootDirectoryReference(); byte[] buffer = FileTestBase.GetRandomBuffer(80 * 1024 * 1024); try { share.Create(); fileClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(5); CloudFile file = rootDirectory.GetFileReference("file1"); file.StreamWriteSizeInBytes = 1 * 1024 * 1024; using (MemoryStream ms = new MemoryStream(buffer)) { try { file.UploadFromStream(ms); Assert.Fail(); } catch (TimeoutException ex) { Assert.IsInstanceOfType(ex, typeof(TimeoutException)); } catch (StorageException ex) { Assert.IsInstanceOfType(ex.InnerException, typeof(TimeoutException)); } } } finally { fileClient.DefaultRequestOptions.MaximumExecutionTime = null; share.DeleteIfExists(); } }
public async Task CloudFileShareCreateWithMetadataAsync() { CloudFileShare share = GetRandomShareReference(); try { share.Metadata.Add("key1", "value1"); await share.CreateAsync(); CloudFileShare share2 = share.ServiceClient.GetShareReference(share.Name); await share2.FetchAttributesAsync(); Assert.AreEqual(1, share2.Metadata.Count); Assert.AreEqual("value1", share2.Metadata["key1"]); Assert.IsTrue(share2.Properties.LastModified.Value.AddHours(1) > DateTimeOffset.Now); Assert.IsNotNull(share2.Properties.ETag); } finally { share.DeleteIfExistsAsync().Wait(); } }
public async Task CloudFileCreateWithMetadataAsync() { CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); file.Metadata["key1"] = "value1"; await file.CreateAsync(1024); CloudFile file2 = share.GetRootDirectoryReference().GetFileReference("file1"); await file2.FetchAttributesAsync(); Assert.AreEqual(1, file2.Metadata.Count); Assert.AreEqual("value1", file2.Metadata["key1"]); } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
public void CloudFileShareListFilesAndDirectories() { CloudFileShare share = GetRandomShareReference(); try { share.Create(); List <string> fileNames = CreateFiles(share, 3); CloudFileDirectory rootDirectory = share.GetRootDirectoryReference(); IEnumerable <IListFileItem> results = rootDirectory.ListFilesAndDirectories(); Assert.AreEqual(fileNames.Count, results.Count()); foreach (IListFileItem fileItem in results) { Assert.IsInstanceOfType(fileItem, typeof(CloudFile)); Assert.IsTrue(fileNames.Remove(((CloudFile)fileItem).Name)); } } finally { share.DeleteIfExists(); } }
public void FileOpenReadWriteTest() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudFileShare share = GetRandomShareReference(); try { share.Create(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); Stream fileStream = file.OpenWrite(2048); fileStream.Write(buffer, 0, 2048); fileStream.Close(); MemoryStream memoryStream = new MemoryStream(buffer); Stream dstStream = file.OpenRead(); TestHelper.AssertStreamsAreEqual(memoryStream, dstStream); } finally { share.DeleteIfExists(); } }
public async Task CloudFileUploadTimeoutAsync() { CloudFileShare share = DefaultFileClient.GetShareReference(Guid.NewGuid().ToString("N")); byte[] buffer = FileTestBase.GetRandomBuffer(4 * 1024 * 1024); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); FileRequestOptions requestOptions = new FileRequestOptions() { MaximumExecutionTime = TimeSpan.FromMilliseconds(10), RetryPolicy = new NoRetry() }; using (MemoryStream ms = new MemoryStream(buffer)) { await file.UploadFromStreamAsync(ms.AsInputStream(), null, requestOptions, null); } Assert.Fail(); } catch (Exception e) { #if ASPNET_K Assert.AreEqual(WindowsAzureErrorCode.TimeoutException, e.InnerException.InnerException.HResult); #else Assert.AreEqual(WindowsAzureErrorCode.HttpRequestTimeout, e.InnerException.InnerException.HResult); #endif } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
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 async Task FileWriteWhenOpenReadAsync() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); using (MemoryStream srcStream = new MemoryStream(buffer)) { await file.UploadFromStreamAsync(srcStream.AsInputStream()); bool thrown = false; byte[] testBuffer = new byte[2048]; using (var fileStream = await file.OpenReadAsync()) { Stream fileStreamForRead = fileStream.AsStreamForRead(); try { await fileStreamForRead.WriteAsync(testBuffer, 0, 2048); } catch (NotSupportedException) { thrown = true; } Assert.IsTrue(thrown); } } } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
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 CloudFileFetchAttributesAsync() { CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); await file.CreateAsync(1024); Assert.AreEqual(1024, file.Properties.Length); Assert.IsNotNull(file.Properties.ETag); Assert.IsTrue(file.Properties.LastModified > DateTimeOffset.UtcNow.AddMinutes(-5)); Assert.IsNull(file.Properties.CacheControl); Assert.IsNull(file.Properties.ContentEncoding); Assert.IsNull(file.Properties.ContentLanguage); Assert.IsNull(file.Properties.ContentType); Assert.IsNull(file.Properties.ContentMD5); CloudFile file2 = share.GetRootDirectoryReference().GetFileReference("file1"); await file2.FetchAttributesAsync(); Assert.AreEqual(1024, file2.Properties.Length); Assert.AreEqual(file.Properties.ETag, file2.Properties.ETag); Assert.AreEqual(file.Properties.LastModified, file2.Properties.LastModified); Assert.IsNull(file2.Properties.CacheControl); Assert.IsNull(file2.Properties.ContentEncoding); Assert.IsNull(file2.Properties.ContentLanguage); Assert.AreEqual("application/octet-stream", file2.Properties.ContentType); Assert.IsNull(file2.Properties.ContentMD5); } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
public void CopyFileUsingUnicodeFileName() { string _unicodeFileName = "繁体字14a6c"; string _nonUnicodeFileName = "sample_file"; CloudFileShare share = GetRandomShareReference(); try { share.Create(); CloudFile fileUnicodeSource = share.GetRootDirectoryReference().GetFileReference(_unicodeFileName); string data = "Test content"; UploadText(fileUnicodeSource, data, Encoding.UTF8); CloudFile fileAsciiSource = share.GetRootDirectoryReference().GetFileReference(_nonUnicodeFileName); UploadText(fileAsciiSource, data, Encoding.UTF8); //Copy files over CloudFile fileAsciiDest = share.GetRootDirectoryReference().GetFileReference(_nonUnicodeFileName + "_copy"); string copyId = fileAsciiDest.StartCopy(TestHelper.Defiddler(fileAsciiSource)); WaitForCopy(fileAsciiDest); CloudFile fileUnicodeDest = share.GetRootDirectoryReference().GetFileReference(_unicodeFileName + "_copy"); copyId = fileUnicodeDest.StartCopy(TestHelper.Defiddler(fileUnicodeSource)); WaitForCopy(fileUnicodeDest); Assert.AreEqual(CopyStatus.Success, fileUnicodeDest.CopyState.Status); Assert.AreEqual(fileUnicodeSource.Uri.AbsolutePath, fileUnicodeDest.CopyState.Source.AbsolutePath); Assert.AreEqual(data.Length, fileUnicodeDest.CopyState.TotalBytes); Assert.AreEqual(data.Length, fileUnicodeDest.CopyState.BytesCopied); Assert.AreEqual(copyId, fileUnicodeDest.CopyState.CopyId); Assert.IsTrue(fileUnicodeDest.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); } finally { share.DeleteIfExists(); } }
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 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; } }
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 void CloudFileDirectoryCreateDirectoryUsingPrefix() { CloudFileClient client = GenerateCloudFileClient(); string name = GetRandomShareName(); CloudFileShare share = client.GetShareReference(name); try { share.Create(); CloudFileDirectory dir1 = share.GetRootDirectoryReference().GetDirectoryReference("Dir1"); CloudFileDirectory dir2 = share.GetRootDirectoryReference().GetDirectoryReference("Dir1/Dir2"); TestHelper.ExpectedException( () => dir2.Create(), "Try to create directory hierarchy by specifying prefix", HttpStatusCode.NotFound); dir1.Create(); dir2.Create(); } finally { share.Delete(); } }
public void CloudFileShareExistsAPM() { CloudFileShare share = GetRandomShareReference(); CloudFileShare share2 = share.ServiceClient.GetShareReference(share.Name); using (AutoResetEvent waitHandle = new AutoResetEvent(false)) { IAsyncResult result = share2.BeginExists( ar => waitHandle.Set(), null); waitHandle.WaitOne(); Assert.IsFalse(share2.EndExists(result)); share.Create(); try { result = share2.BeginExists( ar => waitHandle.Set(), null); waitHandle.WaitOne(); Assert.IsTrue(share2.EndExists(result)); Assert.IsNotNull(share2.Properties.ETag); } finally { share.Delete(); } result = share2.BeginExists( ar => waitHandle.Set(), null); waitHandle.WaitOne(); Assert.IsFalse(share2.EndExists(result)); } }
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(); } }
public void CloudFileShareSetMetadataTask() { CloudFileShare share = GetRandomShareReference(); try { share.Create(); CloudFileShare share2 = share.ServiceClient.GetShareReference(share.Name); share2.FetchAttributesAsync().Wait(); Assert.AreEqual(0, share2.Metadata.Count); share.Metadata.Add("key1", "value1"); share.SetMetadataAsync().Wait(); share2.FetchAttributesAsync().Wait(); Assert.AreEqual(1, share2.Metadata.Count); Assert.AreEqual("value1", share2.Metadata["key1"]); CloudFileShare share3 = share.ServiceClient.ListSharesSegmentedAsync( share.Name, ShareListingDetails.Metadata, null, null, null, null).Result.Results.First(); Assert.AreEqual(1, share3.Metadata.Count); Assert.AreEqual("value1", share3.Metadata["key1"]); share.Metadata.Clear(); share.SetMetadataAsync().Wait(); share2.FetchAttributesAsync().Wait(); Assert.AreEqual(0, share2.Metadata.Count); } finally { share.DeleteIfExistsAsync().Wait(); } }
public Task DeleteShareAsync(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { return share.DeleteAsync(accessCondition, options, operationContext, cancellationToken); }
public Task DeleteShareAsync(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { return TaskEx.FromResult(true); }
private async Task CloudFileUploadFromStreamAsync(CloudFileShare share, int size, long? copyLength, AccessCondition accessCondition, OperationContext operationContext, int startOffset) { byte[] buffer = GetRandomBuffer(size); #if NETCORE MD5 hasher = MD5.Create(); string md5 = Convert.ToBase64String(hasher.ComputeHash(buffer, startOffset, copyLength.HasValue ? (int)copyLength : buffer.Length - startOffset)); #else CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); hasher.Append(buffer.AsBuffer(startOffset, copyLength.HasValue ? (int)copyLength.Value : buffer.Length - startOffset)); string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); #endif CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); file.StreamWriteSizeInBytes = 512; using (MemoryStream originalFileStream = new MemoryStream()) { originalFileStream.Write(buffer, startOffset, buffer.Length - startOffset); using (MemoryStream sourceStream = new MemoryStream(buffer)) { sourceStream.Seek(startOffset, SeekOrigin.Begin); FileRequestOptions options = new FileRequestOptions() { StoreFileContentMD5 = true, }; if (copyLength.HasValue) { await file.UploadFromStreamAsync(sourceStream, copyLength.Value, accessCondition, options, operationContext); } else { await file.UploadFromStreamAsync(sourceStream, accessCondition, options, operationContext); } } await file.FetchAttributesAsync(); Assert.AreEqual(md5, file.Properties.ContentMD5); using (MemoryStream downloadedFileStream = new MemoryStream()) { await file.DownloadToStreamAsync(downloadedFileStream); Assert.AreEqual(copyLength ?? originalFileStream.Length, downloadedFileStream.Length); TestHelper.AssertStreamsAreEqualAtIndex( originalFileStream, downloadedFileStream, 0, 0, copyLength.HasValue ? (int)copyLength : (int)originalFileStream.Length); } } }
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 Task<FileSharePermissions> GetSharePermissionsAsync(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { return share.GetPermissionsAsync(accessCondition, options, operationContext, cancellationToken); }
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 FileTypesWithStorageUri() { StorageUri endpoint = new StorageUri( new Uri("http://" + AccountName + FileService + EndpointSuffix), new Uri("http://" + AccountName + SecondarySuffix + FileService + EndpointSuffix)); CloudFileClient client = new CloudFileClient(endpoint, new StorageCredentials()); Assert.IsTrue(endpoint.Equals(client.StorageUri)); Assert.IsTrue(endpoint.PrimaryUri.Equals(client.BaseUri)); StorageUri shareUri = new StorageUri( new Uri(endpoint.PrimaryUri + "share"), new Uri(endpoint.SecondaryUri + "share")); CloudFileShare share = client.GetShareReference("share"); Assert.IsTrue(shareUri.Equals(share.StorageUri)); Assert.IsTrue(shareUri.PrimaryUri.Equals(share.Uri)); Assert.IsTrue(endpoint.Equals(share.ServiceClient.StorageUri)); share = new CloudFileShare(shareUri, client.Credentials); Assert.IsTrue(shareUri.Equals(share.StorageUri)); Assert.IsTrue(shareUri.PrimaryUri.Equals(share.Uri)); Assert.IsTrue(endpoint.Equals(share.ServiceClient.StorageUri)); StorageUri directoryUri = new StorageUri( new Uri(shareUri.PrimaryUri + "/directory"), new Uri(shareUri.SecondaryUri + "/directory")); StorageUri subdirectoryUri = new StorageUri( new Uri(directoryUri.PrimaryUri + "/subdirectory"), new Uri(directoryUri.SecondaryUri + "/subdirectory")); CloudFileDirectory directory = share.GetRootDirectoryReference().GetDirectoryReference("directory"); Assert.IsTrue(directoryUri.Equals(directory.StorageUri)); Assert.IsTrue(directoryUri.PrimaryUri.Equals(directory.Uri)); Assert.IsNotNull(directory.Parent); Assert.IsTrue(shareUri.Equals(directory.Share.StorageUri)); Assert.IsTrue(endpoint.Equals(directory.ServiceClient.StorageUri)); CloudFileDirectory subdirectory = directory.GetDirectoryReference("subdirectory"); Assert.IsTrue(subdirectoryUri.Equals(subdirectory.StorageUri)); Assert.IsTrue(subdirectoryUri.PrimaryUri.Equals(subdirectory.Uri)); Assert.IsTrue(directoryUri.Equals(subdirectory.Parent.StorageUri)); Assert.IsTrue(shareUri.Equals(subdirectory.Share.StorageUri)); Assert.IsTrue(endpoint.Equals(subdirectory.ServiceClient.StorageUri)); StorageUri fileUri = new StorageUri( new Uri(subdirectoryUri.PrimaryUri + "/file"), new Uri(subdirectoryUri.SecondaryUri + "/file")); CloudFile file = subdirectory.GetFileReference("file"); Assert.IsTrue(fileUri.Equals(file.StorageUri)); Assert.IsTrue(fileUri.PrimaryUri.Equals(file.Uri)); Assert.IsTrue(subdirectoryUri.Equals(file.Parent.StorageUri)); Assert.IsTrue(shareUri.Equals(file.Share.StorageUri)); Assert.IsTrue(endpoint.Equals(file.ServiceClient.StorageUri)); file = new CloudFile(fileUri, client.Credentials); Assert.IsTrue(fileUri.Equals(file.StorageUri)); Assert.IsTrue(fileUri.PrimaryUri.Equals(file.Uri)); Assert.IsTrue(subdirectoryUri.Equals(file.Parent.StorageUri)); Assert.IsTrue(shareUri.Equals(file.Share.StorageUri)); Assert.IsTrue(endpoint.Equals(file.ServiceClient.StorageUri)); }
private static void TestAccess(string sasToken, SharedAccessFilePermissions permissions, SharedAccessFileHeaders headers, CloudFileShare share, CloudFile file) { StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ? new StorageCredentials() : new StorageCredentials(sasToken); if (share != null) { share = new CloudFileShare(credentials.TransformUri(share.Uri)); file = share.GetRootDirectoryReference().GetFileReference(file.Name); } else { file = new CloudFile(credentials.TransformUri(file.Uri)); } if (share != null) { if ((permissions & SharedAccessFilePermissions.List) == SharedAccessFilePermissions.List) { share.GetRootDirectoryReference().ListFilesAndDirectories().ToArray(); } else { TestHelper.ExpectedException( () => share.GetRootDirectoryReference().ListFilesAndDirectories().ToArray(), "List files while SAS does not allow for listing", HttpStatusCode.NotFound); } } if ((permissions & SharedAccessFilePermissions.Read) == SharedAccessFilePermissions.Read) { file.FetchAttributes(); // Test headers if (headers != null) { if (headers.CacheControl != null) { Assert.AreEqual(headers.CacheControl, file.Properties.CacheControl); } if (headers.ContentDisposition != null) { Assert.AreEqual(headers.ContentDisposition, file.Properties.ContentDisposition); } if (headers.ContentEncoding != null) { Assert.AreEqual(headers.ContentEncoding, file.Properties.ContentEncoding); } if (headers.ContentLanguage != null) { Assert.AreEqual(headers.ContentLanguage, file.Properties.ContentLanguage); } if (headers.ContentType != null) { Assert.AreEqual(headers.ContentType, file.Properties.ContentType); } } } else { TestHelper.ExpectedException( () => file.FetchAttributes(), "Fetch file attributes while SAS does not allow for reading", HttpStatusCode.NotFound); } if ((permissions & SharedAccessFilePermissions.Write) == SharedAccessFilePermissions.Write) { file.SetMetadata(); } else { TestHelper.ExpectedException( () => file.SetMetadata(), "Set file metadata while SAS does not allow for writing", HttpStatusCode.NotFound); } if ((permissions & SharedAccessFilePermissions.Delete) == SharedAccessFilePermissions.Delete) { file.Delete(); } else { TestHelper.ExpectedException( () => file.Delete(), "Delete file while SAS does not allow for deleting", HttpStatusCode.NotFound); } }
private async Task CloudFileUploadFromStreamAsync(CloudFileShare share, int size, long? copyLength, AccessCondition accessCondition, OperationContext operationContext, int startOffset) { byte[] buffer = GetRandomBuffer(size); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); file.StreamWriteSizeInBytes = 512; using (MemoryStream originalFileStream = new MemoryStream()) { originalFileStream.Write(buffer, startOffset, buffer.Length - startOffset); using (MemoryStream sourceStream = new MemoryStream(buffer)) { sourceStream.Seek(startOffset, SeekOrigin.Begin); if (copyLength.HasValue) { await file.UploadFromStreamAsync(sourceStream, copyLength.Value, accessCondition, null, operationContext); } else { await file.UploadFromStreamAsync(sourceStream, accessCondition, null, operationContext); } } using (MemoryStream downloadedFileStream = new MemoryStream()) { await file.DownloadToStreamAsync(downloadedFileStream); Assert.AreEqual(copyLength ?? originalFileStream.Length, downloadedFileStream.Length); TestHelper.AssertStreamsAreEqualAtIndex( originalFileStream, downloadedFileStream, 0, 0, copyLength.HasValue ? (int)copyLength : (int)originalFileStream.Length); } } }
public void SetShareProperties(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext) { share.SetProperties(accessCondition, options, operationContext); }
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 CloudFileListSharesWithSnapshotAsync() { CloudFileShare share = GetRandomShareReference(); await share.CreateAsync(); share.Metadata["key1"] = "value1"; await share.SetMetadataAsync(); CloudFileShare snapshot = await share.SnapshotAsync(); share.Metadata["key2"] = "value2"; await share.SetMetadataAsync(); CloudFileClient client = GenerateCloudFileClient(); List <CloudFileShare> listedShares = new List <CloudFileShare>(); FileContinuationToken token = null; do { ShareResultSegment resultSegment = await client.ListSharesSegmentedAsync(share.Name, ShareListingDetails.All, null, token, null, null); token = resultSegment.ContinuationToken; foreach (CloudFileShare listResultShare in resultSegment.Results) { listedShares.Add(listResultShare); } }while (token != null); int count = 0; bool originalFound = false; bool snapshotFound = false; foreach (CloudFileShare listShareItem in listedShares) { if (listShareItem.Name.Equals(share.Name) && !listShareItem.IsSnapshot && !originalFound) { count++; originalFound = true; Assert.AreEqual(2, listShareItem.Metadata.Count); Assert.AreEqual("value2", listShareItem.Metadata["key2"]); Assert.AreEqual("value1", listShareItem.Metadata["key1"]); Assert.AreEqual(share.StorageUri, listShareItem.StorageUri); } else if (listShareItem.Name.Equals(share.Name) && listShareItem.IsSnapshot && !snapshotFound) { count++; snapshotFound = true; Assert.AreEqual(1, listShareItem.Metadata.Count); Assert.AreEqual("value1", listShareItem.Metadata["key1"]); Assert.AreEqual(snapshot.StorageUri, listShareItem.StorageUri); } } Assert.AreEqual(2, count); await snapshot.DeleteAsync(); await share.DeleteAsync(); }
public FileSharePermissions GetSharePermissions(CloudFileShare share, AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null) { return share.GetPermissions(accessCondition, options, operationContext); }
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 void TestInitialize() { this.testShare = GetRandomShareReference(); this.testShare.CreateIfNotExistsAsync().AsTask().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 void FetchShareAttributes(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext) { share.FetchAttributes(accessCondition, options, operationContext); }
public Task CreateShareAsync(CloudFileShare share, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { return TaskEx.FromResult(share); }
public void SetSharePermissions(CloudFileShare share, FileSharePermissions permissions, AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null) { share.SetPermissions(permissions, accessCondition, options, operationContext); }
public void SetShareProperties(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext) { throw new NotImplementedException(); }
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 Task CreateShareAsync(CloudFileShare share, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { return share.CreateAsync(options, operationContext, cancellationToken); }
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 Task FetchShareAttributesAsync(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken token) { return share.FetchAttributesAsync(accessCondition, options, operationContext, token); }
public void CloudFileShareUpdateSASToken() { // Create a policy with read/write access and get SAS. SharedAccessFilePolicy policy = new SharedAccessFilePolicy() { SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5), SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30), Permissions = SharedAccessFilePermissions.Read | SharedAccessFilePermissions.Write, }; string sasToken = this.testShare.GetSharedAccessSignature(policy); //Thread.Sleep(35000); CloudFile testFile = this.testShare.GetRootDirectoryReference().GetFileReference("file"); UploadText(testFile, "file", Encoding.UTF8); TestAccess(sasToken, SharedAccessFilePermissions.Read | SharedAccessFilePermissions.Write, null, this.testShare, testFile); StorageCredentials creds = new StorageCredentials(sasToken); // Change the policy to only read and update SAS. SharedAccessFilePolicy policy2 = new SharedAccessFilePolicy() { SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5), SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30), Permissions = SharedAccessFilePermissions.Read }; string sasToken2 = this.testShare.GetSharedAccessSignature(policy2); creds.UpdateSASToken(sasToken2); // Extra check to make sure that we have actually updated the SAS token. CloudFileShare share = new CloudFileShare(this.testShare.Uri, creds); CloudFile testFile2 = share.GetRootDirectoryReference().GetFileReference("file2"); TestHelper.ExpectedException( () => UploadText(testFile2, "file", Encoding.UTF8), "Writing to a file while SAS does not allow for writing", HttpStatusCode.NotFound); CloudFile testFile3 = this.testShare.GetRootDirectoryReference().GetFileReference("file3"); testFile3.Create(0); TestAccess(sasToken2, SharedAccessFilePermissions.Read, null, this.testShare, testFile); }