[Storage] Flattened Client Refactor

Cargo.toml

@@ -108,7 +108,6 @@ futures = "0.3"
 getrandom = { version = "0.3" }
 gloo-timers = { version = "0.3" }
 hmac = { version = "0.12" }
-litemap = "0.7.4"
 openssl = { version = "0.10.72" }
 opentelemetry = { version = "0.30", features = ["trace"] }
 opentelemetry_sdk = "0.30"
@@ -149,7 +148,6 @@ url = "2.2"
 uuid = { version = "1.18", features = ["v4"] }
 wasm-bindgen-futures = "0.4"
 wasm-bindgen-test = "0.3"
-zerofrom = "0.1.5"
 zip = { version = "4.0.0", default-features = false, features = ["deflate"] }
 
 [workspace.lints.clippy]

eng/emitter-package.json

@@ -1,17 +1,17 @@
 {
   "main": "dist/src/index.js",
   "dependencies": {
-    "@azure-tools/typespec-rust": "0.24.0"
+    "@azure-tools/typespec-rust": "0.24.1"
   },
   "devDependencies": {
-    "@azure-tools/typespec-azure-core": "0.60",
-    "@azure-tools/typespec-azure-rulesets": "0.60",
-    "@azure-tools/typespec-client-generator-core": "0.60",
-    "@typespec/compiler": "1.4",
-    "@typespec/http": "1.4",
-    "@typespec/openapi": "1.4",
-    "@typespec/rest": "0.74",
-    "@typespec/versioning": "0.74",
-    "@typespec/xml": "0.74"
+    "@azure-tools/typespec-azure-core": "0.61",
+    "@azure-tools/typespec-azure-rulesets": "0.61",
+    "@azure-tools/typespec-client-generator-core": ">=0.61.1",
+    "@typespec/compiler": "1.5.0",
+    "@typespec/http": "1.5.0",
+    "@typespec/openapi": "1.5.0",
+    "@typespec/rest": "0.75.0",
+    "@typespec/versioning": "0.75.0",
+    "@typespec/xml": "0.75.0"
   }
-}
+}

sdk/eventhubs/assets.json

@@ -2,5 +2,5 @@
   "AssetsRepo": "Azure/azure-sdk-assets",
   "AssetsRepoPrefixPath": "rust",
   "TagPrefix": "rust/eventhubs",
-  "Tag": "rust/eventhubs_12266aa668"
+  "Tag": "rust/eventhubs_ad9b84912d"
 }

sdk/eventhubs/azure_messaging_eventhubs_checkpointstore_blob/README.md

@@ -88,8 +88,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let credential = DeveloperToolsCredential::new(None)?;
     let blob_client = BlobContainerClient::new(
         "https://yourstorageaccount.blob.core.windows.net",
-        "yourcontainername".to_string(),
-        credential.clone(),
+        "yourcontainername",
+        Some(credential.clone()),
         None,
     )?;
 

sdk/eventhubs/azure_messaging_eventhubs_checkpointstore_blob/examples/checkpoint_store_basic.rs

