private static void Step2_CreateModelJson() { var json = ModelJsonBuilder.Run( new List <Type> { typeof(Product), typeof(Order), typeof(OrderRow), }, new List <Tuple <Type, string, Type, string> > { new Tuple <Type, string, Type, string>(typeof(Order), nameof(Order.OrderID), typeof(OrderRow), nameof(OrderRow.OrderID)), new Tuple <Type, string, Type, string>(typeof(Product), nameof(Product.ProductID), typeof(OrderRow), nameof(OrderRow.ProductID)) }, _csvFileList); string fileName = "model.json"; if (_configuration.GetValue <bool>("DumpToLocalFile")) { File.WriteAllText(fileName, json); } if (_configuration.GetValue <bool>("UploadToADLSGen2")) { byte[] buffer = Encoding.UTF8.GetBytes(json); var adlsFileClient = _ADLSDirectoryClient.GetFileClient("model.json"); Console.WriteLine($"Uploading {adlsFileClient.Uri.ToString()}"); adlsFileClient.Create(); adlsFileClient.Append(new MemoryStream(buffer), 0); adlsFileClient.Flush(buffer.Length); } }
// </Snippet_DownloadFromDirectory> #endregion #region Download a binary file from a directory // --------------------------------------------------------- // Download file from directory (binary) //---------------------------------------------------------- // <Snippet_DownloadBinaryFromDirectory> public async Task DownloadFile(DataLakeFileSystemClient fileSystemClient) { DataLakeDirectoryClient directoryClient = fileSystemClient.GetDirectoryClient("my-directory"); DataLakeFileClient fileClient = directoryClient.GetFileClient("my-image.png"); Response <FileDownloadInfo> downloadResponse = await fileClient.ReadAsync(); BinaryReader reader = new BinaryReader(downloadResponse.Value.Content); FileStream fileStream = File.OpenWrite("C:\\Users\\contoso\\my-image-downloaded.png"); int bufferSize = 4096; byte[] buffer = new byte[bufferSize]; int count; while ((count = reader.Read(buffer, 0, buffer.Length)) != 0) { fileStream.Write(buffer, 0, count); } await fileStream.FlushAsync(); fileStream.Close(); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "SevenZip/{account}/{container}/{directory}/{filename}")] HttpRequest req, string account, string container, string directory, string filename, ILogger log) { //Retrieve File from storage var lakeClient = GetDataLakeServiceClient(HttpUtility.UrlDecode(account)); var fileSystemClient = lakeClient.GetFileSystemClient(HttpUtility.UrlDecode(container)); DataLakeDirectoryClient directoryClient = fileSystemClient.GetDirectoryClient(HttpUtility.UrlDecode(directory)); var DownloadFile = directoryClient.GetFileClient(HttpUtility.UrlDecode(filename)); var ReadStream = await DownloadFile.OpenReadAsync(); var response = req.HttpContext.Response; response.StatusCode = 200; response.ContentType = "application/json-data-stream"; using (var archive = SevenZipArchive.Open(ReadStream, null)) { foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { foreach (IArchiveEntry e in archive.Entries) { e.WriteTo(response.Body); } } } return(new EmptyResult()); }
public async Task CreateFileClientAsync_Directory() { // Make StorageSharedKeyCredential to pass to the serviceClient string storageAccountName = StorageAccountName; string storageAccountKey = StorageAccountKey; Uri serviceUri = StorageAccountBlobUri; StorageSharedKeyCredential sharedKeyCredential = new StorageSharedKeyCredential(storageAccountName, storageAccountKey); // Create DataLakeServiceClient using StorageSharedKeyCredentials DataLakeServiceClient serviceClient = new DataLakeServiceClient(serviceUri, sharedKeyCredential); // Create a DataLake Filesystem DataLakeFileSystemClient filesystem = serviceClient.GetFileSystemClient(Randomize("sample-filesystem")); await filesystem.CreateAsync(); //Create a DataLake Directory DataLakeDirectoryClient directory = filesystem.CreateDirectory(Randomize("sample-directory")); await directory.CreateAsync(); // Create a DataLake File using a DataLake Directory DataLakeFileClient file = directory.GetFileClient(Randomize("sample-file")); await file.CreateAsync(); // Verify we created one file AsyncPageable <PathItem> response = filesystem.GetPathsAsync(); IList <PathItem> paths = await response.ToListAsync(); Assert.AreEqual(1, paths.Count); // Cleanup await filesystem.DeleteAsync(); }
#pragma warning disable CA1806 // Do not ignore method results public override void Run(CancellationToken cancellationToken) { var serviceClient = new DataLakeServiceClient(s_testEnvironment.DataLakeServiceUri); new DataLakeServiceClient(s_testEnvironment.DataLakeServiceUri, s_tokenCredential); new DataLakeServiceClient(s_testEnvironment.DataLakeServiceUri, s_testEnvironment.DataLakeCredential); var fileSystemClient = new DataLakeFileSystemClient(s_fileSystemUri); new DataLakeFileSystemClient(s_fileSystemUri, s_tokenCredential); new DataLakeFileSystemClient(s_fileSystemUri, s_testEnvironment.DataLakeCredential); var directoryClient = new DataLakeDirectoryClient(s_directoryUri); new DataLakeDirectoryClient(s_directoryUri, s_tokenCredential); new DataLakeDirectoryClient(s_directoryUri, s_testEnvironment.DataLakeCredential); new DataLakeFileClient(s_fileUri); new DataLakeFileClient(s_fileUri, s_tokenCredential); new DataLakeFileClient(s_fileUri, s_testEnvironment.DataLakeCredential); new DataLakePathClient(s_fileUri); new DataLakePathClient(s_fileUri, s_tokenCredential); new DataLakePathClient(s_fileUri, s_testEnvironment.DataLakeCredential); serviceClient.GetFileSystemClient("foo"); fileSystemClient.GetDirectoryClient("foo"); fileSystemClient.GetFileClient("foo"); directoryClient.GetFileClient("foo"); }
public void CreateFileClient_Directory() { // Make StorageSharedKeyCredential to pass to the serviceClient string storageAccountName = StorageAccountName; string storageAccountKey = StorageAccountKey; Uri serviceUri = StorageAccountBlobUri; #region Snippet:SampleSnippetDataLakeFileSystemClient_Create StorageSharedKeyCredential sharedKeyCredential = new StorageSharedKeyCredential(storageAccountName, storageAccountKey); // Create DataLakeServiceClient using StorageSharedKeyCredentials DataLakeServiceClient serviceClient = new DataLakeServiceClient(serviceUri, sharedKeyCredential); // Create a DataLake Filesystem DataLakeFileSystemClient filesystem = serviceClient.GetFileSystemClient(Randomize("sample-filesystem")); filesystem.Create(); #endregion Snippet:SampleSnippetDataLakeFileSystemClient_Create #region Snippet:SampleSnippetDataLakeFileClient_Create_Directory // Create a DataLake Directory DataLakeDirectoryClient directory = filesystem.CreateDirectory(Randomize("sample-directory")); directory.Create(); // Create a DataLake File using a DataLake Directory DataLakeFileClient file = directory.GetFileClient(Randomize("sample-file")); file.Create(); #endregion Snippet:SampleSnippetDataLakeFileClient_Create_Directory // Verify we created one file Assert.AreEqual(1, filesystem.ListPaths().Count()); // Cleanup filesystem.Delete(); }
public IDisposable GetNewFile(out DataLakeFileClient file, DataLakeServiceClient service = default, string fileSystemName = default, string directoryName = default, string fileName = default) { IDisposable disposingFileSystem = GetNewFileSystem(out DataLakeFileSystemClient fileSystem, service, fileSystemName); DataLakeDirectoryClient directory = InstrumentClient(fileSystem.GetDirectoryClient(directoryName ?? GetNewDirectoryName())); _ = directory.CreateAsync().Result; file = InstrumentClient(directory.GetFileClient(fileName ?? GetNewFileName())); _ = file.CreateAsync().Result; return(disposingFileSystem); }
// </Snippet_UploadFile> #endregion #region Upload files to a directory in bulk // --------------------------------------------------------- // Upload files to the directory - bulk uploads //---------------------------------------------------------- // <Snippet_UploadFileBulk> public async Task UploadFileBulk(DataLakeFileSystemClient fileSystemClient) { DataLakeDirectoryClient directoryClient = fileSystemClient.GetDirectoryClient("my-directory"); DataLakeFileClient fileClient = directoryClient.GetFileClient("uploaded-file.txt"); FileStream fileStream = File.OpenRead("C:\\Users\\contoso\\file-to-upload.txt"); await fileClient.UploadAsync(fileStream); }
static async Task ApplyACLsToSampleData(DataLakeDirectoryClient rootDirectoryClient, AppSettings settings) { Console.WriteLine("Applying Execute and Read ACLs to root directory..."); await ApplyACLsForDirectory(rootDirectoryClient, RolePermissions.Execute | RolePermissions.Read, settings); Console.WriteLine(@"Applying Execute and Read ACLs to root ""Files For Organization""..."); var filesForOrganizationClient = rootDirectoryClient.GetFileClient("Files for Organization.txt"); await ApplyACLsForFile(filesForOrganizationClient, RolePermissions.Execute | RolePermissions.Read, settings); Console.WriteLine("Applying Execute And Read ACLs to Shared Documents directory recursively..."); var sharedDocumentsDirectoryClient = rootDirectoryClient.GetSubDirectoryClient("Shared Documents"); await ApplyACLsForDirectory(sharedDocumentsDirectoryClient, RolePermissions.Execute | RolePermissions.Read, settings, recursive : true); Console.WriteLine("Applying Execute and Read ACLs to User Documents directory..."); var userDocumentsDirectoryClient = rootDirectoryClient.GetSubDirectoryClient("User Documents"); await ApplyACLsForDirectory(userDocumentsDirectoryClient, RolePermissions.Execute | RolePermissions.Read, settings); Console.WriteLine("Applying Execute and Read ACLs to Alice's document directory..."); var aliceDirectoryClient = userDocumentsDirectoryClient.GetSubDirectoryClient("Alice"); await ApplyACLsForDirectory(aliceDirectoryClient, RolePermissions.Execute | RolePermissions.Read, settings); Console.WriteLine(@"Applying Execute and Read ACLs to ""Alice.txt""..."); var aliceTxtFile = aliceDirectoryClient.GetFileClient("alice.txt"); await ApplyACLsForFile(aliceTxtFile, RolePermissions.Execute | RolePermissions.Read, settings); Console.WriteLine("Applying Execute and Read ACLs to John's document directory recursively..."); var johnDirectoryClient = userDocumentsDirectoryClient.GetSubDirectoryClient("John"); await ApplyACLsForDirectory(johnDirectoryClient, RolePermissions.Execute | RolePermissions.Read, settings, recursive : true); Console.WriteLine("Applying Execute and Read ACLs to Bob's document directory recursively..."); var bobDirectoryClient = userDocumentsDirectoryClient.GetSubDirectoryClient("Bob"); await ApplyACLsForDirectory(bobDirectoryClient, RolePermissions.Execute | RolePermissions.Read, settings, recursive : true); Console.WriteLine(@"Removing Execute and Read ACLs from ""c.txt"""); var cClient = bobDirectoryClient.GetSubDirectoryClient("Reports").GetFileClient("c.txt"); await RemoveACLsForFile(cClient, settings); Console.WriteLine(@"Removing Execute and Read ACLs from Bob's Sales directory recursively..."); var salesClient = bobDirectoryClient.GetSubDirectoryClient("Sales"); await RemoveACLsForDirectory(salesClient, settings, recursive : true); }
public async Task <dynamic> DownloadJsonData(DataLakeFileSystemClient fileSystemClient, string directory, string filePath) { DataLakeDirectoryClient directoryClient = fileSystemClient.GetDirectoryClient(directory); DataLakeFileClient fileClient = directoryClient.GetFileClient(filePath); Response <FileDownloadInfo> downloadResponse = await fileClient.ReadAsync(); var streamContent = new StreamContent(downloadResponse.Value.Content); var stringContent = await streamContent.ReadAsStringAsync(); return(JsonConvert.DeserializeObject <dynamic>(stringContent)); }
// </Snippet_ACLDirectory> #endregion #region Get and set file ACLs // --------------------------------------------------------- // Get and set ACLs on files //---------------------------------------------------------- // <Snippet_FileACL> public async Task ManageFileACLs(DataLakeFileSystemClient fileSystemClient) { DataLakeDirectoryClient directoryClient = fileSystemClient.GetDirectoryClient("my-directory"); DataLakeFileClient fileClient = directoryClient.GetFileClient("hello.txt"); PathAccessControl FileAccessControl = await fileClient.GetAccessControlAsync(); foreach (var item in FileAccessControl.AccessControlList) { Console.WriteLine(item.ToString()); } IList <PathAccessControlItem> accessControlList = PathAccessControlExtensions.ParseAccessControlList ("user::rwx,group::r-x,other::rw-"); fileClient.SetAccessControlList(accessControlList); }
static async Task UploadSampleDataIfNotExistsAsync(string localDirectory, DataLakeDirectoryClient directoryClient) { // Upload all sample data files in this directory foreach (string filePath in Directory.GetFiles(localDirectory)) { string fileName = Path.GetFileName(filePath); DataLakeFileClient fileClient = directoryClient.GetFileClient(fileName); if (!await fileClient.ExistsAsync()) { await fileClient.UploadAsync(filePath); } } // Recursively create subdirectories, and upload all sample data files in those subdirectories foreach (string directory in Directory.GetDirectories(localDirectory)) { string directoryName = Path.GetFileNameWithoutExtension(directory); DataLakeDirectoryClient subDirectoryClient = directoryClient.GetSubDirectoryClient(directoryName); await subDirectoryClient.CreateIfNotExistsAsync(); await UploadSampleDataIfNotExistsAsync(directory, subDirectoryClient); } }
public async Task DownloadFile(DataLakeFileSystemClient fileSystemClient, string keywordFilename, string outputFilePath) { DataLakeDirectoryClient directoryClient = fileSystemClient.GetDirectoryClient(stAccountDirectory); DataLakeFileClient fileClient = directoryClient.GetFileClient(keywordFilename); Response <FileDownloadInfo> downloadResponse = await fileClient.ReadAsync(); BinaryReader reader = new BinaryReader(downloadResponse.Value.Content); FileStream fileStream = File.OpenWrite(outputFilePath); int bufferSize = 4096; byte[] buffer = new byte[bufferSize]; int count; while ((count = reader.Read(buffer, 0, buffer.Length)) != 0) { fileStream.Write(buffer, 0, count); } await fileStream.FlushAsync(); fileStream.Close(); }
// </Snippet_UploadFileBulk> #endregion #region Download a file from a directory // --------------------------------------------------------- // Download file from directory //---------------------------------------------------------- // <Snippet_DownloadFromDirectory> public async Task DownloadFile2(DataLakeFileSystemClient fileSystemClient) { DataLakeDirectoryClient directoryClient = fileSystemClient.GetDirectoryClient("my-directory"); DataLakeFileClient fileClient = directoryClient.GetFileClient("my-image.png"); Response <FileDownloadInfo> downloadResponse = await fileClient.ReadAsync(); StreamReader reader = new StreamReader(downloadResponse.Value.Content); FileStream fileStream = File.OpenWrite("C:\\Users\\contoso\\my-image-downloaded.png"); string output = await reader.ReadToEndAsync(); byte[] data = System.Text.Encoding.UTF8.GetBytes(output); fileStream.Write(data, 0, data.Length); await fileStream.FlushAsync(); fileStream.Close(); }
private static async Task DownloadAsync(string fileSystem, string directory, string fileName) { DataLakeFileSystemClient fileSystemClient = _dataLakeClient.GetFileSystemClient(fileSystem); DataLakeDirectoryClient directoryClient = fileSystemClient.GetDirectoryClient(directory); DataLakeFileClient fileClient = directoryClient.GetFileClient(fileName); Console.WriteLine("\nStarting download..."); Response <FileDownloadInfo> downloadResponse = await fileClient.ReadAsync(); var reader = new BinaryReader(downloadResponse.Value.Content); FileStream fileStream = File.OpenWrite($"{fileName}"); const int bufferSize = 4096; var buffer = new byte[bufferSize]; int count; while ((count = reader.Read(buffer, 0, buffer.Length)) != 0) { fileStream.Write(buffer, 0, count); } await fileStream.FlushAsync(); fileStream.Close(); Console.WriteLine($"File downloaded to {fileName}\n"); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "SevenZipV2/{account}/{container}/{directory}/{filename}")] HttpRequest req, string account, string container, string directory, string filename, ILogger log) { //Retrieve File from storage var lakeClient = SevenZip.GetDataLakeServiceClient(HttpUtility.UrlDecode(account)); var fileSystemClient = lakeClient.GetFileSystemClient(HttpUtility.UrlDecode(container)); DataLakeDirectoryClient directoryClient = fileSystemClient.GetDirectoryClient(HttpUtility.UrlDecode(directory)); var DownloadFile = directoryClient.GetFileClient(HttpUtility.UrlDecode(filename)); var ReadStream = await DownloadFile.OpenReadAsync(); //Begin to send first http response var response = req.HttpContext.Response; response.StatusCode = 200; response.ContentType = "application/json-data-stream"; await response.Body.WriteAsync(Encoding.UTF8.GetBytes("[")); using (var archive = SevenZipArchive.Open(ReadStream, null)) { //Retrieve uncompressed Stream IArchiveEntry e = archive.Entries.FirstOrDefault(); var un7ZipStream = e.OpenEntryStream(); log.LogInformation($"Stream Opened {filename}"); XmlReaderSettings settings = new XmlReaderSettings(); settings.Async = true; settings.IgnoreWhitespace = true; using (XmlReader reader = XmlReader.Create(un7ZipStream, settings)) { bool keepReading = reader.Read(); bool firstrow = true; while (keepReading) { if ((reader.NodeType == XmlNodeType.Element) && (reader.Name == "row") && reader.HasAttributes) { dynamic exo = new ExpandoObject(); for (int attInd = 0; attInd < reader.AttributeCount; attInd++) { reader.MoveToAttribute(attInd); ((IDictionary <String, Object>)exo).Add(reader.Name, reader.Value); /*if(reader.Name == "Id"&&int.Parse(reader.Value)%1000==0) * { * log.LogInformation(reader.Value); * } */ } await response.Body.WriteAsync(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(exo))); } if (reader.Read()) { if ((reader.NodeType == XmlNodeType.Element) && (reader.Name == "row") && reader.HasAttributes) { if (!firstrow) { await response.Body.WriteAsync(Encoding.UTF8.GetBytes(",")); } else { firstrow = false; } } } else { keepReading = false; } } } } await response.Body.WriteAsync(Encoding.UTF8.GetBytes("]")); return(new EmptyResult()); }
public void Traverse() { // Create a temporary Lorem Ipsum file on disk that we can upload string originalPath = CreateTempFile(SampleFileContent); // Make StorageSharedKeyCredential to pass to the serviceClient string storageAccountName = StorageAccountName; string storageAccountKey = StorageAccountKey; Uri serviceUri = StorageAccountBlobUri; StorageSharedKeyCredential sharedKeyCredential = new StorageSharedKeyCredential(storageAccountName, storageAccountKey); // Create DataLakeServiceClient using StorageSharedKeyCredentials DataLakeServiceClient serviceClient = new DataLakeServiceClient(serviceUri, sharedKeyCredential); // Get a reference to a filesystem named "sample-filesystem-traverse" and then create it DataLakeFileSystemClient filesystem = serviceClient.GetFileSystemClient(Randomize("sample-filesystem-traverse")); filesystem.Create(); try { // Create a bunch of directories and files within the directories DataLakeDirectoryClient first = filesystem.CreateDirectory("first"); first.CreateSubDirectory("a"); first.CreateSubDirectory("b"); DataLakeDirectoryClient second = filesystem.CreateDirectory("second"); second.CreateSubDirectory("c"); second.CreateSubDirectory("d"); filesystem.CreateDirectory("third"); DataLakeDirectoryClient fourth = filesystem.CreateDirectory("fourth"); DataLakeDirectoryClient deepest = fourth.CreateSubDirectory("e"); // Upload a DataLake file named "file" DataLakeFileClient file = deepest.GetFileClient("file"); file.Create(); using (FileStream stream = File.OpenRead(originalPath)) { file.Append(stream, 0); } // Keep track of all the names we encounter List <string> names = new List <string>(); foreach (PathItem pathItem in filesystem.ListPaths(recursive: true)) { names.Add(pathItem.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("first/a", names); Assert.Contains("first/b", names); Assert.Contains("second/c", names); Assert.Contains("second/d", names); Assert.Contains("fourth/e", names); Assert.Contains("fourth/e/file", names); } finally { // Clean up after the test when we're finished filesystem.Delete(); } }