Add more data_lake operations (#495)

* Initial implementation of FileSystemClient.update_path().

* Better names for handcrafted API.

* Add FileSystemClient.create_file_if_not_exists()

* Better name.

* Make append_to_file work.

* Add file_flush operation.

* Make position a parameter for appending to file.

* Better name.

* Remove comment.

* Add basic rename file operation.

* Take "close" as parameter for flush_file.

* Separate file system and file operations from each other in test and examples.

* Align client names in data_lake examples to client names in data_lake e2e test.

* PR feedback: less println!().

* Make rename source a local thing.

Author: thovoll

sdk/core/src/request_options/content_length.rs

@@ -5,7 +5,6 @@ use http::request::Builder;
 pub struct ContentLength(i32);
 
 impl ContentLength {
-    /// Create a new `ContentLength`
     pub fn new(count: i32) -> Self {
         Self(count)
     }

sdk/storage/examples/data_lake_00.rs

@@ -1,4 +1,3 @@
-use azure_core::prelude::IfMatchCondition;
 use azure_core::prelude::*;
 use azure_identity::token_credentials::DefaultAzureCredential;
 use azure_identity::token_credentials::TokenCredential;
@@ -17,7 +16,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
         .expect("Set env variable ADLSGEN2_STORAGE_MASTER_KEY first!");
 
     let now = Utc::now();
-    let file_system_name = format!("azurerustsdk-datalake-example-{}", now.timestamp());
+    let file_system_name = format!("azurerustsdk-datalake-example00-{}", now.timestamp());
 
     let http_client = new_http_client();
 
@@ -29,107 +28,72 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     let bearer_token = DefaultAzureCredential::default()
         .get_token(resource_id)
         .await?;
-    println!("token expires on {}", bearer_token.expires_on);
-    println!();
+    println!("token expires on {}\n", bearer_token.expires_on);
 
     let storage_client = storage_account_client.as_storage_client();
-    let data_lake = DataLakeClient::new(
+    let data_lake_client = DataLakeClient::new(
         storage_client,
         account,
         bearer_token.token.secret().to_owned(),
         None,
     );
 
-    let file_system = data_lake
+    let file_system_client = data_lake_client
         .clone()
         .into_file_system_client(file_system_name.to_string());
 
     let mut fs_properties = Properties::new();
     fs_properties.insert("AddedVia", "Azure SDK for Rust");
 
     println!("creating file system '{}'...", &file_system_name);
-    let create_fs_response = file_system
+    let create_fs_response = file_system_client
         .create()
         .properties(&fs_properties)
         .execute()
         .await?;
-    println!("create file system response == {:?}", create_fs_response);
-    println!();
+    println!("create file system response == {:?}\n", create_fs_response);
 
     println!("listing file systems...");
     let mut stream = Box::pin(
-        data_lake
+        data_lake_client
             .list()
             .max_results(NonZeroU32::new(3).unwrap())
             .stream(),
     );
     while let Some(list_fs_response) = stream.next().await {
-        println!("list file system response == {:?}", list_fs_response);
-        println!();
+        println!("list file system response == {:?}\n", list_fs_response);
     }
 
     println!("getting file system properties...");
-    let get_fs_props_response = file_system.get_properties().execute().await?;
+    let get_fs_props_response = file_system_client.get_properties().execute().await?;
     println!(
-        "get file system properties response == {:?}",
+        "get file system properties response == {:?}\n",
         get_fs_props_response
     );
-    println!();
-
-    let file_name = "example-file.txt";
-
-    println!("creating path '{}'...", file_name);
-    let create_path_response = file_system
-        .create_path(Context::default(), file_name, CreatePathOptions::default())
-        .await?;
-    println!("create path response == {:?}", create_path_response);
-    println!();
-
-    println!("creating path '{}' (overwrite)...", file_name);
-    let create_path_response = file_system
-        .create_path(Context::default(), file_name, CreatePathOptions::default())
-        .await?;
-    println!("create path response == {:?}", create_path_response);
-    println!();
-
-    println!("creating path '{}' (do not overwrite)...", file_name);
-    let do_not_overwrite =
-        CreatePathOptions::new().if_match_condition(IfMatchCondition::NotMatch("*"));
-    let create_path_result = file_system
-        .create_path(Context::default(), file_name, do_not_overwrite)
-        .await;
-    println!(
-        "create path result (should fail) == {:?}",
-        create_path_result
-    );
-    println!();
 
     println!("setting file system properties...");
     fs_properties.insert("ModifiedBy", "Iota");
-    let set_fs_props_response = file_system
+    let set_fs_props_response = file_system_client
         .set_properties(Some(&fs_properties))
         .execute()
         .await?;
     println!(
-        "set file system properties response == {:?}",
+        "set file system properties response == {:?}\n",
         set_fs_props_response
     );
-    println!();
 
     println!("getting file system properties...");
-    let get_fs_props_response = file_system.get_properties().execute().await?;
+    let get_fs_props_response = file_system_client.get_properties().execute().await?;
     println!(
-        "get file system properties response == {:?}",
+        "get file system properties response == {:?}\n",
         get_fs_props_response
     );
-    println!();
 
     println!("deleting file system...");
-    let delete_fs_response = file_system.delete().execute().await?;
-    println!("delete file system response == {:?}", delete_fs_response);
-    println!();
+    let delete_fs_response = file_system_client.delete().execute().await?;
+    println!("delete file system response == {:?}\n", delete_fs_response);
 
-    println!("data lake example done.");
+    println!("data lake example 00 done.");
 
     Ok(())
 }

sdk/storage/examples/data_lake_01.rs

@@ -0,0 +1,118 @@
+use azure_core::prelude::*;
+use azure_identity::token_credentials::DefaultAzureCredential;
+use azure_identity::token_credentials::TokenCredential;
+use azure_storage::core::prelude::*;
+use azure_storage::data_lake::prelude::*;
+use chrono::Utc;
+use std::error::Error;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
+    let account = std::env::var("ADLSGEN2_STORAGE_ACCOUNT")
+        .expect("Set env variable ADLSGEN2_STORAGE_ACCOUNT first!");
+    let master_key = std::env::var("ADLSGEN2_STORAGE_MASTER_KEY")
+        .expect("Set env variable ADLSGEN2_STORAGE_MASTER_KEY first!");
+
+    let now = Utc::now();
+    let file_system_name = format!("azurerustsdk-datalake-example01-{}", now.timestamp());
+
+    let http_client = new_http_client();
+
+    let storage_account_client =
+        StorageAccountClient::new_access_key(http_client.clone(), &account, &master_key);
+
+    let resource_id = "https://storage.azure.com/";
+    println!("getting bearer token for '{}'...", resource_id);
+    let bearer_token = DefaultAzureCredential::default()
+        .get_token(resource_id)
+        .await?;
+    println!("token expires on {}\n", bearer_token.expires_on);
+
+    let storage_client = storage_account_client.as_storage_client();
+    let data_lake_client = DataLakeClient::new(
+        storage_client,
+        account,
+        bearer_token.token.secret().to_owned(),
+        None,
+    );
+
+    let file_system_client = data_lake_client
+        .clone()
+        .into_file_system_client(file_system_name.to_string());
+
+    println!("creating file system '{}'...", &file_system_name);
+    let create_fs_response = file_system_client.create().execute().await?;
+    println!("create file system response == {:?}\n", create_fs_response);
+
+    let file_path = "some/path/example-file.txt";
+
+    println!("creating file '{}'...", file_path);
+    let create_file_response = file_system_client
+        .create_file(Context::default(), file_path, FileCreateOptions::default())
+        .await?;
+    println!("create file response == {:?}\n", create_file_response);
+
+    println!("creating file '{}' (overwrite)...", file_path);
+    let create_file_response = file_system_client
+        .create_file(Context::default(), file_path, FileCreateOptions::default())
+        .await?;
+    println!("create file response == {:?}\n", create_file_response);
+
+    println!("creating file '{}' if not exists...", file_path);
+    let create_file_if_not_exists_result = file_system_client
+        .create_file_if_not_exists(Context::default(), file_path)
+        .await;
+    println!(
+        "create file result (should fail) == {:?}\n",
+        create_file_if_not_exists_result
+    );
+
+    println!("appending to file '{}'...", file_path);
+    let bytes = bytes::Bytes::from("some data");
+    let file_length = bytes.len() as i64;
+    let append_to_file_response = file_system_client
+        .append_to_file(
+            Context::default(),
+            file_path,
+            bytes,
+            0,
+            FileAppendOptions::default(),
+        )
+        .await?;
+    println!("append to file response == {:?}\n", append_to_file_response);
+
+    println!("flushing file '{}'...", file_path);
+    let flush_file_response = file_system_client
+        .flush_file(
+            Context::default(),
+            file_path,
+            file_length,
+            true,
+            FileFlushOptions::default(),
+        )
+        .await?;
+    println!("flush file response == {:?}\n", flush_file_response);
+
+    let destination_file_path = "some/path/example-file-renamed.txt";
+    println!(
+        "renaming file '{}' to '{}'...",
+        file_path, destination_file_path
+    );
+    let rename_file_response = file_system_client
+        .rename_file(
+            Context::default(),
+            file_path,
+            destination_file_path,
+            FileRenameOptions::default(),
+        )
+        .await?;
+    println!("rename file response == {:?}\n", rename_file_response);
+
+    println!("deleting file system...");
+    let delete_fs_response = file_system_client.delete().execute().await?;
+    println!("delete file system response == {:?}\n", delete_fs_response);
+
+    println!("data lake example 01 done.");
+
+    Ok(())
+}