public static FoundFile ScanForANewFile() { ShareClient share = new ShareClient(CONNECTIONSTRING, SHARENAME); foreach (ShareFileItem item in share.GetRootDirectoryClient().GetFilesAndDirectories()) // loop through all plants { if (item.Name == "System") { continue; } if (item.IsDirectory) { var subDirectory = share.GetRootDirectoryClient().GetSubdirectoryClient(item.Name); ShareDirectoryClient dir = subDirectory.GetSubdirectoryClient("immediateScan"); if (!dir.Exists()) { continue; } foreach (var file in dir.GetFilesAndDirectories()) { if (!file.IsDirectory) { string tempFileName = Path.GetTempFileName(); DownloadFile(dir.GetFileClient(file.Name), tempFileName); return(new FoundFile(/*item.Name, */ file.Name, dir.Path + "/" + file.Name, tempFileName)); } } } } return(null); }
public List <FileGroup> GetGroups() { var root = shareClient.GetRootDirectoryClient(); var items = root.GetFilesAndDirectories(); var fileGroups = new List <FileGroup>(); foreach (ShareFileItem item in items) { if (!item.IsDirectory) { continue; } var fm36Folder = root.GetSubdirectoryClient(item.Name); var fileGroup = new FileGroup { Name = fm36Folder.Name }; var fm36Files = fm36Folder.GetFilesAndDirectories(); foreach (var fm36File in fm36Files) { if (fm36File.IsDirectory) { continue; } fileGroup.Files.Add(Fm36File.Parse(fm36File.Name)); } fileGroups.Add(fileGroup); } return(fileGroups); }
/// <summary>Creates a wrapper around the file so that you can perform actions on it (doesn't do anything to the server).</summary> /// <param name="directoryName">The directory of interest or empty/null if you want the root directory</param> /// <param name="fileName">The file name without a path</param> public ShareFileClient CreateClient(string directoryName, string fileName) { ShareDirectoryClient directory = string.IsNullOrWhiteSpace(directoryName) ? _share.GetRootDirectoryClient() : _share.GetDirectoryClient(directoryName); return(directory.GetFileClient(fileName)); }
public IAsyncEnumerable <string> ListAsync(IPathFilter pathFilter, CancellationToken cancellationToken) { if (pathFilter == null) { throw new ArgumentNullException(nameof(pathFilter)); } return(RecurseDirectory(_shareClient.GetRootDirectoryClient(), pathFilter, cancellationToken)); }
public ServiceFileShare(String con) { ShareClient client = new ShareClient(con, "filesharegsr"); this.root = client.GetRootDirectoryClient(); }
public static bool WriteStringToAzureFileShare(string storageConnString, string shareName, string fileName, string content) { if (!azureAuthenticated) { return(false); } try { ShareClient share = new ShareClient(storageConnString, shareName); ShareDirectoryClient directory = share.GetRootDirectoryClient(); directory.DeleteFile(fileName); ShareFileClient file = directory.GetFileClient(fileName); byte[] byteArray = Encoding.UTF8.GetBytes(content); using (MemoryStream stream = new MemoryStream(byteArray)) { file.Create(stream.Length); file.UploadRange( new HttpRange(0, stream.Length), stream); } return(true); } catch (Exception _) { // Log Ex.Message here return(false); } }
public ServiceStorageFile(String keys) { ShareClient client = new ShareClient(keys, "ejemplo"); this.root = client.GetRootDirectoryClient(); }
private void Initialize() { _shareClient.CreateIfNotExists(); var remaining = new Queue <ShareDirectoryClient>(); remaining.Enqueue(_shareClient.GetRootDirectoryClient()); while (remaining.Count > 0) { var dir = remaining.Dequeue(); _shareDirectories.Add(HttpUtility.UrlDecode(dir.Path)); foreach (var item in dir.GetFilesAndDirectories()) { if (item.IsDirectory) { remaining.Enqueue(dir.GetSubdirectoryClient(item.Name)); } else if (item.FileSize != null) { _shareFiles.Add(new ShareFileMetadata(item.Name, HttpUtility.UrlDecode(dir.Path) ?? string.Empty, item.FileSize.Value)); } } } }
private static async Task TraverseAsync(string connectionString, string shareName, ILogger log) { ShareClient share = new ShareClient(connectionString, shareName); // Get the root directory var root = share.GetRootDirectoryClient(); // Traverse each item in the root directory await foreach (ShareFileItem item in root.GetFilesAndDirectoriesAsync()) { // Print the name of the item log.LogInformation(item.Name); // If the item is our input folder then traverse it if (item.IsDirectory && item.Name == _inputFolder) { var subClient = root.GetSubdirectoryClient(item.Name); await foreach (ShareFileItem inputItem in subClient.GetFilesAndDirectoriesAsync()) { if (!inputItem.IsDirectory) { var fileProcessor = new FileProcessor(connectionString, shareName, subClient.Name, inputItem.Name, _pattern, _outputFolder, log); await fileProcessor.ProcessFile(); } } } } }
private void Initialize() { _shareClient.CreateIfNotExists(); // Track the remaining directories to walk, starting from the root var remaining = new Queue <ShareDirectoryClient>(); remaining.Enqueue(_shareClient.GetRootDirectoryClient()); while (remaining.Count > 0) { // Get all of the next directory's files and subdirectories var dir = remaining.Dequeue(); _shareDirectories.Add(HttpUtility.UrlDecode(dir.Path)); foreach (var item in dir.GetFilesAndDirectories()) { // Keep walking down directories if (item.IsDirectory) { remaining.Enqueue(dir.GetSubdirectoryClient(item.Name)); } else { if (item.FileSize != null) { _shareFiles.Add(new ShareFileMetadata(item.Name, HttpUtility.UrlDecode(dir.Path), item.FileSize.Value)); } } } } }
/// <summary> /// Traverse the files and directories in a share. /// </summary> /// <param name="connectionString"> /// A connection string to your Azure Storage account. /// </param> /// <param name="shareName"> /// The name of the share to traverse. /// </param> public static async Task TraverseAsync(string connectionString, string shareName) { ShareClient share = new ShareClient(connectionString, shareName); // Track the remaining directories to walk, starting from the root var remaining = new Queue <ShareDirectoryClient>(); remaining.Enqueue(share.GetRootDirectoryClient()); while (remaining.Count > 0) { // Get all of the next directory's files and subdirectories ShareDirectoryClient dir = remaining.Dequeue(); await foreach (ShareFileItem item in dir.GetFilesAndDirectoriesAsync()) { // Print the name of the item Console.WriteLine(item.Name); // Keep walking down directories if (item.IsDirectory) { remaining.Enqueue(dir.GetSubdirectoryClient(item.Name)); } } } }
public static ShareFileClient GetAzureFile(string folderName, string fileName) { string shareName = MyWebUtils.Application.ToLower(); string connectionString = Properties.Settings.Default.StorageConnectionString; ShareClient share = new ShareClient(connectionString, shareName); // Create the share if it doesn't already exist share.CreateIfNotExists(); if (share.Exists()) { ShareDirectoryClient subFolder = share.GetRootDirectoryClient(); foreach (string subFolderName in folderName.Split('\\')) { subFolder = subFolder.GetSubdirectoryClient(subFolderName); subFolder.CreateIfNotExists(); } return(subFolder.GetFileClient(fileName)); } return(null); }
public async Task SharePermissionsRawPermissions(string permissionsString) { // Arrange await using DisposingShare test = await GetTestShareAsync(); ShareSasBuilder blobSasBuilder = new ShareSasBuilder { StartsOn = Recording.UtcNow.AddHours(-1), ExpiresOn = Recording.UtcNow.AddHours(1), ShareName = test.Share.Name }; blobSasBuilder.SetPermissions( rawPermissions: permissionsString, normalize: true); StorageSharedKeyCredential sharedKeyCredential = new StorageSharedKeyCredential(TestConfigDefault.AccountName, TestConfigDefault.AccountKey); ShareUriBuilder blobUriBuilder = new ShareUriBuilder(test.Share.Uri) { Sas = blobSasBuilder.ToSasQueryParameters(sharedKeyCredential) }; ShareClient sasShareClient = new ShareClient(blobUriBuilder.ToUri(), GetOptions()); // Act await sasShareClient.GetRootDirectoryClient().GetPropertiesAsync(); }
public async Task <string> GetFileshare() { // this resource does not have support for managed identities, see https://docs.microsoft.com/en-us/azure/active-directory/managed-identities-azure-resources/services-support-managed-identities var fileName = "test.txt"; var storageConnectionString = _configuration.GetConnectionString("StorageConnectionString"); var shareClient = new ShareClient(storageConnectionString, Environment.GetEnvironmentVariable("FileShareName")); if (await shareClient.ExistsAsync()) { // getting file from root var directory = shareClient.GetRootDirectoryClient(); if (await directory.ExistsAsync()) { var fileClient = directory.GetFileClient(fileName); if (!await fileClient.ExistsAsync()) { await UploadFile(fileClient, fileName); } var result = await ReadFileFromFileShare(fileClient, fileName); return(!string.IsNullOrEmpty(result) ? result : "Something went wrong. Check the logs for more information."); } } return("The fileshare does not exist."); }
public async Task <string> SaveFileUri(string fileShare, string fileName, string fileContent) { ShareClient share = new ShareClient(connectionString, fileShare); if (!share.Exists()) { share.Create(); } ShareDirectoryClient rootDir = share.GetRootDirectoryClient(); ShareFileClient file = rootDir.GetFileClient(fileName); if (!file.Exists()) { file.Create(fileContent.Length); } byte[] outBuff = Encoding.ASCII.GetBytes(fileContent); ShareFileOpenWriteOptions options = new ShareFileOpenWriteOptions { MaxSize = outBuff.Length }; var stream = await file.OpenWriteAsync(true, 0, options); stream.Write(outBuff, 0, outBuff.Length); stream.Flush(); return(file.Uri.ToString()); }
public async Task <string> ReadFile(string fileShare, string fileName) { string json = ""; ShareClient share = new ShareClient(connectionString, fileShare); if (!share.Exists()) { Exception error = new Exception($"Fileshare {fileName} does not exist "); throw error; } ShareDirectoryClient directory = share.GetRootDirectoryClient(); ShareFileClient file = directory.GetFileClient(fileName); if (file.Exists()) { using (Stream fileStream = await file.OpenReadAsync()) { using (StreamReader reader = new StreamReader(fileStream)) { json = reader.ReadToEnd(); } } } else { Exception error = new Exception($"File {fileName} does not exist in Azure storage "); throw error; } return(json); }
/// <summary> /// Traverse the files and directories in a share. /// </summary> /// <param name="connectionString"> /// A connection string to your Azure Storage account. /// </param> /// <param name="shareName"> /// The name of the share to traverse. /// </param> public static void Traverse(string connectionString, string shareName) { #region Snippet:Azure_Storage_Files_Shares_Samples_Sample01a_HelloWorld_Traverse // Connect to the share //@@ string connectionString = "<connection_string>"; //@@ string shareName = "sample-share"; ShareClient share = new ShareClient(connectionString, shareName); // Track the remaining directories to walk, starting from the root var remaining = new Queue <ShareDirectoryClient>(); remaining.Enqueue(share.GetRootDirectoryClient()); while (remaining.Count > 0) { // Get all of the next directory's files and subdirectories ShareDirectoryClient dir = remaining.Dequeue(); foreach (ShareFileItem item in dir.GetFilesAndDirectories()) { // Print the name of the item Console.WriteLine(item.Name); // Keep walking down directories if (item.IsDirectory) { remaining.Enqueue(dir.GetSubdirectoryClient(item.Name)); } } } #endregion Snippet:Azure_Storage_Files_Shares_Samples_Sample01a_HelloWorld_Traverse }
public List <string> AllFiles() { List <string> FileNames = new List <string>(); var files = root.GetRootDirectoryClient().GetFilesAndDirectories(); foreach (var item in files) { var tipo = " (archivo)"; if (item.IsDirectory) { tipo = " (Carpeta)"; } FileNames.Add(item.Name + tipo); } return(FileNames); }
static void Main(string[] args) { string downloadDirectory = args[0]; // Create a BlobServiceClient object which will be used to create a container client BlobServiceClient blobServiceClient = new BlobServiceClient(AZURE_STORAGE_CONNECTION_STRING); // Create a unique name for the container string containerName = "startupfiles"; // Create the container and return a container client object BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName); List <BlobItem> blobs = containerClient.GetBlobs().ToList(); // Download the blob files in parallel - maximum of 10 at a time } Parallel.ForEach(blobs, new ParallelOptions() { MaxDegreeOfParallelism = 10 }, blob => { string downloadFilePath = Path.Combine(downloadDirectory, blob.Name); BlobClient blobClient = containerClient.GetBlobClient(blob.Name); BlobDownloadInfo download = blobClient.Download(); using (FileStream downloadFileStream = File.OpenWrite(downloadFilePath)) { download.Content.CopyTo(downloadFileStream); downloadFileStream.Close(); } }); string shareName = "startupfiles"; ShareClient shareClient = new ShareClient(AZURE_FILES_CONNECTION_STRING, shareName); if (shareClient.Exists()) { ShareDirectoryClient shareDirectoryClient = shareClient.GetRootDirectoryClient(); List <ShareFileItem> items = shareDirectoryClient.GetFilesAndDirectories().ToList(); foreach (ShareFileItem item in items) { if (!item.IsDirectory) { string downloadFilePath = Path.Combine(downloadDirectory, item.Name); ShareFileClient shareFileClient = shareDirectoryClient.GetFileClient(item.Name); ShareFileDownloadInfo download = shareFileClient.Download(); using (FileStream downloadFileStream = File.OpenWrite(downloadFilePath)) { download.Content.CopyTo(downloadFileStream); downloadFileStream.Close(); } } } } }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, ILogger log) { string connectionString = "DefaultEndpointsProtocol=https;AccountName=m10l2;AccountKey=jKxmGhpm9FWua8lWReXyt9gft5xConbXInXr8IRQj2Z1lWVL6YIWNl/pmqm3EQkdh7YgJlTRPakW8w2GiSfswg==;EndpointSuffix=core.windows.net"; string containerName = "test"; string queueName = "test"; string shareName = "test"; string blobName = $"{Guid.NewGuid().ToString()}.json"; string fileName = $"{Guid.NewGuid().ToString()}.json"; BlobContainerClient container = new BlobContainerClient(connectionString, containerName); BlobClient blob = container.GetBlobClient(blobName); Stream uploadStream = new MemoryStream(); req.Body.CopyTo(uploadStream); uploadStream.Position = 0; blob.Upload(uploadStream); Stream result = (await blob.DownloadAsync()).Value.Content; QueueClient queue = new QueueClient(connectionString, queueName); Stream messageStream = new MemoryStream(); req.Body.Position = 0; req.Body.CopyTo(messageStream); using (StreamReader sr = new StreamReader(messageStream)) { queue.SendMessage(sr.ReadToEnd()); } QueueMessage[] messages = (await queue.ReceiveMessagesAsync()).Value; ShareClient share = new ShareClient(connectionString, shareName); ShareDirectoryClient directory = share.GetRootDirectoryClient(); Stream fileStream = new MemoryStream(); req.Body.Position = 0; req.Body.CopyTo(fileStream); fileStream.Position = 0; ShareFileClient file = directory.GetFileClient(fileName); await file.CreateAsync(fileStream.Length); file.UploadRange(new HttpRange(0, fileStream.Length), fileStream); var downloadedFile = file.Download(); using (StreamReader sr = new StreamReader(downloadedFile.Value.Content)) { string uploadedFile = await sr.ReadToEndAsync(); return(new OkObjectResult(uploadedFile)); } }
/// <summary> /// Get directory properties /// </summary> /// <param name="shareServiceClient"></param> /// <returns></returns> private static async Task DirectoryPropertiesSample(ShareServiceClient shareServiceClient) { Console.WriteLine(); // Create the share name -- use a guid in the name so it's unique. string shareName = "demotest-" + Guid.NewGuid(); ShareClient shareClient = shareServiceClient.GetShareClient(shareName); try { // Create share Console.WriteLine("Create Share"); await shareClient.CreateIfNotExistsAsync(); // Create directory Console.WriteLine("Create directory"); ShareDirectoryClient rootDirectory = shareClient.GetRootDirectoryClient(); // Fetch directory attributes ShareDirectoryProperties shareDirectoryProperties = await rootDirectory.GetPropertiesAsync(); Console.WriteLine("Get directory properties:"); Console.WriteLine(" ETag: {0}", shareDirectoryProperties.ETag); Console.WriteLine(" Last modified: {0}", shareDirectoryProperties.LastModified); } catch (RequestFailedException exRequest) { Common.WriteException(exRequest); Console.WriteLine( "Please make sure your storage account is specified correctly in the app.config - then restart the sample."); Console.WriteLine("Press any key to exit"); Console.ReadLine(); throw; } catch (Exception ex) { Console.WriteLine(" Exception thrown creating share."); Common.WriteException(ex); throw; } finally { // Delete share Console.WriteLine("Delete share"); await shareClient.DeleteIfExistsAsync(); } Console.WriteLine(); }
public async Task <List <string> > ListFiles(string fileShare) { List <string> files = new List <string>(); ShareClient share = new ShareClient(connectionString, fileShare); if (!share.Exists()) { Exception error = new Exception($"Fileshare {fileShare} does not exist "); throw error; } ShareDirectoryClient directory = share.GetRootDirectoryClient(); foreach (ShareFileItem item in directory.GetFilesAndDirectories()) { files.Add(item.Name); } return(files); }
// <snippet_ListSnapshotContents> //------------------------------------------------- // List the snapshots on a share //------------------------------------------------- public void ListSnapshotContents(string shareName, string snapshotTime) { // Get the connection string from app settings string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"]; // Instatiate a ShareServiceClient ShareServiceClient shareService = new ShareServiceClient(connectionString); // Get a ShareClient ShareClient share = shareService.GetShareClient(shareName); Console.WriteLine($"Share: {share.Name}"); // Get as ShareClient that points to a snapshot ShareClient snapshot = share.WithSnapshot(snapshotTime); // Get the root directory in the snapshot share ShareDirectoryClient rootDir = snapshot.GetRootDirectoryClient(); // Recursively list the directory tree ListDirTree(rootDir); }
public async Task DeleteFile(string fileShare, string fileName) { ShareClient share = new ShareClient(connectionString, fileShare); if (!share.Exists()) { Exception error = new Exception($"Fileshare {fileShare} does not exist "); throw error; } ShareDirectoryClient rootDir = share.GetRootDirectoryClient(); ShareFileClient file = rootDir.GetFileClient(fileName); if (file.Exists()) { await file.DeleteAsync(); } else { Exception error = new Exception($"File {fileName} does not exist in Azure storage "); throw error; } }
public void Iterate(string connectionString, string shareName, string directory = null) { ShareClient share = new ShareClient(connectionString, shareName); // Track the remaining directories to walk, starting from the root var remaining = new Queue <ShareDirectoryClient>(); if (directory == null) { remaining.Enqueue(share.GetRootDirectoryClient()); } else { remaining.Enqueue(share.GetDirectoryClient(directory)); } while (remaining.Count > 0) { // Get all of the next directory's files and subdirectories ShareDirectoryClient dir = remaining.Dequeue(); foreach (ShareFileItem item in dir.GetFilesAndDirectories()) { if (!File.Exists(@"C:\audio\sales\trusted\Sales\" + item.Name)) { string filepath = Download(connectionString, shareName, directory, item.Name); } //Upload(filepath); // Keep walking down directories if (item.IsDirectory) { remaining.Enqueue(dir.GetSubdirectoryClient(item.Name)); } } } }
/// <summary> /// Manage file metadata /// </summary> /// <param name="shareServiceClient"></param> /// <returns></returns> private static async Task FileMetadataSample(ShareServiceClient shareServiceClient) { Console.WriteLine(); // Create the share name -- use a guid in the name so it's unique. string shareName = "demotest-" + Guid.NewGuid(); ShareClient shareClient = shareServiceClient.GetShareClient(shareName); try { // Create share Console.WriteLine("Create Share"); await shareClient.CreateIfNotExistsAsync(); // Create directory Console.WriteLine("Create directory"); ShareDirectoryClient rootDirectory = shareClient.GetRootDirectoryClient(); ShareFileClient file = rootDirectory.GetFileClient("demofile"); // Create file Console.WriteLine("Create file"); await file.CreateAsync(1000); // Set file metadata Console.WriteLine("Set file metadata"); var metadata = new Dictionary <string, string> { { "key1", "value1" }, { "key2", "value2" } }; await file.SetMetadataAsync(metadata); // Fetch file attributes ShareFileProperties properties = await file.GetPropertiesAsync(); Console.WriteLine("Get file metadata:"); foreach (var keyValue in properties.Metadata) { Console.WriteLine(" {0}: {1}", keyValue.Key, keyValue.Value); } Console.WriteLine(); } catch (RequestFailedException exRequest) { Common.WriteException(exRequest); Console.WriteLine( "Please make sure your storage account is specified correctly in the app.config - then restart the sample."); Console.WriteLine("Press any key to exit"); Console.ReadLine(); throw; } catch (Exception ex) { Console.WriteLine(" Exception thrown creating share."); Common.WriteException(ex); throw; } finally { // Delete share Console.WriteLine("Delete share"); await shareClient.DeleteIfExistsAsync(); } }
/// <summary> /// Manage file properties /// </summary> /// <param name="shareServiceClient"></param> /// <returns></returns> private static async Task FilePropertiesSample(ShareServiceClient shareServiceClient) { Console.WriteLine(); // Create the share name -- use a guid in the name so it's unique. string shareName = "demotest-" + Guid.NewGuid(); ShareClient shareClient = shareServiceClient.GetShareClient(shareName); try { // Create share Console.WriteLine("Create Share"); await shareClient.CreateIfNotExistsAsync(); // Create directory Console.WriteLine("Create directory"); ShareDirectoryClient rootDirectory = shareClient.GetRootDirectoryClient(); ShareFileClient file = rootDirectory.GetFileClient("demofile"); // Create file Console.WriteLine("Create file"); await file.CreateAsync(1000); // Set file properties var headers = new ShareFileHttpHeaders { ContentType = "plain/text", ContentEncoding = new string[] { "UTF-8" }, ContentLanguage = new string[] { "en" } }; await file.SetHttpHeadersAsync(httpHeaders : headers); // Fetch file attributes ShareFileProperties shareFileProperties = await file.GetPropertiesAsync(); Console.WriteLine("Get file properties:"); Console.WriteLine(" Content type: {0}", shareFileProperties.ContentType); Console.WriteLine(" Content encoding: {0}", string.Join("", shareFileProperties.ContentEncoding)); Console.WriteLine(" Content language: {0}", string.Join("", shareFileProperties.ContentLanguage)); Console.WriteLine(" Length: {0}", shareFileProperties.ContentLength); } catch (RequestFailedException exRequest) { Common.WriteException(exRequest); Console.WriteLine( "Please make sure your storage account is specified correctly in the app.config - then restart the sample."); Console.WriteLine("Press any key to exit"); Console.ReadLine(); throw; } catch (Exception ex) { Console.WriteLine(" Exception thrown creating share."); Common.WriteException(ex); throw; } finally { // Delete share Console.WriteLine("Delete share"); await shareClient.DeleteIfExistsAsync(); } Console.WriteLine(); }
public async Task TraverseAsync() { // Create a temporary Lorem Ipsum file on disk that we can upload string originalPath = CreateTempFile(SampleFileContent); // Get a connection string to our Azure Storage account. string connectionString = ConnectionString; // Get a reference to a share named "sample-share" and then create it ShareClient share = new ShareClient(connectionString, Randomize("sample-share")); await share.CreateAsync(); try { // Create a bunch of directories DirectoryClient first = await share.CreateDirectoryAsync("first"); await first.CreateSubdirectoryAsync("a"); await first.CreateSubdirectoryAsync("b"); DirectoryClient second = await share.CreateDirectoryAsync("second"); await second.CreateSubdirectoryAsync("c"); await second.CreateSubdirectoryAsync("d"); await share.CreateDirectoryAsync("third"); DirectoryClient fourth = await share.CreateDirectoryAsync("fourth"); DirectoryClient deepest = await fourth.CreateSubdirectoryAsync("e"); // Upload a file named "file" FileClient file = deepest.GetFileClient("file"); using (FileStream stream = File.OpenRead(originalPath)) { await file.CreateAsync(stream.Length); await file.UploadRangeAsync( FileRangeWriteType.Update, new HttpRange(0, stream.Length), stream); } // Keep track of all the names we encounter List <string> names = new List <string>(); // Track the remaining directories to walk, starting from the root Queue <DirectoryClient> remaining = new Queue <DirectoryClient>(); remaining.Enqueue(share.GetRootDirectoryClient()); while (remaining.Count > 0) { // Get all of the next directory's files and subdirectories DirectoryClient dir = remaining.Dequeue(); await foreach (StorageFileItem item in dir.GetFilesAndDirectoriesAsync()) { // Track the name of the item names.Add(item.Name); // Keep walking down directories if (item.IsDirectory) { remaining.Enqueue(dir.GetSubdirectoryClient(item.Name)); } } } // Verify we've seen everything Assert.AreEqual(10, names.Count); Assert.Contains("first", names); Assert.Contains("second", names); Assert.Contains("third", names); Assert.Contains("fourth", names); Assert.Contains("a", names); Assert.Contains("b", names); Assert.Contains("c", names); Assert.Contains("d", names); Assert.Contains("e", names); Assert.Contains("file", names); } finally { // Clean up after the test when we're finished await share.DeleteAsync(); } }
private static ShareDirectoryClient GetShareDirectoryClient(string account, string key, string share, string folder) { ShareClient client = new ShareClient(Client.GetConnectionString(account, key), share); return(string.IsNullOrWhiteSpace(folder) ? client.GetRootDirectoryClient() : client.GetDirectoryClient(folder)); }
/// <summary> /// Test some of the file storage operations. /// </summary> public async Task RunFileStorageOperationsAsync() { // These are used in the finally block to clean up the objects created during the demo. ShareClient shareClient = null; ShareFileClient shareFileClient = null; ShareDirectoryClient fileDirectory = null; BlobClient targetBlob = null; BlobContainerClient blobContainer = null; string destFile = null; string downloadFolder = null; // Name to be used for the file when downloading it so you can inspect it locally string downloadFile = null; try { //***** Setup *****// Console.WriteLine("Getting reference to the storage account."); // How to create a storage connection string - http://msdn.microsoft.com/en-us/library/azure/ee758697.aspx string storageConnectionString = ConfigurationManager.AppSettings.Get("StorageConnectionString"); string storageAccountName = ConfigurationManager.AppSettings.Get("StorageAccountName"); string storageAccountKey = ConfigurationManager.AppSettings.Get("StorageAccountKey"); Console.WriteLine("Instantiating file client."); // Create a share client for interacting with the file service. var shareServiceClient = new ShareServiceClient(storageConnectionString); // Create the share name -- use a guid in the name so it's unique. // This will also be used as the container name for blob storage when copying the file to blob storage. string shareName = "demotest-" + System.Guid.NewGuid().ToString(); // Name of folder to put the files in string sourceFolder = "testfolder"; // Name of file to upload and download string testFile = "HelloWorld.png"; // Folder where the HelloWorld.png file resides string localFolder = @".\"; // It won't let you download in the same folder as the exe file, // so use a temporary folder with the same name as the share. downloadFolder = Path.Combine(Path.GetTempPath(), shareName); //***** Create a file share *****// // Create the share if it doesn't already exist. Console.WriteLine("Creating share with name {0}", shareName); shareClient = shareServiceClient.GetShareClient(shareName); try { await shareClient.CreateIfNotExistsAsync(); Console.WriteLine(" Share created successfully."); } catch (RequestFailedException exRequest) { Common.WriteException(exRequest); Console.WriteLine("Please make sure your storage account has storage file endpoint enabled and specified correctly in the app.config - then restart the sample."); Console.WriteLine("Press any key to exit"); Console.ReadLine(); throw; } catch (Exception ex) { Console.WriteLine(" Exception thrown creating share."); Common.WriteException(ex); throw; } //***** Create a directory on the file share *****// // Create a directory on the share. Console.WriteLine("Creating directory named {0}", sourceFolder); ShareDirectoryClient rootDirectory = shareClient.GetRootDirectoryClient(); // If the source folder is null, then use the root folder. // If the source folder is specified, then get a reference to it. if (string.IsNullOrWhiteSpace(sourceFolder)) { // There is no folder specified, so return a reference to the root directory. fileDirectory = rootDirectory; Console.WriteLine(" Using root directory."); } else { // There was a folder specified, so return a reference to that folder. fileDirectory = rootDirectory.GetSubdirectoryClient(sourceFolder); await fileDirectory.CreateIfNotExistsAsync(); Console.WriteLine(" Directory created successfully."); } //***** Upload a file to the file share *****// // Get a file client. shareFileClient = fileDirectory.GetFileClient(testFile); // Upload a file to the share. Console.WriteLine("Uploading file {0} to share", testFile); // Set up the name and path of the local file. string sourceFile = Path.Combine(localFolder, testFile); if (File.Exists(sourceFile)) { using (FileStream stream = File.OpenRead(sourceFile)) { // Upload from the local file to the file share in azure. await shareFileClient.CreateAsync(stream.Length); await shareFileClient.UploadAsync(stream); } Console.WriteLine(" Successfully uploaded file to share."); } else { Console.WriteLine("File not found, so not uploaded."); } //***** Get list of all files/directories on the file share*****// // List all files/directories under the root directory. Console.WriteLine("Getting list of all files/directories under the root directory of the share."); var fileList = rootDirectory.GetFilesAndDirectoriesAsync(); // Print all files/directories listed above. await foreach (ShareFileItem listItem in fileList) { // listItem type will be ShareClient or ShareDirectoryClient. Console.WriteLine(" - {0} (type: {1})", listItem.Name, listItem.GetType()); } Console.WriteLine("Getting list of all files/directories in the file directory on the share."); // Now get the list of all files/directories in your directory. // Ordinarily, you'd write something recursive to do this for all directories and subdirectories. fileList = fileDirectory.GetFilesAndDirectoriesAsync(); // Print all files/directories in the folder. await foreach (ShareFileItem listItem in fileList) { // listItem type will be a file or directory Console.WriteLine(" - {0} (IsDirectory: {1})", listItem.Name, listItem.IsDirectory); } //***** Download a file from the file share *****// // Download the file to the downloadFolder in the temp directory. // Check and if the directory doesn't exist (which it shouldn't), create it. Console.WriteLine("Downloading file from share to local temp folder {0}.", downloadFolder); if (!Directory.Exists(downloadFolder)) { Directory.CreateDirectory(downloadFolder); } // Download the file. ShareFileDownloadInfo download = await shareFileClient.DownloadAsync(); downloadFile = Path.Combine(downloadFolder, testFile); using (FileStream stream = File.OpenWrite(downloadFile)) { await download.Content.CopyToAsync(stream); } Console.WriteLine(" Successfully downloaded file from share to local temp folder."); //***** Copy a file from the file share to blob storage, then abort the copy *****// // Copies can sometimes complete before there's a chance to abort. // If that happens with the file you're testing with, try copying the file // to a storage account in a different region. If it still finishes too fast, // try using a bigger file and copying it to a different region. That will almost always // take long enough to give you time to abort the copy. // If you want to change the file you're testing the Copy with without changing the value for the // rest of the sample code, upload the file to the share, then assign the name of the file // to the testFile variable right here before calling GetFileClient. // Then it will use the new file for the copy and abort but the rest of the code // will still use the original file. ShareFileClient shareFileCopy = fileDirectory.GetFileClient(testFile); // Upload a file to the share. Console.WriteLine("Uploading file {0} to share", testFile); // Set up the name and path of the local file. string sourceFileCopy = Path.Combine(localFolder, testFile); using (FileStream stream = File.OpenRead(sourceFile)) { // Upload from the local file to the file share in azure. await shareFileCopy.CreateAsync(stream.Length); await shareFileCopy.UploadAsync(stream); } Console.WriteLine(" Successfully uploaded file to share."); // Copy the file to blob storage. Console.WriteLine("Copying file to blob storage. Container name = {0}", shareName); // First get a blob service client. var blobServiceClient = new BlobServiceClient(storageConnectionString); // Get a blob container client and create it if it doesn't already exist. blobContainer = blobServiceClient.GetBlobContainerClient(shareName); await blobContainer.CreateIfNotExistsAsync(); // Get a blob client to the target blob. targetBlob = blobContainer.GetBlobClient(testFile); string copyId = string.Empty; // Get a share file client to be copied. shareFileClient = fileDirectory.GetFileClient(testFile); // Create a SAS for the file that's valid for 24 hours. // Note that when you are copying a file to a blob, or a blob to a file, you must use a SAS // to authenticate access to the source object, even if you are copying within the same // storage account. var sas = new AccountSasBuilder { // Allow access to Files Services = AccountSasServices.Files, // Allow access to the service level APIs ResourceTypes = AccountSasResourceTypes.All, // Access expires in 1 day! ExpiresOn = DateTime.UtcNow.AddDays(1) }; sas.SetPermissions(AccountSasPermissions.Read); var credential = new StorageSharedKeyCredential(storageAccountName, storageAccountKey); // Build a SAS URI var sasUri = new UriBuilder(shareFileClient.Uri) { Query = sas.ToSasQueryParameters(credential).ToString() }; // Start the copy of the file to the blob. CopyFromUriOperation operation = await targetBlob.StartCopyFromUriAsync(sasUri.Uri); copyId = operation.Id; Console.WriteLine(" File copy started successfully. copyID = {0}", copyId); // Now clean up after yourself. Console.WriteLine("Deleting the files from the file share."); // Delete the files because cloudFile is a different file in the range sample. shareFileClient = fileDirectory.GetFileClient(testFile); await shareFileClient.DeleteIfExistsAsync(); Console.WriteLine("Setting up files to test WriteRange and ListRanges."); //***** Write 2 ranges to a file, then list the ranges *****// // This is the code for trying out writing data to a range in a file, // and then listing those ranges. // Get a reference to a file and write a range of data to it . // Then write another range to it. // Then list the ranges. // Start at the very beginning of the file. long startOffset = 0; // Set the destination file name -- this is the file on the file share that you're writing to. destFile = "rangeops.txt"; shareFileClient = fileDirectory.GetFileClient(destFile); // Create a string with 512 a's in it. This will be used to write the range. int testStreamLen = 512; string textToStream = string.Empty; textToStream = textToStream.PadRight(testStreamLen, 'a'); using (MemoryStream ms = new MemoryStream(Encoding.Default.GetBytes(textToStream))) { // Max size of the output file; have to specify this when you create the file // I picked this number arbitrarily. long maxFileSize = 65536; Console.WriteLine("Write first range."); // Set the stream back to the beginning, in case it's been read at all. ms.Position = 0; // If the file doesn't exist, create it. // The maximum file size is passed in. It has to be big enough to hold // all the data you're going to write, so don't set it to 256k and try to write two 256-k blocks to it. if (!shareFileClient.Exists()) { Console.WriteLine("File doesn't exist, create empty file to write ranges to."); // Create a file with a maximum file size of 64k. await shareFileClient.CreateAsync(maxFileSize); Console.WriteLine(" Empty file created successfully."); } // Write the stream to the file starting at startOffset for the length of the stream. Console.WriteLine("Writing range to file."); var range = new HttpRange(startOffset, textToStream.Length); await shareFileClient.UploadRangeAsync(range, ms); // Download the file to your temp directory so you can inspect it locally. downloadFile = Path.Combine(downloadFolder, "__testrange.txt"); Console.WriteLine("Downloading file to examine."); download = await shareFileClient.DownloadAsync(); using (FileStream stream = File.OpenWrite(downloadFile)) { await download.Content.CopyToAsync(stream); } Console.WriteLine(" Successfully downloaded file with ranges in it to examine."); } // Now add the second range, but don't make it adjacent to the first one, or it will show only // one range, with the two combined. Put it like 1000 spaces away. When you get the range back, it will // start at the position at the 512-multiple border prior or equal to the beginning of the data written, // and it will end at the 512-multliple border after the actual end of the data. //For example, if you write to 2000-3000, the range will be the 512-multiple prior to 2000, which is // position 1536, or offset 1535 (because it's 0-based). // And the right offset of the range will be the 512-multiple after 3000, which is position 3072, // or offset 3071 (because it's 0-based). Console.WriteLine("Getting ready to write second range to file."); startOffset += testStreamLen + 1000; //randomly selected number // Create a string with 512 b's in it. This will be used to write the range. textToStream = string.Empty; textToStream = textToStream.PadRight(testStreamLen, 'b'); using (MemoryStream ms = new MemoryStream(Encoding.Default.GetBytes(textToStream))) { ms.Position = 0; // Write the stream to the file starting at startOffset for the length of the stream. Console.WriteLine("Write second range to file."); var range = new HttpRange(startOffset, textToStream.Length); await shareFileClient.UploadRangeAsync(range, ms); Console.WriteLine(" Successful writing second range to file."); // Download the file to your temp directory so you can examine it. downloadFile = Path.Combine(downloadFolder, "__testrange2.txt"); Console.WriteLine("Downloading file with two ranges in it to examine."); download = await shareFileClient.DownloadAsync(); using (FileStream stream = File.OpenWrite(downloadFile)) { await download.Content.CopyToAsync(stream); } Console.WriteLine(" Successfully downloaded file to examine."); } // Query and view the list of ranges. Console.WriteLine("Call to get the list of ranges."); var listOfRanges = await shareFileClient.GetRangeListAsync(new HttpRange()); Console.WriteLine(" Successfully retrieved list of ranges."); foreach (HttpRange range in listOfRanges.Value.Ranges) { Console.WriteLine(" --> filerange startOffset = {0}, endOffset = {1}", range.Offset, range.Offset + range.Length); } //***** Clean up *****// } catch (Exception ex) { Console.WriteLine(" Exception thrown. Message = {0}{1} Strack Trace = {2}", ex.Message, Environment.NewLine, ex.StackTrace); } finally { //Clean up after you're done. Console.WriteLine("Removing all files, folders, shares, blobs, and containers created in this demo."); // ****NOTE: You can just delete the file share, and everything will be removed. // This samples deletes everything off of the file share first for the purpose of // showing you how to delete specific files and directories. // Delete the file with the ranges in it. destFile = "rangeops.txt"; shareFileClient = fileDirectory.GetFileClient(destFile); await shareFileClient.DeleteIfExistsAsync(); Console.WriteLine("Deleting the directory on the file share."); // Delete the directory. bool success = await fileDirectory.DeleteIfExistsAsync(); if (success) { Console.WriteLine(" Directory on the file share deleted successfully."); } else { Console.WriteLine(" Directory on the file share NOT deleted successfully; may not exist."); } Console.WriteLine("Deleting the file share."); // Delete the share. await shareClient.DeleteAsync(); Console.WriteLine(" Deleted the file share successfully."); Console.WriteLine("Deleting the temporary download directory and the file in it."); // Delete the download folder and its contents. Directory.Delete(downloadFolder, true); Console.WriteLine(" Successfully deleted the temporary download directory."); Console.WriteLine("Deleting the container and blob used in the Copy/Abort test."); await targetBlob.DeleteIfExistsAsync(); await blobContainer.DeleteIfExistsAsync(); Console.WriteLine(" Successfully deleted the blob and its container."); } }