@@ -46,8 +46,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Instantiate a blob client with OpenTelemetry instrumentation enabled
     let blob_container_client = BlobContainerClient::new(
         &storage_account_url,
-        container,
-        credential,
+        &container,
+        Some(credential),
         Some(BlobContainerClientOptions {
             client_options: ClientOptions {
                 instrumentation: InstrumentationOptions {

sdk/eventhubs/azure_messaging_eventhubs_checkpointstore_blob/examples/processor_with_blob_checkpoints.rs

@@ -33,8 +33,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let credential = DeveloperToolsCredential::new(None)?;
     let blob_container_client = BlobContainerClient::new(
         &storage_account_url,
-        container_name,
-        credential.clone(),
+        &container_name,
+        Some(credential.clone()),
         None,
     )?;
     let consumer = ConsumerClient::builder()

sdk/eventhubs/azure_messaging_eventhubs_checkpointstore_blob/src/checkpoint_store.rs

@@ -68,9 +68,7 @@ impl BlobCheckpointStore {
         blob_name: &str,
         metadata: HashMap<String, String>,
     ) -> Result<(Option<OffsetDateTime>, Option<Etag>)> {
-        let blob_client = self
-            .blob_container_client
-            .blob_client(blob_name.to_string());
+        let blob_client = self.blob_container_client.blob_client(blob_name);
 
         let result = blob_client.set_metadata(metadata.clone(), None).await;
         match result {
@@ -106,9 +104,7 @@ impl BlobCheckpointStore {
         metadata: Option<HashMap<String, String>>,
         etag: Option<Etag>,
     ) -> Result<(Option<OffsetDateTime>, Option<Etag>)> {
-        let blob_client = self
-            .blob_container_client
-            .blob_client(blob_name.to_string());
+        let blob_client = self.blob_container_client.blob_client(blob_name);
 
         if etag.is_some() {
             debug!(

sdk/eventhubs/azure_messaging_eventhubs_checkpointstore_blob/tests/checkpoint_unit_tests.rs

@@ -17,8 +17,8 @@ pub fn create_test_checkpoint_store(recording: &Recording) -> Result<Arc<BlobChe
     recording.instrument(&mut options.client_options);
     let blob_container_client = BlobContainerClient::new(
         &recording.var("AZURE_STORAGE_BLOB_ENDPOINT", None),
-        recording.var("AZURE_STORAGE_BLOB_CONTAINER", None),
-        credential.clone(),
+        &recording.var("AZURE_STORAGE_BLOB_CONTAINER", None),
+        Some(credential.clone()),
         Some(options),
     )?;
 

sdk/storage/azure_storage_blob/CHANGELOG.md

@@ -4,6 +4,9 @@
 
 ### Features Added
 
+- Added support for SAS (Shared Access Signature) authentication scheme.
+- Added support for unauthenticated client access (public access clients).
+
 ### Breaking Changes
 
 ### Bugs Fixed

sdk/storage/azure_storage_blob/README.md

@@ -48,9 +48,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let credential = DeveloperToolsCredential::new(None)?;
     let blob_client = BlobClient::new(
         "https://<storage_account_name>.blob.core.windows.net/", // endpoint
-        "container_name".to_string(),                            // container name
-        "blob_name".to_string(),                                 // blob name
-        credential,                                              // credential
+        "container_name",                                        // container name
+        "blob_name",                                             // blob name
+        Some(credential),                                        // credential
         Some(BlobClientOptions::default()),                      // BlobClient options
     )?;
     Ok(())
@@ -75,9 +75,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let credential = DeveloperToolsCredential::new(None)?;
     let blob_client = BlobClient::new(
         "https://<storage_account_name>.blob.core.windows.net/", // endpoint
-        "container_name".to_string(),                            // container name
-        "blob_name".to_string(),                                 // blob name
-        credential,                                              // credential
+        "container_name",                                        // container name
+        "blob_name",                                             // blob name
+        Some(credential),                                        // credential
         Some(BlobClientOptions::default()),                      // BlobClient options
     )?;
     Ok(())
@@ -96,9 +96,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let credential = DeveloperToolsCredential::new(None)?;
     let blob_client = BlobClient::new(
         "https://<storage_account_name>.blob.core.windows.net/",
-        "container_name".to_string(),
-        "blob_name".to_string(),
-        credential,
+        "container_name",
+        "blob_name",
+        Some(credential),
         Some(BlobClientOptions::default()),
     )?;
 
@@ -127,9 +127,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let credential = DeveloperToolsCredential::new(None)?;
     let blob_client = BlobClient::new(
         "https://<storage_account_name>.blob.core.windows.net/",
-        "container_name".to_string(),
-        "blob_name".to_string(),
-        credential,
+        "container_name",
+        "blob_name",
+        Some(credential),
         Some(BlobClientOptions::default()),
     )?;
     let blob_properties = blob_client.get_properties(

sdk/storage/azure_storage_blob/assets.json

@@ -1,6 +1,6 @@
 {
   "AssetsRepo": "Azure/azure-sdk-assets",
   "AssetsRepoPrefixPath": "rust",
-  "Tag": "rust/azure_storage_blob_4dd8ebabce",
+  "Tag": "rust/azure_storage_blob_f947fbbe2f",
   "TagPrefix": "rust/azure_storage_blob"
 }

sdk/storage/azure_storage_blob/perf/list_blob_test.rs

@@ -83,7 +83,8 @@ impl PerfTest for ListBlobTest {
         let recording = context.recording();
         let credential = recording.credential();
         let container_name = format!("perf-container-{}", uuid::Uuid::new_v4());
-        let client = BlobContainerClient::new(&self.endpoint, container_name, credential, None)?;
+        let client =
+            BlobContainerClient::new(&self.endpoint, &container_name, Some(credential), None)?;
         self.client.set(client).map_err(|_| {
             azure_core::Error::with_message(ErrorKind::Other, "Failed to set client")
         })?;
@@ -95,7 +96,7 @@ impl PerfTest for ListBlobTest {
         // Create the blobs for the test.
         for i in 0..self.count {
             let blob_name = format!("blob-{}", i);
-            let blob_client = container_client.blob_client(blob_name);
+            let blob_client = container_client.blob_client(&blob_name);
             let body = vec![0u8; 1024 * 1024]; // 1 MB blob
             let body_bytes = Bytes::from(body);
 

sdk/storage/azure_storage_blob/src/clients/append_blob_client.rs

@@ -10,39 +10,35 @@ use crate::{
         AppendBlobClientSealResult,
     },
     pipeline::StorageHeadersPolicy,
-    AppendBlobClientOptions, BlobClientOptions,
+    AppendBlobClientOptions,
 };
 use azure_core::{
     credentials::TokenCredential,
     http::{
         policies::{BearerTokenCredentialPolicy, Policy},
-        NoFormat, RequestContent, Response, Url,
+        NoFormat, Pipeline, RequestContent, Response, Url,
     },
-    Bytes, Result,
+    tracing, Bytes, Result,
 };
 use std::sync::Arc;
 
 /// A client to interact with a specific Azure storage Append blob, although that blob may not yet exist.
 pub struct AppendBlobClient {
-    pub(crate) endpoint: Url,
-    pub(crate) client: GeneratedAppendBlobClient,
+    pub(super) client: GeneratedAppendBlobClient,
 }
 
-impl AppendBlobClient {
-    /// Creates a new AppendBlobClient, using Entra ID authentication.
+impl GeneratedAppendBlobClient {
+    /// Creates a new GeneratedAppendBlobClient from a blob URL.
     ///
     /// # Arguments
     ///
-    /// * `endpoint` - The full URL of the Azure storage account, for example `https://myaccount.blob.core.windows.net/`
-    /// * `container_name` - The name of the container containing this Append blob.
-    /// * `blob_name` - The name of the Append blob to interact with.
-    /// * `credential` - An implementation of [`TokenCredential`] that can provide an Entra ID token to use when authenticating.
+    /// * `blob_url` - The full URL of the Append blob, for example `https://myaccount.blob.core.windows.net/mycontainer/myblob`.
+    /// * `credential` - An optional implementation of [`TokenCredential`] that can provide an Entra ID token to use when authenticating.
     /// * `options` - Optional configuration for the client.
-    pub fn new(
-        endpoint: &str,
-        container_name: String,
-        blob_name: String,
-        credential: Arc<dyn TokenCredential>,
+    #[tracing::new("Storage.Blob.AppendBlob")]
+    pub fn from_url(
+        blob_url: Url,
+        credential: Option<Arc<dyn TokenCredential>>,
         options: Option<AppendBlobClientOptions>,
     ) -> Result<Self> {
         let mut options = options.unwrap_or_default();
@@ -53,32 +49,86 @@ impl AppendBlobClient {
             .per_call_policies
             .push(storage_headers_policy);
 
-        let client = GeneratedAppendBlobClient::new(
-            endpoint,
-            credential,
-            container_name,
-            blob_name,
-            Some(options),
-        )?;
+        let per_retry_policies = if let Some(token_credential) = credential {
+            if !blob_url.scheme().starts_with("https") {
+                return Err(azure_core::Error::with_message(
+                    azure_core::error::ErrorKind::Other,
+                    format!("{blob_url} must use http(s)"),
+                ));
+            }
+            let auth_policy: Arc<dyn Policy> = Arc::new(BearerTokenCredentialPolicy::new(
+                token_credential,
+                vec!["https://storage.azure.com/.default"],
+            ));
+            vec![auth_policy]
+        } else {
+            Vec::default()
+        };
+
+        let pipeline = Pipeline::new(
+            option_env!("CARGO_PKG_NAME"),
+            option_env!("CARGO_PKG_VERSION"),
+            options.client_options.clone(),
+            Vec::default(),
+            per_retry_policies,
+            None,
+        );
+
         Ok(Self {
-            endpoint: endpoint.parse()?,
-            client,
+            endpoint: blob_url,
+            version: options.version,
+            pipeline,
         })
     }
+}
+
+impl AppendBlobClient {
+    /// Creates a new AppendBlobClient, using Entra ID authentication.
+    ///
+    /// # Arguments
+    ///
+    /// * `endpoint` - The full URL of the Azure storage account, for example `https://myaccount.blob.core.windows.net/`
+    /// * `container_name` - The name of the container containing this Append blob.
+    /// * `blob_name` - The name of the Append blob to interact with.
+    /// * `credential` - An implementation of [`TokenCredential`] that can provide an Entra ID token to use when authenticating.
+    /// * `options` - Optional configuration for the client.
+    pub fn new(
+        endpoint: &str,
+        container_name: &str,
+        blob_name: &str,
+        credential: Option<Arc<dyn TokenCredential>>,
+        options: Option<AppendBlobClientOptions>,
+    ) -> Result<Self> {
+        let mut url = Url::parse(endpoint)?;
 
-    /// Gets the endpoint of the Storage account this client is connected to.
-    pub fn endpoint(&self) -> &Url {
-        &self.endpoint
+        url.path_segments_mut()
+            .expect("Invalid endpoint URL: Cannot append container_name and blob_name to the blob endpoint.")
+            .extend([container_name, blob_name]);
+
+        let client = GeneratedAppendBlobClient::from_url(url, credential, options)?;
+        Ok(Self { client })
     }
 
-    /// Gets the container name of the Storage account this client is connected to.
-    pub fn container_name(&self) -> &str {
-        &self.client.container_name
+    /// Creates a new AppendBlobClient from a blob URL.
+    ///
+    /// # Arguments
+    ///
+    /// * `blob_url` - The full URL of the Append blob, for example `https://myaccount.blob.core.windows.net/mycontainer/myblob`.
+    /// * `credential` - An optional implementation of [`TokenCredential`] that can provide an Entra ID token to use when authenticating.
+    /// * `options` - Optional configuration for the client.
+    pub fn from_blob_url(
+        blob_url: Url,
+        credential: Option<Arc<dyn TokenCredential>>,
+        options: Option<AppendBlobClientOptions>,
+    ) -> Result<Self> {
+        let client = GeneratedAppendBlobClient::from_url(blob_url, credential, options)?;
+
+        Ok(Self { client })
     }
 
-    /// Gets the blob name of the Storage account this client is connected to.
-    pub fn blob_name(&self) -> &str {
-        &self.client.blob_name
+    /// Gets the URL of the Storage account this client is connected to.
+    pub fn url(&self) -> &Url {
+        &self.client.endpoint
     }
 
     /// Creates a new Append blob.