This commit contains the following changes:

  * Regenerated client based on new TSP
  * Switching set and get metadata to use the generated client.
  * Added get_statistics
  * Updated samples to show how to pass realistic parameters.

Author: lsiddiquee

Cargo.lock

@@ -1,6 +1,6 @@
 {
   "AssetsRepo": "Azure/azure-sdk-assets",
   "AssetsRepoPrefixPath": "rust",
-  "Tag": "rust/azure_storage_79cfa5e62f",
+  "Tag": "rust/azure_storage_5ed46ef9da",
   "TagPrefix": "rust/azure_storage"
 }

sdk/storage/assets.json

@@ -6,5 +6,5 @@ This directory contains a set of example for the use of the Storage Queue client
 
 The following environment variables need to be set:
 
-- AZURE_QUEUE_STORAGE_ACCOUNT=https://<storage_account_name>.queue.core.windows.net/ - needs to include "https://" and trailing '/'
+- AZURE_QUEUE_STORAGE_ACCOUNT_NAME=<storage_account_name>
 

sdk/storage/azure_storage_queue/examples/README.md

@@ -1,18 +1,32 @@
 pub fn get_endpoint() -> String {
     // Retrieve the storage account endpoint from environment variable.
-    let endpoint = std::env::var("AZURE_QUEUE_STORAGE_ACCOUNT");
-    let endpoint = match endpoint {
+    let storage_account_name = std::env::var("AZURE_QUEUE_STORAGE_ACCOUNT_NAME");
+    let storage_account_name = match storage_account_name {
         Ok(url) => url,
         Err(_) => {
-            eprintln!("Environment variable AZURE_QUEUE_STORAGE_ACCOUNT is not set");
+            eprintln!("Environment variable AZURE_QUEUE_STORAGE_ACCOUNT_NAME is not set");
             std::process::exit(1);
         }
     };
 
-    // Validate endpoint format
-    if !endpoint.ends_with("/") || !endpoint.starts_with("https://") {
-        eprintln!("Endpoint must start with 'https://' and end with '/'");
-        std::process::exit(1);
-    }
-    endpoint
+    format!("https://{}.queue.core.windows.net/", storage_account_name)
+}
+
+// This function is used only for the queue service client example, hence the `allow(dead_code)` attribute.
+#[allow(dead_code)]
+pub fn get_secondary_endpoint() -> String {
+    // Retrieve the storage account endpoint from environment variable.
+    let storage_account_name = std::env::var("AZURE_QUEUE_STORAGE_ACCOUNT_NAME");
+    let storage_account_name = match storage_account_name {
+        Ok(url) => url,
+        Err(_) => {
+            eprintln!("Environment variable AZURE_QUEUE_STORAGE_ACCOUNT_NAME is not set");
+            std::process::exit(1);
+        }
+    };
+
+    format!(
+        "https://{}-secondary.queue.core.windows.net/",
+        storage_account_name
+    )
 }

sdk/storage/azure_storage_queue/examples/helpers/endpoint.rs

@@ -5,14 +5,13 @@ use helpers::endpoint::get_endpoint;
 use helpers::logs::log_operation_result;
 use helpers::random_queue_name::get_random_queue_name;
 
-use azure_core::http::RequestContent;
 use azure_identity::DefaultAzureCredential;
 use azure_storage_queue::{
     clients::QueueClient,
     models::{
-        QueueMessage, QueueMessageIdOperationGroupClientUpdateOptions,
-        QueueMessagesOperationGroupClientDequeueOptions,
-        QueueMessagesOperationGroupClientPeekOptions,
+        ListOfSignedIdentifier, QueueClientDequeueOptions, QueueClientGetMetadataResultHeaders,
+        QueueClientPeekOptions, QueueClientSetMetadataOptions, QueueClientUpdateOptions,
+        QueueMessage,
     },
 };
 
@@ -59,12 +58,12 @@ async fn send_and_update_message(
                     "Updating message with ID: {} and pop receipt: {}",
                     message_id, pop_receipt
                 );
-                let message_xml_string = quick_xml::se::to_string(&QueueMessage {
+                let queue_message = QueueMessage {
                     message_text: Some("Updated message text from Rust".to_string()),
-                });
-                let update_option = QueueMessageIdOperationGroupClientUpdateOptions {
+                };
+                let update_option = QueueClientUpdateOptions {
                     // Serialize the message text as bytes for the update
-                    queue_message: Some(RequestContent::from(message_xml_string?.into_bytes())),
+                    queue_message: Some(queue_message.try_into()?),
                     ..Default::default()
                 };
                 let update_result = queue_client
@@ -78,20 +77,86 @@ async fn send_and_update_message(
     Ok(())
 }
 
-async fn get_and_set_access_policies(
+async fn set_and_get_access_policies(
     queue_client: &QueueClient,
 ) -> Result<(), Box<dyn std::error::Error>> {
+    //     .checked_add(std::time::Duration::from_secs(3600)) // 1 hour from now
+    //     .ok_or("Failed to calculate expiry time")?;
+    // let acl = ListOfSignedIdentifier {
+    //     items: Some(vec![SignedIdentifier {
+    //         id: Some("policy1".to_string()),
+    //         access_policy: Some(AccessPolicy {
+    //             start: Some(OffsetDateTime::now_utc()),
+    //             expiry: Some(expiry_time.into()),
+    //             permission: Some("raup".to_string()),
+    //         }),
+    //     }]),
+    // };
+
+    //     let acl_xml = quick_xml::se::to_string(&acl);
+    //     println!("Access Policy XML: {}", acl_xml?);
+
+    //     let acl_xml = "<SignedIdentifiers>
+    //   <SignedIdentifier>
+    //     <AccessPolicy>
+    //       <Expiry>2025-06-27T15:02:39.351158345Z</Expiry>
+    //       <Permission>raup</Permission>
+    //       <Start>2025-06-26T14:02:39.351160525Z</Start>
+    //     </AccessPolicy>
+    //     <Id>MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTI=</Id>
+    //   </SignedIdentifier>
+    // </SignedIdentifiers>";
+
+    //     let result = queue_client
+    //         .set_access_policy(acl_xml.try_into()?, None)
+    //         .await;
+    // TODO: Fix set and get access policies
+    let acl = ListOfSignedIdentifier {
+        ..Default::default()
+    };
+    let result = queue_client.set_access_policy(acl.try_into()?, None).await;
+    log_operation_result(&result, "set_access_policy");
+
     let result = queue_client.get_access_policy(None).await;
     log_operation_result(&result, "get_access_policy");
-
     let properties = result.unwrap().into_body().await?;
-    let properties_xml = quick_xml::se::to_string(&properties)?;
-    let properties_bytes = properties_xml.into_bytes();
+    if let Some(policies) = properties.items {
+        for policy in policies {
+            println!(
+                "Access Policy - Id: {}, Start: {:?}, Expiry: {:?}, Permissions: {}",
+                &policy.id.unwrap_or_default(),
+                policy.access_policy.clone().unwrap().start.unwrap(),
+                policy.access_policy.clone().unwrap().expiry.unwrap(),
+                policy.access_policy.clone().unwrap().permission.unwrap()
+            );
+        }
+    } else {
+        println!("No access policies found.");
+    }
 
-    let result = queue_client
-        .set_access_policy(RequestContent::from(properties_bytes), None)
-        .await;
-    log_operation_result(&result, "set_access_policy");
+    Ok(())
+}
+
+async fn set_and_get_metadata(
+    queue_client: &QueueClient,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let metadata_options = Some(QueueClientSetMetadataOptions {
+        metadata: Some(HashMap::from([
+            ("key1".to_string(), "value1".to_string()),
+            ("key2".to_string(), "value2".to_string()),
+        ])),
+        ..Default::default()
+    });
+    let result = queue_client.set_metadata(metadata_options).await;
+    log_operation_result(&result, "set_metadata");
+
+    let result = queue_client.get_metadata(None).await;
+    log_operation_result(&result, "get_metadata");
+
+    let metadata = result.unwrap().metadata().unwrap_or_default();
+    for (key, value) in metadata {
+        println!("Metadata - {}: {}", key, value);
+    }
 
     Ok(())
 }
@@ -106,7 +171,7 @@ async fn peek_and_receive_messages(
         .enqueue_message("Message 2 from Rust Queue SDK", None)
         .await;
 
-    let options = QueueMessagesOperationGroupClientPeekOptions {
+    let options = QueueClientPeekOptions {
         number_of_messages: Some(5),
         ..Default::default()
     };
@@ -127,7 +192,7 @@ async fn peek_and_receive_messages(
         }
     }
 
-    let options = QueueMessagesOperationGroupClientDequeueOptions {
+    let options = QueueClientDequeueOptions {
         number_of_messages: Some(5),
         ..Default::default()
     };
@@ -161,10 +226,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let queue_name = get_random_queue_name();
     let queue_client = QueueClient::new(&endpoint, &queue_name, credential.clone(), None)?;
 
-    // Get queue service properties
-    let result = queue_client.get_properties(None).await;
-    log_operation_result(&result, "get_properties");
-
     // Create and manage queue
     let result = queue_client.create(None).await;
     log_operation_result(&result, "create");
@@ -175,10 +236,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let result = queue_client.create_if_not_exists(None).await;
     log_operation_result(&result, "create_if_not_exists");
 
-    // Set queue metadata
-    let metadata = HashMap::from([("key1", "value1"), ("key2", "value2")]);
-    let result = queue_client.set_metadata(Some(metadata)).await;
-    log_operation_result(&result, "set_metadata");
+    // Set and get queue metadata
+    set_and_get_metadata(&queue_client).await?;
 
     let result = queue_client.enqueue_message("Example Message", None).await;
     log_operation_result(&result, "enqueue_message");
@@ -203,7 +262,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Receive messages
     peek_and_receive_messages(&queue_client).await?;
 
-    get_and_set_access_policies(&queue_client).await?;
+    // Set and get access policies
+    set_and_get_access_policies(&queue_client).await?;
 
     // Cleanup
     let result = queue_client.delete(None).await;