Skip to content

Commit ee4e1f8

Browse files
AJIOBAJIOB
committed
Ignore empty-set environment values
1 parent bdbab18 commit ee4e1f8

1 file changed

Lines changed: 77 additions & 54 deletions

File tree

‎src/config.rs‎

Lines changed: 77 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -828,9 +828,12 @@ pub struct EnvConfig {
828828
basedirs: Option<Vec<String>>,
829829
}
830830

831+
fn string_from_env_var(env_var_name: &str) -> Option<String> {
832+
env::var(env_var_name).ok().filter(|s| !s.is_empty())
833+
}
834+
831835
fn key_prefix_from_env_var(env_var_name: &str) -> String {
832-
env::var(env_var_name)
833-
.ok()
836+
string_from_env_var(env_var_name)
834837
.as_ref()
835838
.map(|s| s.trim_end_matches('/'))
836839
.filter(|s| !s.is_empty())
@@ -839,23 +842,21 @@ fn key_prefix_from_env_var(env_var_name: &str) -> String {
839842
}
840843

841844
fn cache_mode_from_env_var(env_var_name: &str) -> Option<CacheModeConfig> {
842-
env::var(env_var_name)
843-
.ok()
844-
.and_then(|value| match value.to_uppercase().as_str() {
845-
"READ_ONLY" => Some(CacheModeConfig::ReadOnly),
846-
"READ_WRITE" => Some(CacheModeConfig::ReadWrite),
847-
_ => {
848-
warn!("{} must be 'READ_ONLY' or 'READ_WRITE'", env_var_name);
849-
None
850-
}
851-
})
845+
string_from_env_var(env_var_name).and_then(|value| match value.to_uppercase().as_str() {
846+
"READ_ONLY" => Some(CacheModeConfig::ReadOnly),
847+
"READ_WRITE" => Some(CacheModeConfig::ReadWrite),
848+
_ => {
849+
warn!("{} must be 'READ_ONLY' or 'READ_WRITE'", env_var_name);
850+
None
851+
}
852+
})
852853
}
853854

854855
fn number_from_env_var<A: std::str::FromStr>(env_var_name: &str) -> Option<Result<A>>
855856
where
856857
<A as FromStr>::Err: std::fmt::Debug,
857858
{
858-
let value = env::var(env_var_name).ok()?;
859+
let value = string_from_env_var(env_var_name)?;
859860

860861
value
861862
.parse::<A>()
@@ -864,8 +865,7 @@ where
864865
}
865866

866867
fn bool_from_env_var(env_var_name: &str) -> Result<Option<bool>> {
867-
env::var(env_var_name)
868-
.ok()
868+
string_from_env_var(env_var_name)
869869
.map(|value| match value.to_lowercase().as_str() {
870870
"true" | "on" | "1" => Ok(true),
871871
"false" | "off" | "0" => Ok(false),
@@ -879,12 +879,12 @@ fn bool_from_env_var(env_var_name: &str) -> Result<Option<bool>> {
879879

880880
fn config_from_env() -> Result<EnvConfig> {
881881
// ======= AWS =======
882-
let s3 = if let Ok(bucket) = env::var("SCCACHE_BUCKET") {
883-
let region = env::var("SCCACHE_REGION").ok();
882+
let s3 = if let Some(bucket) = string_from_env_var("SCCACHE_BUCKET") {
883+
let region = string_from_env_var("SCCACHE_REGION");
884884
let no_credentials = bool_from_env_var("SCCACHE_S3_NO_CREDENTIALS")?.unwrap_or(false);
885885
let use_ssl = bool_from_env_var("SCCACHE_S3_USE_SSL")?;
886886
let server_side_encryption = bool_from_env_var("SCCACHE_S3_SERVER_SIDE_ENCRYPTION")?;
887-
let endpoint = env::var("SCCACHE_ENDPOINT").ok();
887+
let endpoint = string_from_env_var("SCCACHE_ENDPOINT");
888888
let key_prefix = key_prefix_from_env_var("SCCACHE_S3_KEY_PREFIX");
889889
let enable_virtual_host_style = bool_from_env_var("SCCACHE_S3_ENABLE_VIRTUAL_HOST_STYLE")?;
890890
let rw_mode =
@@ -914,18 +914,18 @@ fn config_from_env() -> Result<EnvConfig> {
914914

915915
// ======= redis =======
916916
let redis = match (
917-
env::var("SCCACHE_REDIS").ok(),
918-
env::var("SCCACHE_REDIS_ENDPOINT").ok(),
919-
env::var("SCCACHE_REDIS_CLUSTER_ENDPOINTS").ok(),
917+
string_from_env_var("SCCACHE_REDIS"),
918+
string_from_env_var("SCCACHE_REDIS_ENDPOINT"),
919+
string_from_env_var("SCCACHE_REDIS_CLUSTER_ENDPOINTS"),
920920
) {
921921
(None, None, None) => None,
922922
(url, endpoint, cluster_endpoints) => {
923923
let db = number_from_env_var("SCCACHE_REDIS_DB")
924924
.transpose()?
925925
.unwrap_or(DEFAULT_REDIS_DB);
926926

927-
let username = env::var("SCCACHE_REDIS_USERNAME").ok();
928-
let password = env::var("SCCACHE_REDIS_PASSWORD").ok();
927+
let username = string_from_env_var("SCCACHE_REDIS_USERNAME");
928+
let password = string_from_env_var("SCCACHE_REDIS_PASSWORD");
929929

930930
let ttl = number_from_env_var("SCCACHE_REDIS_EXPIRATION")
931931
.or_else(|| number_from_env_var("SCCACHE_REDIS_TTL"))
@@ -958,11 +958,11 @@ fn config_from_env() -> Result<EnvConfig> {
958958
}
959959

960960
// ======= memcached =======
961-
let memcached = if let Ok(url) =
962-
env::var("SCCACHE_MEMCACHED").or_else(|_| env::var("SCCACHE_MEMCACHED_ENDPOINT"))
961+
let memcached = if let Some(url) = string_from_env_var("SCCACHE_MEMCACHED")
962+
.or_else(|| string_from_env_var("SCCACHE_MEMCACHED_ENDPOINT"))
963963
{
964-
let username = env::var("SCCACHE_MEMCACHED_USERNAME").ok();
965-
let password = env::var("SCCACHE_MEMCACHED_PASSWORD").ok();
964+
let username = string_from_env_var("SCCACHE_MEMCACHED_USERNAME");
965+
let password = string_from_env_var("SCCACHE_MEMCACHED_PASSWORD");
966966

967967
let expiration = number_from_env_var("SCCACHE_MEMCACHED_EXPIRATION")
968968
.transpose()?
@@ -994,28 +994,28 @@ fn config_from_env() -> Result<EnvConfig> {
994994
}
995995

996996
// ======= GCP/GCS =======
997-
if (env::var("SCCACHE_GCS_CREDENTIALS_URL").is_ok()
998-
|| env::var("SCCACHE_GCS_OAUTH_URL").is_ok()
999-
|| env::var("SCCACHE_GCS_KEY_PATH").is_ok())
1000-
&& env::var("SCCACHE_GCS_BUCKET").is_err()
997+
if (string_from_env_var("SCCACHE_GCS_CREDENTIALS_URL").is_some()
998+
|| string_from_env_var("SCCACHE_GCS_OAUTH_URL").is_some()
999+
|| string_from_env_var("SCCACHE_GCS_KEY_PATH").is_some())
1000+
&& string_from_env_var("SCCACHE_GCS_BUCKET").is_none()
10011001
{
10021002
bail!(
10031003
"If setting GCS credentials, SCCACHE_GCS_BUCKET and an auth mechanism need to be set."
10041004
);
10051005
}
10061006

1007-
let gcs = env::var("SCCACHE_GCS_BUCKET").ok().map(|bucket| {
1007+
let gcs = string_from_env_var("SCCACHE_GCS_BUCKET").map(|bucket| {
10081008
let key_prefix = key_prefix_from_env_var("SCCACHE_GCS_KEY_PREFIX");
10091009

1010-
if env::var("SCCACHE_GCS_OAUTH_URL").is_ok() {
1010+
if string_from_env_var("SCCACHE_GCS_OAUTH_URL").is_some() {
10111011
eprintln!("SCCACHE_GCS_OAUTH_URL has been deprecated");
10121012
eprintln!("if you intend to use vm metadata for auth, please set correct service account instead");
10131013
}
10141014

1015-
let credential_url = env::var("SCCACHE_GCS_CREDENTIALS_URL").ok();
1015+
let credential_url = string_from_env_var("SCCACHE_GCS_CREDENTIALS_URL");
10161016

1017-
let cred_path = env::var("SCCACHE_GCS_KEY_PATH").ok();
1018-
let service_account = env::var("SCCACHE_GCS_SERVICE_ACCOUNT").ok();
1017+
let cred_path = string_from_env_var("SCCACHE_GCS_KEY_PATH");
1018+
let service_account = string_from_env_var("SCCACHE_GCS_SERVICE_ACCOUNT");
10191019

10201020
let rw_mode = cache_mode_from_env_var("SCCACHE_GCS_RW_MODE").unwrap_or_else(|| {
10211021
warn!("No valid SCCACHE_GCS_RW_MODE value was found -- defaulting to READ_ONLY.");
@@ -1035,7 +1035,7 @@ fn config_from_env() -> Result<EnvConfig> {
10351035
// ======= GHA =======
10361036
let gha_rw_mode: CacheModeConfig =
10371037
cache_mode_from_env_var("SCCACHE_GHA_RW_MODE").unwrap_or(CacheModeConfig::ReadWrite);
1038-
let gha = if let Ok(version) = env::var("SCCACHE_GHA_VERSION") {
1038+
let gha = if let Some(version) = string_from_env_var("SCCACHE_GHA_VERSION") {
10391039
// If SCCACHE_GHA_VERSION has been set, we don't need to check
10401040
// SCCACHE_GHA_ENABLED's value anymore.
10411041
Some(GHACacheConfig {
@@ -1056,9 +1056,9 @@ fn config_from_env() -> Result<EnvConfig> {
10561056
};
10571057

10581058
// ======= Azure =======
1059-
let azure = if let (Ok(connection_string), Ok(container)) = (
1060-
env::var("SCCACHE_AZURE_CONNECTION_STRING"),
1061-
env::var("SCCACHE_AZURE_BLOB_CONTAINER"),
1059+
let azure = if let (Some(connection_string), Some(container)) = (
1060+
string_from_env_var("SCCACHE_AZURE_CONNECTION_STRING"),
1061+
string_from_env_var("SCCACHE_AZURE_BLOB_CONTAINER"),
10621062
) {
10631063
let key_prefix = key_prefix_from_env_var("SCCACHE_AZURE_KEY_PREFIX");
10641064
let rw_mode =
@@ -1075,11 +1075,11 @@ fn config_from_env() -> Result<EnvConfig> {
10751075
};
10761076

10771077
// ======= WebDAV =======
1078-
let webdav = if let Ok(endpoint) = env::var("SCCACHE_WEBDAV_ENDPOINT") {
1078+
let webdav = if let Some(endpoint) = string_from_env_var("SCCACHE_WEBDAV_ENDPOINT") {
10791079
let key_prefix = key_prefix_from_env_var("SCCACHE_WEBDAV_KEY_PREFIX");
1080-
let username = env::var("SCCACHE_WEBDAV_USERNAME").ok();
1081-
let password = env::var("SCCACHE_WEBDAV_PASSWORD").ok();
1082-
let token = env::var("SCCACHE_WEBDAV_TOKEN").ok();
1080+
let username = string_from_env_var("SCCACHE_WEBDAV_USERNAME");
1081+
let password = string_from_env_var("SCCACHE_WEBDAV_PASSWORD");
1082+
let token = string_from_env_var("SCCACHE_WEBDAV_TOKEN");
10831083
let rw_mode =
10841084
cache_mode_from_env_var("SCCACHE_WEBDAV_RW_MODE").unwrap_or(CacheModeConfig::ReadWrite);
10851085

@@ -1096,8 +1096,8 @@ fn config_from_env() -> Result<EnvConfig> {
10961096
};
10971097

10981098
// ======= OSS =======
1099-
let oss = if let Ok(bucket) = env::var("SCCACHE_OSS_BUCKET") {
1100-
let endpoint = env::var("SCCACHE_OSS_ENDPOINT").ok();
1099+
let oss = if let Some(bucket) = string_from_env_var("SCCACHE_OSS_BUCKET") {
1100+
let endpoint = string_from_env_var("SCCACHE_OSS_ENDPOINT");
11011101
let key_prefix = key_prefix_from_env_var("SCCACHE_OSS_KEY_PREFIX");
11021102

11031103
let no_credentials = bool_from_env_var("SCCACHE_OSS_NO_CREDENTIALS")?.unwrap_or(false);
@@ -1127,8 +1127,8 @@ fn config_from_env() -> Result<EnvConfig> {
11271127
}
11281128

11291129
// ======= COS =======
1130-
let cos = if let Ok(bucket) = env::var("SCCACHE_COS_BUCKET") {
1131-
let endpoint = env::var("SCCACHE_COS_ENDPOINT").ok();
1130+
let cos = if let Some(bucket) = string_from_env_var("SCCACHE_COS_BUCKET") {
1131+
let endpoint = string_from_env_var("SCCACHE_COS_ENDPOINT");
11321132
let key_prefix = key_prefix_from_env_var("SCCACHE_COS_KEY_PREFIX");
11331133

11341134
let rw_mode =
@@ -1146,9 +1146,7 @@ fn config_from_env() -> Result<EnvConfig> {
11461146

11471147
// ======= Local =======
11481148
let disk_dir = env::var_os("SCCACHE_DIR").map(PathBuf::from);
1149-
let disk_sz = env::var("SCCACHE_CACHE_SIZE")
1150-
.ok()
1151-
.and_then(|v| parse_size(&v));
1149+
let disk_sz = string_from_env_var("SCCACHE_CACHE_SIZE").and_then(|v| parse_size(&v));
11521150

11531151
let mut preprocessor_mode_config = PreprocessorCacheModeConfig::activated();
11541152
let preprocessor_mode_overridden = if let Some(value) = bool_from_env_var("SCCACHE_DIRECT")? {
@@ -1180,11 +1178,10 @@ fn config_from_env() -> Result<EnvConfig> {
11801178
};
11811179

11821180
// Parse multi-level cache configuration
1183-
let multilevel = if let Ok(chain_str) = env::var("SCCACHE_MULTILEVEL_CHAIN") {
1181+
let multilevel = if let Some(chain_str) = string_from_env_var("SCCACHE_MULTILEVEL_CHAIN") {
11841182
let chain: Vec<String> = chain_str.split(',').map(|s| s.trim().to_string()).collect();
11851183

1186-
let write_error_policy = env::var("SCCACHE_MULTILEVEL_WRITE_ERROR_POLICY")
1187-
.ok()
1184+
let write_error_policy = string_from_env_var("SCCACHE_MULTILEVEL_WRITE_ERROR_POLICY")
11881185
.and_then(|s| s.parse::<WriteErrorPolicy>().ok())
11891186
.unwrap_or_default();
11901187

@@ -1600,6 +1597,32 @@ fn test_parse_size() {
16001597
assert_eq!(Some(1024 * TEN_GIGS), parse_size("10T"));
16011598
}
16021599

1600+
#[test]
1601+
fn test_string_from_env_var() {
1602+
let var_name = "TEST_SCCACHE_VAR";
1603+
for value in [None, Some(""), Some("foo")] {
1604+
match value {
1605+
None => unsafe {
1606+
std::env::remove_var(var_name);
1607+
},
1608+
Some(value) => unsafe {
1609+
std::env::set_var(var_name, value);
1610+
},
1611+
}
1612+
let result = string_from_env_var(var_name);
1613+
unsafe {
1614+
std::env::remove_var(var_name);
1615+
}
1616+
1617+
let expected = match value {
1618+
None | Some("") => None,
1619+
Some(value) => Some(value.to_string()),
1620+
};
1621+
1622+
assert_eq!(result, expected);
1623+
}
1624+
}
1625+
16031626
#[test]
16041627
fn config_overrides() {
16051628
let env_conf = EnvConfig {

0 commit comments

Comments
 (0)