Rename DefaultCredential to DefaultAzureCredential (#488)

Author: johnbatty

sdk/identity/examples/default_credentials.rs

@@ -6,7 +6,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     env_logger::init();
 
     let sub_id = std::env::var("AZURE_SUBSCRIPTION_ID")?;
-    let creds = DefaultCredential::default();
+    let creds = DefaultAzureCredential::default();
     let res = creds
         .get_token("https://management.azure.com/")
         .await

sdk/identity/src/errors.rs

@@ -16,7 +16,7 @@ pub enum Error {
         #[from] crate::token_credentials::ManagedIdentityCredentialError,
     ),
     #[error("Error getting default credential: {0}")]
-    DefaultCredentialError(#[from] crate::token_credentials::DefaultCredentialError),
+    DefaultAzureCredentialError(#[from] crate::token_credentials::DefaultAzureCredentialError),
     #[error("Error refreshing token: {0}")]
     RefreshTokenError(#[from] crate::refresh_token::Error),
     /// An unrecognized error response from an identity service.

sdk/identity/src/token_credentials/default_credentials.rs

@@ -5,15 +5,15 @@ use azure_core::TokenResponse;
 use log::debug;
 
 #[derive(Debug, Default)]
-/// Provides a mechanism of selectively disabling credentials used for a `DefaultCredential` instance
-pub struct DefaultCredentialBuilder {
+/// Provides a mechanism of selectively disabling credentials used for a `DefaultAzureCredential` instance
+pub struct DefaultAzureCredentialBuilder {
     include_environment_credential: bool,
     include_managed_identity_credential: bool,
     include_cli_credential: bool,
 }
 
-impl DefaultCredentialBuilder {
-    /// Create a new `DefaultCredentialBuilder`
+impl DefaultAzureCredentialBuilder {
+    /// Create a new `DefaultAzureCredentialBuilder`
     pub fn new() -> Self {
         Self::default()
     }
@@ -36,31 +36,31 @@ impl DefaultCredentialBuilder {
         self
     }
 
-    pub fn build(&self) -> DefaultCredential {
+    pub fn build(&self) -> DefaultAzureCredential {
         let source_count = self.include_cli_credential as usize
             + self.include_cli_credential as usize
             + self.include_managed_identity_credential as usize;
-        let mut sources = Vec::<DefaultCredentialEnum>::with_capacity(source_count);
+        let mut sources = Vec::<DefaultAzureCredentialEnum>::with_capacity(source_count);
         if self.include_environment_credential {
-            sources.push(DefaultCredentialEnum::Environment(
+            sources.push(DefaultAzureCredentialEnum::Environment(
                 EnvironmentCredential::default(),
             ));
         }
         if self.include_managed_identity_credential {
-            sources.push(DefaultCredentialEnum::ManagedIdentity(
+            sources.push(DefaultAzureCredentialEnum::ManagedIdentity(
                 ManagedIdentityCredential {},
             ))
         }
         if self.include_cli_credential {
-            sources.push(DefaultCredentialEnum::AzureCli(AzureCliCredential {}));
+            sources.push(DefaultAzureCredentialEnum::AzureCli(AzureCliCredential {}));
         }
-        DefaultCredential::with_sources(sources)
+        DefaultAzureCredential::with_sources(sources)
     }
 }
 
 #[non_exhaustive]
 #[derive(Debug, thiserror::Error)]
-pub enum DefaultCredentialError {
+pub enum DefaultAzureCredentialError {
     #[error("Error getting token credential from Azure CLI: {0}")]
     AzureCliCredentialError(#[from] super::AzureCliCredentialError),
     #[error("Error getting environment credential: {0}")]
@@ -71,31 +71,31 @@ pub enum DefaultCredentialError {
     EndOfDefaultList,
 }
 
-/// Types of TokenCredential supported by DefaultCredential
-pub enum DefaultCredentialEnum {
+/// Types of TokenCredential supported by DefaultAzureCredential
+pub enum DefaultAzureCredentialEnum {
     Environment(EnvironmentCredential),
     ManagedIdentity(ManagedIdentityCredential),
     AzureCli(AzureCliCredential),
 }
 
 #[async_trait::async_trait]
-impl TokenCredential for DefaultCredentialEnum {
-    type Error = DefaultCredentialError;
+impl TokenCredential for DefaultAzureCredentialEnum {
+    type Error = DefaultAzureCredentialError;
 
     async fn get_token(&self, resource: &str) -> Result<TokenResponse, Self::Error> {
         match self {
-            DefaultCredentialEnum::Environment(credential) => credential
+            DefaultAzureCredentialEnum::Environment(credential) => credential
                 .get_token(resource)
                 .await
-                .map_err(DefaultCredentialError::EnvironmentCredentialError),
-            DefaultCredentialEnum::ManagedIdentity(credential) => credential
+                .map_err(DefaultAzureCredentialError::EnvironmentCredentialError),
+            DefaultAzureCredentialEnum::ManagedIdentity(credential) => credential
                 .get_token(resource)
                 .await
-                .map_err(DefaultCredentialError::ManagedIdentityCredentialError),
-            DefaultCredentialEnum::AzureCli(credential) => credential
+                .map_err(DefaultAzureCredentialError::ManagedIdentityCredentialError),
+            DefaultAzureCredentialEnum::AzureCli(credential) => credential
                 .get_token(resource)
                 .await
-                .map_err(DefaultCredentialError::AzureCliCredentialError),
+                .map_err(DefaultAzureCredentialError::AzureCliCredentialError),
         }
     }
 }
@@ -107,31 +107,31 @@ impl TokenCredential for DefaultCredentialEnum {
 /// - ManagedIdentityCredential
 /// - AzureCliCredential
 /// Consult the documentation of these credential types for more information on how they attempt authentication.
-pub struct DefaultCredential {
-    sources: Vec<DefaultCredentialEnum>,
+pub struct DefaultAzureCredential {
+    sources: Vec<DefaultAzureCredentialEnum>,
 }
 
-impl DefaultCredential {
-    pub fn with_sources(sources: Vec<DefaultCredentialEnum>) -> Self {
-        DefaultCredential { sources }
+impl DefaultAzureCredential {
+    pub fn with_sources(sources: Vec<DefaultAzureCredentialEnum>) -> Self {
+        DefaultAzureCredential { sources }
     }
 }
 
-impl Default for DefaultCredential {
+impl Default for DefaultAzureCredential {
     fn default() -> Self {
-        DefaultCredential {
+        DefaultAzureCredential {
             sources: vec![
-                DefaultCredentialEnum::Environment(EnvironmentCredential::default()),
-                DefaultCredentialEnum::ManagedIdentity(ManagedIdentityCredential {}),
-                DefaultCredentialEnum::AzureCli(AzureCliCredential {}),
+                DefaultAzureCredentialEnum::Environment(EnvironmentCredential::default()),
+                DefaultAzureCredentialEnum::ManagedIdentity(ManagedIdentityCredential {}),
+                DefaultAzureCredentialEnum::AzureCli(AzureCliCredential {}),
             ],
         }
     }
 }
 
 #[async_trait::async_trait]
-impl TokenCredential for DefaultCredential {
-    type Error = DefaultCredentialError;
+impl TokenCredential for DefaultAzureCredential {
+    type Error = DefaultAzureCredentialError;
     /// Try to fetch a token using each of the credential sources until one succeeds
     async fn get_token(&self, resource: &str) -> Result<TokenResponse, Self::Error> {
         for source in &self.sources {
@@ -143,12 +143,12 @@ impl TokenCredential for DefaultCredential {
                 debug!("Failed to get credentials: {:?}", token_res.err().unwrap());
             }
         }
-        Err(DefaultCredentialError::EndOfDefaultList)
+        Err(DefaultAzureCredentialError::EndOfDefaultList)
     }
 }
 
 #[async_trait::async_trait]
-impl azure_core::TokenCredential for DefaultCredential {
+impl azure_core::TokenCredential for DefaultAzureCredential {
     async fn get_token(
         &self,
         resource: &str,

sdk/security_keyvault/src/client.rs

@@ -12,8 +12,8 @@ pub(crate) const API_VERSION_PARAM: &str = formatcp!("api-version={}", API_VERSI
 ///
 /// ```no_run
 /// use azure_security_keyvault::KeyClient;
-/// use azure_identity::token_credentials::DefaultCredential;
-/// let creds = DefaultCredential::default();
+/// use azure_identity::token_credentials::DefaultAzureCredential;
+/// let creds = DefaultAzureCredential::default();
 /// let client = KeyClient::new(&"https://test-key-vault.vault.azure.net", &creds).unwrap();
 /// ```
 #[derive(Debug)]
@@ -31,8 +31,8 @@ impl<'a, T: TokenCredential> KeyClient<'a, T> {
     ///
     /// ```no_run
     /// use azure_security_keyvault::KeyClient;
-    /// use azure_identity::token_credentials::DefaultCredential;
-    /// let creds = DefaultCredential::default();
+    /// use azure_identity::token_credentials::DefaultAzureCredential;
+    /// let creds = DefaultAzureCredential::default();
     /// let client = KeyClient::new("test-key-vault.vault.azure.net", &creds).unwrap();
     /// ```
     pub fn new(vault_url: &str, token_credential: &'a T) -> Result<Self, Error> {

sdk/security_keyvault/src/secret.rs

@@ -123,11 +123,11 @@ impl<'a, T: TokenCredential> KeyClient<'a, T> {
     ///
     /// ```no_run
     /// use azure_security_keyvault::KeyClient;
-    /// use azure_identity::token_credentials::DefaultCredential;
+    /// use azure_identity::token_credentials::DefaultAzureCredential;
     /// use tokio::runtime::Runtime;
     ///
     /// async fn example() {
-    ///     let creds = DefaultCredential::default();
+    ///     let creds = DefaultAzureCredential::default();
     ///     let mut client = KeyClient::new(
     ///     &"KEYVAULT_URL",
     ///     &creds,
@@ -149,11 +149,11 @@ impl<'a, T: TokenCredential> KeyClient<'a, T> {
     ///
     /// ```no_run
     /// use azure_security_keyvault::KeyClient;
-    /// use azure_identity::token_credentials::DefaultCredential;
+    /// use azure_identity::token_credentials::DefaultAzureCredential;
     /// use tokio::runtime::Runtime;
     ///
     /// async fn example() {
-    ///     let creds = DefaultCredential::default();
+    ///     let creds = DefaultAzureCredential::default();
     /// let mut client = KeyClient::new(
     ///     &"KEYVAULT_URL",
     ///     &creds,
@@ -196,11 +196,11 @@ impl<'a, T: TokenCredential> KeyClient<'a, T> {
     ///
     /// ```no_run
     /// use azure_security_keyvault::KeyClient;
-    /// use azure_identity::token_credentials::DefaultCredential;
+    /// use azure_identity::token_credentials::DefaultAzureCredential;
     /// use tokio::runtime::Runtime;
     ///
     /// async fn example() {
-    ///     let creds = DefaultCredential::default();
+    ///     let creds = DefaultAzureCredential::default();
     ///     let mut client = KeyClient::new(
     ///     &"KEYVAULT_URL",
     ///     &creds,
@@ -251,11 +251,11 @@ impl<'a, T: TokenCredential> KeyClient<'a, T> {
     ///
     /// ```no_run
     /// use azure_security_keyvault::KeyClient;
-    /// use azure_identity::token_credentials::DefaultCredential;
+    /// use azure_identity::token_credentials::DefaultAzureCredential;
     /// use tokio::runtime::Runtime;
     ///
     /// async fn example() {
-    ///     let creds = DefaultCredential::default();
+    ///     let creds = DefaultAzureCredential::default();
     ///     let mut client = KeyClient::new(
     ///     &"KEYVAULT_URL",
     ///     &creds,
@@ -316,11 +316,11 @@ impl<'a, T: TokenCredential> KeyClient<'a, T> {
     ///
     /// ```no_run
     /// use azure_security_keyvault::KeyClient;
-    /// use azure_identity::token_credentials::DefaultCredential;
+    /// use azure_identity::token_credentials::DefaultAzureCredential;
     /// use tokio::runtime::Runtime;
     ///
     /// async fn example() {
-    ///     let creds = DefaultCredential::default();
+    ///     let creds = DefaultAzureCredential::default();
     ///     let mut client = KeyClient::new(
     ///     &"KEYVAULT_URL",
     ///     &creds,
@@ -363,11 +363,11 @@ impl<'a, T: TokenCredential> KeyClient<'a, T> {
     ///
     /// ```no_run
     /// use azure_security_keyvault::KeyClient;
-    /// use azure_identity::token_credentials::DefaultCredential;
+    /// use azure_identity::token_credentials::DefaultAzureCredential;
     /// use tokio::runtime::Runtime;
     ///
     /// async fn example() {
-    ///     let creds = DefaultCredential::default();
+    ///     let creds = DefaultAzureCredential::default();
     ///     let mut client = KeyClient::new(
     ///     &"KEYVAULT_URL",
     ///     &creds,
@@ -404,11 +404,11 @@ impl<'a, T: TokenCredential> KeyClient<'a, T> {
     ///
     /// ```no_run
     /// use azure_security_keyvault::{KeyClient, RecoveryLevel};
-    /// use azure_identity::token_credentials::DefaultCredential;
+    /// use azure_identity::token_credentials::DefaultAzureCredential;
     /// use tokio::runtime::Runtime;
     ///
     /// async fn example() {
-    ///     let creds = DefaultCredential::default();
+    ///     let creds = DefaultAzureCredential::default();
     ///     let mut client = KeyClient::new(
     ///     &"KEYVAULT_URL",
     ///     &creds,
@@ -448,12 +448,12 @@ impl<'a, T: TokenCredential> KeyClient<'a, T> {
     ///
     /// ```no_run
     /// use azure_security_keyvault::{KeyClient, RecoveryLevel};
-    /// use azure_identity::token_credentials::DefaultCredential;
+    /// use azure_identity::token_credentials::DefaultAzureCredential;
     /// use tokio::runtime::Runtime;
     /// use chrono::{Utc, Duration};
     ///
     /// async fn example() {
-    ///     let creds = DefaultCredential::default();
+    ///     let creds = DefaultAzureCredential::default();
     ///     let mut client = KeyClient::new(
     ///     &"KEYVAULT_URL",
     ///     &creds,
@@ -507,11 +507,11 @@ impl<'a, T: TokenCredential> KeyClient<'a, T> {
     ///
     /// ```no_run
     /// use azure_security_keyvault::KeyClient;
-    /// use azure_identity::token_credentials::DefaultCredential;
+    /// use azure_identity::token_credentials::DefaultAzureCredential;
     /// use tokio::runtime::Runtime;
     ///
     /// async fn example() {
-    ///     let creds = DefaultCredential::default();
+    ///     let creds = DefaultAzureCredential::default();
     ///     let mut client = KeyClient::new(
     ///     &"KEYVAULT_URL",
     ///     &creds,
@@ -545,11 +545,11 @@ impl<'a, T: TokenCredential> KeyClient<'a, T> {
     ///
     /// ```no_run
     /// use azure_security_keyvault::KeyClient;
-    /// use azure_identity::token_credentials::DefaultCredential;
+    /// use azure_identity::token_credentials::DefaultAzureCredential;
     /// use tokio::runtime::Runtime;
     ///
     /// async fn example() {
-    ///     let creds = DefaultCredential::default();
+    ///     let creds = DefaultAzureCredential::default();
     ///     let mut client = KeyClient::new(
     ///     &"KEYVAULT_URL",
     ///     &creds,
@@ -590,11 +590,11 @@ impl<'a, T: TokenCredential> KeyClient<'a, T> {
     ///
     /// ```no_run
     /// use azure_security_keyvault::{KeyClient, RecoveryLevel};
-    /// use azure_identity::token_credentials::DefaultCredential;
+    /// use azure_identity::token_credentials::DefaultAzureCredential;
     /// use tokio::runtime::Runtime;
     ///
     /// async fn example() {
-    ///     let creds = DefaultCredential::default();
+    ///     let creds = DefaultAzureCredential::default();
     ///     let mut client = KeyClient::new(
     ///     &"KEYVAULT_URL",
     ///     &creds,

sdk/storage/examples/blob_05_default_credential.rs

@@ -2,7 +2,7 @@
 extern crate log;
 
 use azure_core::prelude::*;
-use azure_identity::token_credentials::DefaultCredential;
+use azure_identity::token_credentials::DefaultAzureCredential;
 use azure_identity::token_credentials::TokenCredential;
 use azure_storage::blob::prelude::*;
 use azure_storage::core::prelude::*;
@@ -23,7 +23,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
         .nth(3)
         .expect("please specify the blob name as third command line parameter");
 
-    let bearer_token = DefaultCredential::default()
+    let bearer_token = DefaultAzureCredential::default()
         .get_token("https://storage.azure.com/")
         .await?;
 

sdk/storage/examples/data_lake_00.rs

@@ -1,6 +1,6 @@
 use azure_core::prelude::IfMatchCondition;
 use azure_core::prelude::*;
-use azure_identity::token_credentials::DefaultCredential;
+use azure_identity::token_credentials::DefaultAzureCredential;
 use azure_identity::token_credentials::TokenCredential;
 use azure_storage::core::prelude::*;
 use azure_storage::data_lake::prelude::*;
@@ -26,7 +26,9 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
 
     let resource_id = "https://storage.azure.com/";
     println!("getting bearer token for '{}'...", resource_id);
-    let bearer_token = DefaultCredential::default().get_token(resource_id).await?;
+    let bearer_token = DefaultAzureCredential::default()
+        .get_token(resource_id)
+        .await?;
     println!("token expires on {}", bearer_token.expires_on);
     println!();