azure.rs 0.0%

0 of 70 lines run, 0 of 16 functions · run #413 on main · run missed

//! Azure Blob Storage: `az://ACCOUNT/CONTAINER/PREFIX`.
//!
//! Credentials: a service principal (`AZURE_CLIENT_ID`,
//! `AZURE_CLIENT_SECRET`, `AZURE_TENANT_ID`, as the Azure SDKs name them,
//! or the `AZURE_STORAGE_*` spellings), an account key
//! (`AZURE_STORAGE_ACCOUNT_KEY`), a SAS token (`AZURE_STORAGE_SAS_TOKEN`),
//! else what `az login` left behind, else the machine's managed
//! identity. `?endpoint=URL` points at an emulator.

use crate::StoreUrl;
use object_store::azure::{MicrosoftAzure, MicrosoftAzureBuilder};
use oxy_core::strata::{Error, Result};

pub const HINT: &str = "run `az login`, or set AZURE_CLIENT_ID, AZURE_CLIENT_SECRET and AZURE_TENANT_ID for a service principal, or AZURE_STORAGE_ACCOUNT_KEY";

fn env(name: &str) -> Option<String> {
    std::env::var(name).ok().filter(|v| !v.is_empty())
}

/// The store and the prefix under the container.
/// With `principal` (tenant, client id, client secret) given, only it
/// is used.
pub fn open(
    url: &StoreUrl,
    principal: Option<(&str, &str, &str)>,
) -> Result<(MicrosoftAzure, String)> {
    let (container, prefix) = match url.path.split_once('/') {
        Some((c, p)) => (c.to_string(), p.to_string()),
        None if !url.path.is_empty() => (url.path.clone(), String::new()),
        None => {
            return Err(Error::Backend(format!(
                "{}: an Azure store URL names the account and the container: az://ACCOUNT/CONTAINER/PREFIX",
                url.plain()
            )))
        }
    };
    if let Some((tenant, id, secret)) = principal {
        let mut b = MicrosoftAzureBuilder::new()
            .with_account(&url.host)
            .with_container_name(&container)
            .with_http_connector(crate::http::UreqConnector)
            .with_client_secret_authorization(id, secret, tenant);
        if let Some(endpoint) = url.param("endpoint") {
            b = b
                .with_endpoint(endpoint.to_string())
                .with_allow_http(endpoint.starts_with("http://"));
        }
        let store = b
            .build()
            .map_err(|e| Error::Backend(format!("{}: {e}", url.plain())))?;
        return Ok((store, prefix));
    }
    let mut b = MicrosoftAzureBuilder::from_env()
        .with_account(&url.host)
        .with_container_name(&container)
        .with_http_connector(crate::http::UreqConnector);
    let principal = (
        env("AZURE_CLIENT_ID").or_else(|| env("AZURE_STORAGE_CLIENT_ID")),
        env("AZURE_CLIENT_SECRET").or_else(|| env("AZURE_STORAGE_CLIENT_SECRET")),
        env("AZURE_TENANT_ID").or_else(|| env("AZURE_STORAGE_TENANT_ID")),
    );
    let mut explicit = false;
    if let (Some(id), Some(secret), Some(tenant)) = principal {
        b = b.with_client_secret_authorization(id, secret, tenant);
        explicit = true;
    }
    if env("AZURE_STORAGE_ACCOUNT_KEY").is_some()
        || env("AZURE_STORAGE_ACCESS_KEY").is_some()
        || env("AZURE_STORAGE_SAS_TOKEN").is_some()
        || env("AZURE_STORAGE_SAS_KEY").is_some()
    {
        explicit = true;
    }
    if let Some(endpoint) = url.param("endpoint") {
        b = b
            .with_endpoint(endpoint.to_string())
            .with_allow_http(endpoint.starts_with("http://"));
    }
    if !explicit {
        // What `az login` left behind; the managed identity comes after.
        b = b.with_use_azure_cli(true);
    }
    let store = b
        .build()
        .map_err(|e| Error::Backend(format!("{}: {e}: {HINT}", url.plain())))?;
    Ok((store, prefix))
}

