public AzureOperations(string connectionString, string shareName) { var account = CloudStorageAccount.Parse(connectionString); client = account.CreateCloudFileClient(); share = client.GetShareReference(shareName); share.CreateIfNotExists(); root = share.GetRootDirectoryReference(); }
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 void CloudFileDirectoryGetParentOnRoot() { CloudFileClient client = GenerateCloudFileClient(); string name = GetRandomShareName(); CloudFileShare share = client.GetShareReference(name); CloudFileDirectory root = share.GetRootDirectoryReference().GetDirectoryReference("TopDir1/"); CloudFileDirectory parent = root.Parent; Assert.IsNotNull(parent); CloudFileDirectory empty = parent.Parent; Assert.IsNull(empty); }
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); }
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 void MyTestInitialize() { if (TestBase.FileBufferManager != null) { TestBase.FileBufferManager.OutstandingBufferCount = 0; } this.share = GetRandomShareReference(); this.share.CreateIfNotExists(); CloudFileDirectory directory = share.GetRootDirectoryReference(); this.directory = directory.GetDirectoryReference("directory"); this.directory.Create(); this.file = this.directory.GetFileReference("file"); this.file.UploadText("test"); }
public static List <string> CreateFilesTask(CloudFileShare share, int count) { string name; List <string> files = new List <string>(); List <Task> tasks = new List <Task>(); for (int i = 0; i < count; i++) { name = "ff" + Guid.NewGuid().ToString(); CloudFile file = share.GetRootDirectoryReference().GetFileReference(name); tasks.Add(file.CreateAsync(0)); files.Add(name); } Task.WaitAll(tasks.ToArray()); return(files); }
public void CloudFileDirectoryFileParentValidate() { CloudFileClient client = GenerateCloudFileClient(); string name = GetRandomShareName(); CloudFileShare share = client.GetShareReference(name); CloudFile file = share.GetRootDirectoryReference(). GetDirectoryReference("TopDir1"). GetDirectoryReference("MidDir1"). GetDirectoryReference("EndDir1"). GetFileReference("EndFile1"); CloudFileDirectory directory = file.Parent; Assert.AreEqual(directory.Name, "EndDir1"); Assert.AreEqual(directory.Uri, share.Uri + "/TopDir1/MidDir1/EndDir1"); }
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(); } }
public async Task CloudFileShareUpdateSASTokenAsync() { // 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"); await UploadTextAsync(testFile, "file", Encoding.UTF8); await 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"); OperationContext context = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await UploadTextAsync(testFile2, "file", Encoding.UTF8, operationContext: context), context, "Writing to a file while SAS does not allow for writing", HttpStatusCode.Forbidden, ""); CloudFile testFile3 = this.testShare.GetRootDirectoryReference().GetFileReference("file3"); await testFile3.CreateAsync(0); await TestAccess(sasToken2, SharedAccessFilePermissions.Read, null, this.testShare, testFile); }
public void CloudFileDirectoryWithFilesDeleteAPM() { CloudFileClient client = GenerateCloudFileClient(); string name = GetRandomShareName(); CloudFileShare share = client.GetShareReference(name); try { share.Create(); if (CloudFileDirectorySetup(share)) { CloudFileDirectory dir1 = share.GetRootDirectoryReference().GetDirectoryReference("TopDir1/MidDir1/EndDir1"); CloudFile file1 = dir1.GetFileReference("EndFile1"); using (AutoResetEvent waitHandle = new AutoResetEvent(false)) { IAsyncResult result = dir1.BeginDelete( ar => waitHandle.Set(), null); waitHandle.WaitOne(); TestHelper.ExpectedException( () => dir1.EndDelete(result), "Delete a non-empty directory", HttpStatusCode.Conflict); result = file1.BeginDelete( ar => waitHandle.Set(), null); waitHandle.WaitOne(); file1.EndDelete(result); result = dir1.BeginDelete( ar => waitHandle.Set(), null); waitHandle.WaitOne(); dir1.EndDelete(result); } Assert.IsFalse(file1.Exists()); Assert.IsFalse(dir1.Exists()); } } finally { share.Delete(); } }
public async Task CloudFileUploadCancellationAsync() { CloudFileShare share = DefaultFileClient.GetShareReference(Guid.NewGuid().ToString("N")); byte[] buffer = FileTestBase.GetRandomBuffer(4 * 1024 * 1024); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); FileRequestOptions requestOptions = new FileRequestOptions() { RetryPolicy = new NoRetry() }; CancellationTokenSource cts = new CancellationTokenSource(); CancellationToken token = cts.Token; new Task(() => { new System.Threading.ManualResetEvent(false).WaitOne(10); cts.Cancel(false); }).Start(); using (MemoryStream ms = new MemoryStream(buffer)) { #if ASPNET_K file.UploadFromStreamAsync(ms, ms.Length, null, requestOptions, null, token).Wait(); #else file.UploadFromStreamAsync(ms.AsInputStream(), null, requestOptions, null).AsTask(token).Wait(); #endif } Assert.Fail(); } catch (AggregateException e) { TaskCanceledException ex = new TaskCanceledException(); Assert.AreEqual(ex.HResult, e.InnerException.HResult); } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task FileOpenWriteSeekReadTestAsync() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); MemoryStream memoryStream = new MemoryStream(buffer); using (var fileStream = await file.OpenWriteAsync(2048)) { Stream fileStreamForWrite = fileStream.AsStreamForWrite(); await fileStreamForWrite.WriteAsync(buffer, 0, 2048); Assert.AreEqual(fileStreamForWrite.Position, 2048); fileStreamForWrite.Seek(1024, 0); memoryStream.Seek(1024, 0); Assert.AreEqual(fileStreamForWrite.Position, 1024); byte[] testBuffer = GetRandomBuffer(1024); await memoryStream.WriteAsync(testBuffer, 0, 1024); await fileStreamForWrite.WriteAsync(testBuffer, 0, 1024); Assert.AreEqual(fileStreamForWrite.Position, memoryStream.Position); await fileStreamForWrite.FlushAsync(); } using (var dstStream = await file.OpenReadAsync()) { Stream dstStreamForRead = dstStream.AsStreamForRead(); TestHelper.AssertStreamsAreEqual(memoryStream, dstStreamForRead); } } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task FileUploadWithoutMD5ValidationAndStoreFileContentTestAsync() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); FileRequestOptions options = new FileRequestOptions(); options.DisableContentMD5Validation = false; options.StoreFileContentMD5 = false; OperationContext context = new OperationContext(); using (MemoryStream srcStream = new MemoryStream(buffer)) { await file.UploadFromStreamAsync(srcStream.AsInputStream(), null, options, context); await file.FetchAttributesAsync(); string md5 = file.Properties.ContentMD5; file.Properties.ContentMD5 = "MDAwMDAwMDA="; await file.SetPropertiesAsync(null, options, context); byte[] testBuffer = new byte[2048]; MemoryStream dstStream = new MemoryStream(testBuffer); await TestHelper.ExpectedExceptionAsync(async() => await file.DownloadRangeToStreamAsync(dstStream.AsOutputStream(), null, null, null, options, context), context, "Try to Download a stream with a corrupted md5 and DisableMD5Validation set to false", HttpStatusCode.OK); options.DisableContentMD5Validation = true; await file.SetPropertiesAsync(null, options, context); byte[] testBuffer2 = new byte[2048]; MemoryStream dstStream2 = new MemoryStream(testBuffer2); await file.DownloadRangeToStreamAsync(dstStream2.AsOutputStream(), null, null, null, options, context); } } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
public void FileWriteStreamRandomSeekTest() { byte[] buffer = GetRandomBuffer(3 * 1024 * 1024); CloudFileShare share = GetRandomShareReference(); share.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2; try { share.Create(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); using (MemoryStream wholeFile = new MemoryStream()) { using (Stream fileStream = file.OpenWrite(buffer.Length)) { fileStream.Write(buffer, 0, buffer.Length); wholeFile.Write(buffer, 0, buffer.Length); Random random = new Random(); for (int i = 0; i < 10; i++) { int offset = random.Next(buffer.Length); TestHelper.SeekRandomly(fileStream, offset); fileStream.Write(buffer, 0, buffer.Length - offset); wholeFile.Seek(offset, SeekOrigin.Begin); wholeFile.Write(buffer, 0, buffer.Length - offset); } } file.FetchAttributes(); Assert.IsNull(file.Properties.ContentMD5); using (MemoryStream downloadedFile = new MemoryStream()) { file.DownloadToStream(downloadedFile); TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile); } } } finally { share.DeleteIfExists(); } }
public void CloudFileDirectoryDeleteIfExists() { CloudFileShare share = GetRandomShareReference(); share.Create(); try { CloudFileDirectory directory = share.GetRootDirectoryReference().GetDirectoryReference("directory1"); Assert.IsFalse(directory.DeleteIfExists()); directory.Create(); Assert.IsTrue(directory.DeleteIfExists()); Assert.IsFalse(directory.DeleteIfExists()); } finally { share.Delete(); } }
public async Task CloudFileDirectoryDeleteIfExistsAsync() { CloudFileShare share = GetRandomShareReference(); await share.CreateAsync(); try { CloudFileDirectory directory = share.GetRootDirectoryReference().GetDirectoryReference("directory1"); Assert.IsFalse(await directory.DeleteIfExistsAsync()); await directory.CreateAsync(); Assert.IsTrue(await directory.DeleteIfExistsAsync()); Assert.IsFalse(await directory.DeleteIfExistsAsync()); } finally { share.DeleteAsync().Wait(); } }
public async Task CloudFileCreateAndDeleteAsync() { CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); await file.CreateAsync(0); Assert.IsTrue(await file.ExistsAsync()); await file.DeleteAsync(); } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudFileClientMaximumExecutionTimeoutAsync() { CloudFileClient fileClient = GenerateCloudFileClient(); CloudFileShare share = fileClient.GetShareReference(Guid.NewGuid().ToString("N")); CloudFileDirectory rootDirectory = share.GetRootDirectoryReference(); byte[] buffer = FileTestBase.GetRandomBuffer(80 * 1024 * 1024); try { await share.CreateAsync(); fileClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(5); CloudFile file = rootDirectory.GetFileReference("file"); file.StreamWriteSizeInBytes = 1 * 1024 * 1024; using (MemoryStream ms = new MemoryStream(buffer)) { try { await file.UploadFromStreamAsync(ms); Assert.Fail(); } catch (AggregateException ex) { #if !FACADE_NETCORE Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).ExceptionInfo.Message); #else Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).Exception.Message); #endif } catch (TaskCanceledException) { } } } finally { fileClient.DefaultRequestOptions.MaximumExecutionTime = null; share.DeleteIfExistsAsync().Wait(); } }
public async Task CloudFileApisInShareSnapshotAsync() { CloudFileClient client = GenerateCloudFileClient(); string name = GetRandomShareName(); CloudFileShare share = client.GetShareReference(name); await share.CreateAsync(); CloudFileDirectory dir = share.GetRootDirectoryReference().GetDirectoryReference("dir1"); await dir.CreateAsync(); CloudFile file = dir.GetFileReference("file"); await file.CreateAsync(1024); file.Metadata["key1"] = "value1"; await file.SetMetadataAsync(); CloudFileShare snapshot = share.SnapshotAsync().Result; CloudFile snapshotFile = snapshot.GetRootDirectoryReference().GetDirectoryReference("dir1").GetFileReference("file"); file.Metadata["key2"] = "value2"; await file.SetMetadataAsync(); await snapshotFile.FetchAttributesAsync(); Assert.IsTrue(snapshotFile.Metadata.Count == 1 && snapshotFile.Metadata["key1"].Equals("value1")); Assert.IsNotNull(snapshotFile.Properties.ETag); await file.FetchAttributesAsync(); Assert.IsTrue(file.Metadata.Count == 2 && file.Metadata["key2"].Equals("value2")); Assert.IsNotNull(file.Properties.ETag); Assert.AreNotEqual(file.Properties.ETag, snapshotFile.Properties.ETag); CloudFile snapshotFile2 = new CloudFile(snapshotFile.SnapshotQualifiedStorageUri, client.Credentials); Assert.IsTrue(snapshotFile2.ExistsAsync().Result); Assert.IsTrue(snapshotFile2.Share.SnapshotTime.HasValue); await snapshot.DeleteAsync(); await share.DeleteAsync(); }
public void CloudFileClientObjects() { CloudFileClient fileClient = GenerateCloudFileClient(); CloudFileShare share = fileClient.GetShareReference("share"); Assert.AreEqual(fileClient, share.ServiceClient); CloudFileDirectory rootDirectory = share.GetRootDirectoryReference(); Assert.AreEqual(fileClient, rootDirectory.ServiceClient); CloudFileDirectory directory = rootDirectory.GetDirectoryReference("directory"); Assert.AreEqual(fileClient, directory.ServiceClient); CloudFile file = directory.GetFileReference("file"); Assert.AreEqual(fileClient, file.ServiceClient); CloudFileShare share2 = GetRandomShareReference(); Assert.AreNotEqual(fileClient, share2.ServiceClient); }
public async Task TestFileEncryptionAsync() { bool requestFound = false; OperationContext ctxt = new OperationContext(); CloudFileShare share = GetRandomShareReference(); try { await share.CreateIfNotExistsAsync(); CloudFileDirectory directory = share.GetRootDirectoryReference(); CloudFile file = directory.GetFileReference("file"); await file.UploadTextAsync("test"); ctxt.RequestCompleted += (sender, args) => { Assert.IsTrue(args.RequestInformation.IsRequestServerEncrypted); requestFound = true; }; await file.UploadTextAsync("test", null, null, ctxt); Assert.IsTrue(requestFound); requestFound = false; await file.SetPropertiesAsync(null, null, ctxt); Assert.IsTrue(requestFound); requestFound = false; await file.SetMetadataAsync(null, null, ctxt); Assert.IsTrue(requestFound); } finally { share.DeleteIfExistsAsync().Wait(); } }
public void FileReadWhenOpenWrite() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudFileShare share = GetRandomShareReference(); try { share.Create(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); MemoryStream memoryStream = new MemoryStream(buffer); Stream fileStream = file.OpenWrite(2048); fileStream.Write(buffer, 0, 2048); byte[] testBuffer = new byte[2048]; TestHelper.ExpectedException <NotSupportedException>(() => fileStream.Read(testBuffer, 0, 2048), "Try reading from a stream opened for Write"); } finally { share.DeleteIfExists(); } }
public async Task CloudFileDirectoryApisInvalidApisInShareSnapshotAsync() { CloudFileShare share = GetRandomShareReference(); await share.CreateAsync(); CloudFileShare snapshot = await share.SnapshotAsync(); CloudFileDirectory dir = snapshot.GetRootDirectoryReference().GetDirectoryReference("dir1"); try { dir.CreateAsync().Wait(); Assert.Fail("API should fail in a snapshot"); } catch (InvalidOperationException e) { Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message); } try { dir.DeleteAsync().Wait(); Assert.Fail("API should fail in a snapshot"); } catch (InvalidOperationException e) { Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message); } try { dir.SetMetadataAsync(null, null, null).Wait(); Assert.Fail("API should fail in a snapshot"); } catch (InvalidOperationException e) { Assert.AreEqual(SR.CannotModifyShareSnapshot, e.Message); } snapshot.DeleteAsync().Wait(); share.DeleteAsync().Wait(); }
public async Task CloudFileClientMaximumExecutionTimeoutAsync() { CloudFileClient fileClient = GenerateCloudFileClient(); CloudFileShare share = fileClient.GetShareReference(Guid.NewGuid().ToString("N")); CloudFileDirectory rootDirectory = share.GetRootDirectoryReference(); byte[] buffer = FileTestBase.GetRandomBuffer(80 * 1024 * 1024); try { await share.CreateAsync(); fileClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(5); CloudFile file = rootDirectory.GetFileReference("file"); file.StreamWriteSizeInBytes = 1 * 1024 * 1024; using (MemoryStream ms = new MemoryStream(buffer)) { try { await file.UploadFromStreamAsync(ms); Assert.Fail(); } catch (TimeoutException ex) { Assert.IsInstanceOfType(ex, typeof(TimeoutException)); } catch (StorageException ex) { Assert.IsInstanceOfType(ex.InnerException, typeof(TimeoutException)); } } } finally { fileClient.DefaultRequestOptions.MaximumExecutionTime = null; share.DeleteIfExistsAsync().Wait(); } }
public async Task CloudFileAlignmentAsync() { CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); OperationContext operationContext = new OperationContext(); await file.CreateAsync(511); await file.CreateAsync(512); await file.CreateAsync(513); using (MemoryStream stream = new MemoryStream()) { stream.SetLength(511); await file.WriteRangeAsync(stream.AsInputStream(), 0, null); } using (MemoryStream stream = new MemoryStream()) { stream.SetLength(512); await file.WriteRangeAsync(stream.AsInputStream(), 0, null); } using (MemoryStream stream = new MemoryStream()) { stream.SetLength(513); await file.WriteRangeAsync(stream.AsInputStream(), 0, null); } } 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(); } }
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 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 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 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 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(); } }
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; } }
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 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); }
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 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); } } }
private void CloudFileUploadFromStream(CloudFileShare share, int size, long? copyLength, AccessCondition accessCondition, int startOffset, bool isAsync, bool testMd5) { byte[] buffer = GetRandomBuffer(size); MD5 hasher = MD5.Create(); string md5 = string.Empty; if (testMd5) { md5 = Convert.ToBase64String(hasher.ComputeHash(buffer, startOffset, copyLength.HasValue ? (int)copyLength : buffer.Length - startOffset)); } CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); file.StreamWriteSizeInBytes = 512; using (MemoryStream originalFile = new MemoryStream()) { originalFile.Write(buffer, startOffset, buffer.Length - startOffset); using (MemoryStream sourceStream = new MemoryStream(buffer)) { sourceStream.Seek(startOffset, SeekOrigin.Begin); FileRequestOptions options = new FileRequestOptions() { StoreFileContentMD5 = true, }; if (isAsync) { using (ManualResetEvent waitHandle = new ManualResetEvent(false)) { if (copyLength.HasValue) { ICancellableAsyncResult result = file.BeginUploadFromStream( sourceStream, copyLength.Value, accessCondition, options, null, ar => waitHandle.Set(), null); waitHandle.WaitOne(); file.EndUploadFromStream(result); } else { ICancellableAsyncResult result = file.BeginUploadFromStream( sourceStream, accessCondition, options, null, ar => waitHandle.Set(), null); waitHandle.WaitOne(); file.EndUploadFromStream(result); } } } else { if (copyLength.HasValue) { file.UploadFromStream(sourceStream, copyLength.Value, accessCondition, options); } else { file.UploadFromStream(sourceStream, accessCondition, options); } } } file.FetchAttributes(); if (testMd5) { Assert.AreEqual(md5, file.Properties.ContentMD5); } using (MemoryStream downloadedFile = new MemoryStream()) { if (isAsync) { using (ManualResetEvent waitHandle = new ManualResetEvent(false)) { ICancellableAsyncResult result = file.BeginDownloadToStream(downloadedFile, ar => waitHandle.Set(), null); waitHandle.WaitOne(); file.EndDownloadToStream(result); } } else { file.DownloadToStream(downloadedFile); } TestHelper.AssertStreamsAreEqualAtIndex( originalFile, downloadedFile, 0, 0, copyLength.HasValue ? (int)copyLength : (int)originalFile.Length); } } }
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); } } }
private void CloudFileUploadFromStreamTask(CloudFileShare share, int size, long? copyLength, AccessCondition accessCondition, int startOffset, bool testMd5) { try { byte[] buffer = GetRandomBuffer(size); MD5 hasher = MD5.Create(); string md5 = string.Empty; if (testMd5) { md5 = Convert.ToBase64String(hasher.ComputeHash(buffer, startOffset, copyLength.HasValue ? (int)copyLength : buffer.Length - startOffset)); } CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); file.StreamWriteSizeInBytes = 512; using (MemoryStream originalFile = new MemoryStream()) { originalFile.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) { file.UploadFromStreamAsync(sourceStream, copyLength.Value, accessCondition, options, null).Wait(); } else { file.UploadFromStreamAsync(sourceStream, accessCondition, options, null).Wait(); } } file.FetchAttributesAsync().Wait(); if (testMd5) { Assert.AreEqual(md5, file.Properties.ContentMD5); } using (MemoryStream downloadedFile = new MemoryStream()) { file.DownloadToStreamAsync(downloadedFile).Wait(); TestHelper.AssertStreamsAreEqualAtIndex( originalFile, downloadedFile, 0, 0, copyLength.HasValue ? (int)copyLength : (int)originalFile.Length); } } } catch (AggregateException ex) { throw ex.InnerException; } }
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); } }
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 static async Task TestAccess(string sasToken, SharedAccessFilePermissions permissions, SharedAccessFileHeaders headers, CloudFileShare share, CloudFile file) { CloudFileShare SASshare = null; CloudFile SASfile; OperationContext context = new OperationContext(); 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) { await UploadTextAsync(SASfile, fileText, Encoding.UTF8); } else if ((permissions & SharedAccessFilePermissions.Create) == SharedAccessFilePermissions.Create) { await SASfile.CreateAsync(Encoding.UTF8.GetBytes(fileText).Length); context = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async () => await UploadTextAsync(SASfile, fileText, Encoding.UTF8, operationContext:context), context, "UploadText SAS does not allow for writing", HttpStatusCode.Forbidden, ""); await UploadTextAsync(file, fileText, Encoding.UTF8); } else { context = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async () => await SASfile.CreateAsync(Encoding.UTF8.GetBytes(fileText).Length, null /* accessCondition */, null /* options */, context), context, "Create file succeeded but SAS does not allow for writing/creating", HttpStatusCode.Forbidden, ""); context = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async () => await UploadTextAsync(SASfile, fileText, Encoding.UTF8, operationContext:context), context, "UploadText SAS does not allow for writing/creating", HttpStatusCode.Forbidden, ""); await UploadTextAsync(file, fileText, Encoding.UTF8); } if (SASshare != null) { if ((permissions & SharedAccessFilePermissions.List) == SharedAccessFilePermissions.List) { var results = await SASshare.GetRootDirectoryReference().ListFilesAndDirectoriesSegmentedAsync(null); } else { context = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async () => { var results = await SASshare.GetRootDirectoryReference().ListFilesAndDirectoriesSegmentedAsync(null /* maxResults */, null /* currentToken */, null /* options */, context); }, context, "List files while SAS does not allow for listing", HttpStatusCode.Forbidden, ""); } } if ((permissions & SharedAccessFilePermissions.Read) == SharedAccessFilePermissions.Read) { await SASfile.FetchAttributesAsync(); // 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 { context = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async () => await SASfile.FetchAttributesAsync(null /* accessCondition */, null /* options */, context), context, "Fetch file attributes while SAS does not allow for reading", HttpStatusCode.Forbidden, ""); } if ((permissions & SharedAccessFilePermissions.Write) == SharedAccessFilePermissions.Write) { await SASfile.SetMetadataAsync(); } else { context = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async () => await SASfile.SetMetadataAsync(null /* accessCondition */, null /* options */, context), context, "Set file metadata while SAS does not allow for writing", HttpStatusCode.Forbidden, ""); } if ((permissions & SharedAccessFilePermissions.Delete) == SharedAccessFilePermissions.Delete) { await SASfile.DeleteAsync(); } else { context = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async () => await SASfile.DeleteAsync(null /* accessCondition */, null /* options */, context), context, "Delete file while SAS does not allow for deleting", HttpStatusCode.Forbidden, ""); } }