use crate::error::AuthError;
use crate::token::validate_token;
use std::process::Command;
const CLOUD_PLATFORM_SCOPE: &str = "https://www.googleapis.com/auth/cloud-platform";
pub async fn get_credentials(explicit_token: Option<&str>) -> Result<String, AuthError> {
if let Some(token) = explicit_token {
validate_token(token)?;
return Ok(token.to_string());
}
log::debug!("Retrieving application default credentials...");
match get_adc_credentials().await {
Ok(token) => {
log::debug!("Successfully retrieved Application Default Credentials.");
return Ok(token);
}
Err(err) => {
log::debug!("Failed to retrieve ADC: {err}. Falling back to gcloud...");
}
}
log::debug!("Retrieving credentials from gcloud CLI...");
match get_gcloud_credentials() {
Ok(token) => return Ok(token),
Err(err) => {
log::debug!("Failed to retrieve gcloud credentials: {err}");
}
}
Err(AuthError::CredentialsUnavailable)
}
async fn get_adc_credentials() -> Result<String, AuthError> {
let provider = gcp_auth::provider()
.await
.map_err(|e| AuthError::Authentication(format!("ADC provider initialization failed: {e}")))?;
let token = provider
.token(&[CLOUD_PLATFORM_SCOPE])
.await
.map_err(|e| AuthError::Authentication(format!("ADC token acquisition failed: {e}")))?;
let token_str = token.as_str().to_string();
validate_token(&token_str)?;
Ok(token_str)
}
fn get_gcloud_credentials() -> Result<String, AuthError> {
let binaries = if cfg!(windows) {
vec!["gcloud.cmd", "gcloud.bat", "gcloud"]
} else {
vec!["gcloud"]
};
let mut last_error = String::new();
for bin in binaries {
log::debug!("Running `{bin} auth print-access-token`...");
match Command::new(bin)
.args(["auth", "print-access-token"])
.output()
{
Ok(output) if output.status.success() => {
let stdout = String::from_utf8(output.stdout).map_err(|e| {
AuthError::Authentication(format!("gcloud returned a non-UTF-8 token: {e}"))
})?;
let token = stdout.trim_end_matches(['\r', '\n']);
validate_token(token)?;
log::debug!("Successfully retrieved credentials from gcloud CLI.");
return Ok(token.to_string());
}
Ok(output) => {
let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
last_error = format!("`{bin}` exited with {}: {stderr}", output.status);
}
Err(e) => {
last_error = format!("Failed to spawn `{bin}`: {e}");
}
}
}
Err(AuthError::Authentication(last_error))
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_explicit_token() {
let token = get_credentials(Some("my-explicit-token")).await.unwrap();
assert_eq!(token, "my-explicit-token");
}
#[tokio::test]
async fn test_explicit_token_rejects_unsafe_characters() {
assert!(
get_credentials(Some(" my-token-with-spaces \n"))
.await
.is_err()
);
}
}