1		//! Azure Blob Storage: `az://ACCOUNT/CONTAINER/PREFIX`.
2		//!
3		//! Credentials: a service principal (`AZURE_CLIENT_ID`,
4		//! `AZURE_CLIENT_SECRET`, `AZURE_TENANT_ID`, as the Azure SDKs name them,
5		//! or the `AZURE_STORAGE_*` spellings), an account key
6		//! (`AZURE_STORAGE_ACCOUNT_KEY`), a SAS token (`AZURE_STORAGE_SAS_TOKEN`),
7		//! else what `az login` left behind, else the machine's managed
8		//! identity. `?endpoint=URL` points at an emulator.
9
10		use crate::StoreUrl;
11		use object_store::azure::{MicrosoftAzure, MicrosoftAzureBuilder};
12		use oxy_core::strata::{Error, Result};
13
14		pub const HINT: &str = "run `az login`, or set AZURE_CLIENT_ID, AZURE_CLIENT_SECRET and AZURE_TENANT_ID for a service principal, or AZURE_STORAGE_ACCOUNT_KEY";
15
16	0×	fn env(name: &str) -> Option<String> {
17	0×	std::env::var(name).ok().filter(\|v\| !v.is_empty())
18	0×	}
19
20		/// The store and the prefix under the container.
21		/// With `principal` (tenant, client id, client secret) given, only it
22		/// is used.
23	0×	pub fn open(
24	0×	url: &StoreUrl,
25	0×	principal: Option<(&str, &str, &str)>,
26	0×	) -> Result<(MicrosoftAzure, String)> {
27	0×	let (container, prefix) = match url.path.split_once('/') {
28	0×	Some((c, p)) => (c.to_string(), p.to_string()),
29	0×	None if !url.path.is_empty() => (url.path.clone(), String::new()),
30		None => {
31	0×	return Err(Error::Backend(format!(
32	0×	"{}: an Azure store URL names the account and the container: az://ACCOUNT/CONTAINER/PREFIX",
33	0×	url.plain()
34	0×	)))
35		}
36		};
37	0×	if let Some((tenant, id, secret)) = principal {
38	0×	let mut b = MicrosoftAzureBuilder::new()
39	0×	.with_account(&url.host)
40	0×	.with_container_name(&container)
41	0×	.with_http_connector(crate::http::UreqConnector)
42	0×	.with_client_secret_authorization(id, secret, tenant);
43	0×	if let Some(endpoint) = url.param("endpoint") {
44	0×	b = b
45	0×	.with_endpoint(endpoint.to_string())
46	0×	.with_allow_http(endpoint.starts_with("http://"));
47	0×	}
48	0×	let store = b
49	0×	.build()
50	0×	.map_err(\|e\| Error::Backend(format!("{}: {e}", url.plain())))?;
51	0×	return Ok((store, prefix));
52	0×	}
53	0×	let mut b = MicrosoftAzureBuilder::from_env()
54	0×	.with_account(&url.host)
55	0×	.with_container_name(&container)
56	0×	.with_http_connector(crate::http::UreqConnector);
57	0×	let principal = (
58	0×	env("AZURE_CLIENT_ID").or_else(\|\| env("AZURE_STORAGE_CLIENT_ID")),
59	0×	env("AZURE_CLIENT_SECRET").or_else(\|\| env("AZURE_STORAGE_CLIENT_SECRET")),
60	0×	env("AZURE_TENANT_ID").or_else(\|\| env("AZURE_STORAGE_TENANT_ID")),
61		);
62	0×	let mut explicit = false;
63	0×	if let (Some(id), Some(secret), Some(tenant)) = principal {
64	0×	b = b.with_client_secret_authorization(id, secret, tenant);
65	0×	explicit = true;
66	0×	}
67	0×	if env("AZURE_STORAGE_ACCOUNT_KEY").is_some()
68	0×	\|\| env("AZURE_STORAGE_ACCESS_KEY").is_some()
69	0×	\|\| env("AZURE_STORAGE_SAS_TOKEN").is_some()
70	0×	\|\| env("AZURE_STORAGE_SAS_KEY").is_some()
71	0×	{
72	0×	explicit = true;
73	0×	}
74	0×	if let Some(endpoint) = url.param("endpoint") {
75	0×	b = b
76	0×	.with_endpoint(endpoint.to_string())
77	0×	.with_allow_http(endpoint.starts_with("http://"));
78	0×	}
79	0×	if !explicit {
80	0×	// What `az login` left behind; the managed identity comes after.
81	0×	b = b.with_use_azure_cli(true);
82	0×	}
83	0×	let store = b
84	0×	.build()
85	0×	.map_err(\|e\| Error::Backend(format!("{}: {e}: {HINT}", url.plain())))?;
86	0×	Ok((store, prefix))
87	0×	}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/oxy-strata/src/azure.rs 0.0%

Keyboard