Skip to content

Commit 1d36170

Browse files
AJIOBAJIOB
committed
Ignore empty-set environment values
1 parent 2b65ac8 commit 1d36170

1 file changed

Lines changed: 81 additions & 57 deletions

File tree

‎src/config.rs‎

Lines changed: 81 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -695,9 +695,12 @@ pub struct EnvConfig {
695695
basedirs: Option<Vec<String>>,
696696
}
697697

698+
fn string_from_env_var(env_var_name: &str) -> Option<String> {
699+
env::var(env_var_name).ok().filter(|s| !s.is_empty())
700+
}
701+
698702
fn key_prefix_from_env_var(env_var_name: &str) -> String {
699-
env::var(env_var_name)
700-
.ok()
703+
string_from_env_var(env_var_name)
701704
.as_ref()
702705
.map(|s| s.trim_end_matches('/'))
703706
.filter(|s| !s.is_empty())
@@ -709,7 +712,7 @@ fn number_from_env_var<A: std::str::FromStr>(env_var_name: &str) -> Option<Resul
709712
where
710713
<A as FromStr>::Err: std::fmt::Debug,
711714
{
712-
let value = env::var(env_var_name).ok()?;
715+
let value = string_from_env_var(env_var_name)?;
713716

714717
value
715718
.parse::<A>()
@@ -718,8 +721,7 @@ where
718721
}
719722

720723
fn bool_from_env_var(env_var_name: &str) -> Result<Option<bool>> {
721-
env::var(env_var_name)
722-
.ok()
724+
string_from_env_var(env_var_name)
723725
.map(|value| match value.to_lowercase().as_str() {
724726
"true" | "on" | "1" => Ok(true),
725727
"false" | "off" | "0" => Ok(false),
@@ -733,12 +735,12 @@ fn bool_from_env_var(env_var_name: &str) -> Result<Option<bool>> {
733735

734736
fn config_from_env() -> Result<EnvConfig> {
735737
// ======= AWS =======
736-
let s3 = if let Ok(bucket) = env::var("SCCACHE_BUCKET") {
737-
let region = env::var("SCCACHE_REGION").ok();
738+
let s3 = if let Some(bucket) = string_from_env_var("SCCACHE_BUCKET") {
739+
let region = string_from_env_var("SCCACHE_REGION");
738740
let no_credentials = bool_from_env_var("SCCACHE_S3_NO_CREDENTIALS")?.unwrap_or(false);
739741
let use_ssl = bool_from_env_var("SCCACHE_S3_USE_SSL")?;
740742
let server_side_encryption = bool_from_env_var("SCCACHE_S3_SERVER_SIDE_ENCRYPTION")?;
741-
let endpoint = env::var("SCCACHE_ENDPOINT").ok();
743+
let endpoint = string_from_env_var("SCCACHE_ENDPOINT");
742744
let key_prefix = key_prefix_from_env_var("SCCACHE_S3_KEY_PREFIX");
743745
let enable_virtual_host_style = bool_from_env_var("SCCACHE_S3_ENABLE_VIRTUAL_HOST_STYLE")?;
744746

@@ -765,18 +767,18 @@ fn config_from_env() -> Result<EnvConfig> {
765767

766768
// ======= redis =======
767769
let redis = match (
768-
env::var("SCCACHE_REDIS").ok(),
769-
env::var("SCCACHE_REDIS_ENDPOINT").ok(),
770-
env::var("SCCACHE_REDIS_CLUSTER_ENDPOINTS").ok(),
770+
string_from_env_var("SCCACHE_REDIS"),
771+
string_from_env_var("SCCACHE_REDIS_ENDPOINT"),
772+
string_from_env_var("SCCACHE_REDIS_CLUSTER_ENDPOINTS"),
771773
) {
772774
(None, None, None) => None,
773775
(url, endpoint, cluster_endpoints) => {
774776
let db = number_from_env_var("SCCACHE_REDIS_DB")
775777
.transpose()?
776778
.unwrap_or(DEFAULT_REDIS_DB);
777779

778-
let username = env::var("SCCACHE_REDIS_USERNAME").ok();
779-
let password = env::var("SCCACHE_REDIS_PASSWORD").ok();
780+
let username = string_from_env_var("SCCACHE_REDIS_USERNAME");
781+
let password = string_from_env_var("SCCACHE_REDIS_PASSWORD");
780782

781783
let ttl = number_from_env_var("SCCACHE_REDIS_EXPIRATION")
782784
.or_else(|| number_from_env_var("SCCACHE_REDIS_TTL"))
@@ -805,11 +807,11 @@ fn config_from_env() -> Result<EnvConfig> {
805807
}
806808

807809
// ======= memcached =======
808-
let memcached = if let Ok(url) =
809-
env::var("SCCACHE_MEMCACHED").or_else(|_| env::var("SCCACHE_MEMCACHED_ENDPOINT"))
810+
let memcached = if let Some(url) = string_from_env_var("SCCACHE_MEMCACHED")
811+
.or_else(|| string_from_env_var("SCCACHE_MEMCACHED_ENDPOINT"))
810812
{
811-
let username = env::var("SCCACHE_MEMCACHED_USERNAME").ok();
812-
let password = env::var("SCCACHE_MEMCACHED_PASSWORD").ok();
813+
let username = string_from_env_var("SCCACHE_MEMCACHED_USERNAME");
814+
let password = string_from_env_var("SCCACHE_MEMCACHED_PASSWORD");
813815

814816
let expiration = number_from_env_var("SCCACHE_MEMCACHED_EXPIRATION")
815817
.transpose()?
@@ -837,35 +839,35 @@ fn config_from_env() -> Result<EnvConfig> {
837839
}
838840

839841
// ======= GCP/GCS =======
840-
if (env::var("SCCACHE_GCS_CREDENTIALS_URL").is_ok()
841-
|| env::var("SCCACHE_GCS_OAUTH_URL").is_ok()
842-
|| env::var("SCCACHE_GCS_KEY_PATH").is_ok())
843-
&& env::var("SCCACHE_GCS_BUCKET").is_err()
842+
if (string_from_env_var("SCCACHE_GCS_CREDENTIALS_URL").is_some()
843+
|| string_from_env_var("SCCACHE_GCS_OAUTH_URL").is_some()
844+
|| string_from_env_var("SCCACHE_GCS_KEY_PATH").is_some())
845+
&& string_from_env_var("SCCACHE_GCS_BUCKET").is_none()
844846
{
845847
bail!(
846848
"If setting GCS credentials, SCCACHE_GCS_BUCKET and an auth mechanism need to be set."
847849
);
848850
}
849851

850-
let gcs = env::var("SCCACHE_GCS_BUCKET").ok().map(|bucket| {
852+
let gcs = string_from_env_var("SCCACHE_GCS_BUCKET").map(|bucket| {
851853
let key_prefix = key_prefix_from_env_var("SCCACHE_GCS_KEY_PREFIX");
852854

853-
if env::var("SCCACHE_GCS_OAUTH_URL").is_ok() {
855+
if string_from_env_var("SCCACHE_GCS_OAUTH_URL").is_some() {
854856
eprintln!("SCCACHE_GCS_OAUTH_URL has been deprecated");
855857
eprintln!("if you intend to use vm metadata for auth, please set correct service account instead");
856858
}
857859

858-
let credential_url = env::var("SCCACHE_GCS_CREDENTIALS_URL").ok();
860+
let credential_url = string_from_env_var("SCCACHE_GCS_CREDENTIALS_URL");
859861

860-
let cred_path = env::var("SCCACHE_GCS_KEY_PATH").ok();
861-
let service_account = env::var("SCCACHE_GCS_SERVICE_ACCOUNT").ok();
862+
let cred_path = string_from_env_var("SCCACHE_GCS_KEY_PATH");
863+
let service_account = string_from_env_var("SCCACHE_GCS_SERVICE_ACCOUNT");
862864

863-
let rw_mode = match env::var("SCCACHE_GCS_RW_MODE").as_ref().map(String::as_str) {
864-
Ok("READ_ONLY") => CacheModeConfig::ReadOnly,
865-
Ok("READ_WRITE") => CacheModeConfig::ReadWrite,
865+
let rw_mode = match string_from_env_var("SCCACHE_GCS_RW_MODE").as_deref() {
866+
Some("READ_ONLY") => CacheModeConfig::ReadOnly,
867+
Some("READ_WRITE") => CacheModeConfig::ReadWrite,
866868
// TODO: unsure if these should warn during the configuration loading
867869
// or at the time when they're actually used to connect to GCS
868-
Ok(_) => {
870+
Some(_) => {
869871
warn!("Invalid SCCACHE_GCS_RW_MODE -- defaulting to READ_ONLY.");
870872
CacheModeConfig::ReadOnly
871873
}
@@ -886,7 +888,7 @@ fn config_from_env() -> Result<EnvConfig> {
886888
});
887889

888890
// ======= GHA =======
889-
let gha = if let Ok(version) = env::var("SCCACHE_GHA_VERSION") {
891+
let gha = if let Some(version) = string_from_env_var("SCCACHE_GHA_VERSION") {
890892
// If SCCACHE_GHA_VERSION has been set, we don't need to check
891893
// SCCACHE_GHA_ENABLED's value anymore.
892894
Some(GHACacheConfig {
@@ -905,9 +907,9 @@ fn config_from_env() -> Result<EnvConfig> {
905907
};
906908

907909
// ======= Azure =======
908-
let azure = if let (Ok(connection_string), Ok(container)) = (
909-
env::var("SCCACHE_AZURE_CONNECTION_STRING"),
910-
env::var("SCCACHE_AZURE_BLOB_CONTAINER"),
910+
let azure = if let (Some(connection_string), Some(container)) = (
911+
string_from_env_var("SCCACHE_AZURE_CONNECTION_STRING"),
912+
string_from_env_var("SCCACHE_AZURE_BLOB_CONTAINER"),
911913
) {
912914
let key_prefix = key_prefix_from_env_var("SCCACHE_AZURE_KEY_PREFIX");
913915
Some(AzureCacheConfig {
@@ -920,11 +922,11 @@ fn config_from_env() -> Result<EnvConfig> {
920922
};
921923

922924
// ======= WebDAV =======
923-
let webdav = if let Ok(endpoint) = env::var("SCCACHE_WEBDAV_ENDPOINT") {
925+
let webdav = if let Some(endpoint) = string_from_env_var("SCCACHE_WEBDAV_ENDPOINT") {
924926
let key_prefix = key_prefix_from_env_var("SCCACHE_WEBDAV_KEY_PREFIX");
925-
let username = env::var("SCCACHE_WEBDAV_USERNAME").ok();
926-
let password = env::var("SCCACHE_WEBDAV_PASSWORD").ok();
927-
let token = env::var("SCCACHE_WEBDAV_TOKEN").ok();
927+
let username = string_from_env_var("SCCACHE_WEBDAV_USERNAME");
928+
let password = string_from_env_var("SCCACHE_WEBDAV_PASSWORD");
929+
let token = string_from_env_var("SCCACHE_WEBDAV_TOKEN");
928930

929931
Some(WebdavCacheConfig {
930932
endpoint,
@@ -938,8 +940,8 @@ fn config_from_env() -> Result<EnvConfig> {
938940
};
939941

940942
// ======= OSS =======
941-
let oss = if let Ok(bucket) = env::var("SCCACHE_OSS_BUCKET") {
942-
let endpoint = env::var("SCCACHE_OSS_ENDPOINT").ok();
943+
let oss = if let Some(bucket) = string_from_env_var("SCCACHE_OSS_BUCKET") {
944+
let endpoint = string_from_env_var("SCCACHE_OSS_ENDPOINT");
943945
let key_prefix = key_prefix_from_env_var("SCCACHE_OSS_KEY_PREFIX");
944946

945947
let no_credentials = bool_from_env_var("SCCACHE_OSS_NO_CREDENTIALS")?.unwrap_or(false);
@@ -965,8 +967,8 @@ fn config_from_env() -> Result<EnvConfig> {
965967
}
966968

967969
// ======= COS =======
968-
let cos = if let Ok(bucket) = env::var("SCCACHE_COS_BUCKET") {
969-
let endpoint = env::var("SCCACHE_COS_ENDPOINT").ok();
970+
let cos = if let Some(bucket) = string_from_env_var("SCCACHE_COS_BUCKET") {
971+
let endpoint = string_from_env_var("SCCACHE_COS_ENDPOINT");
970972
let key_prefix = key_prefix_from_env_var("SCCACHE_COS_KEY_PREFIX");
971973

972974
Some(COSCacheConfig {
@@ -980,9 +982,7 @@ fn config_from_env() -> Result<EnvConfig> {
980982

981983
// ======= Local =======
982984
let disk_dir = env::var_os("SCCACHE_DIR").map(PathBuf::from);
983-
let disk_sz = env::var("SCCACHE_CACHE_SIZE")
984-
.ok()
985-
.and_then(|v| parse_size(&v));
985+
let disk_sz = string_from_env_var("SCCACHE_CACHE_SIZE").and_then(|v| parse_size(&v));
986986

987987
let mut preprocessor_mode_config = PreprocessorCacheModeConfig::activated();
988988
let preprocessor_mode_overridden = if let Some(value) = bool_from_env_var("SCCACHE_DIRECT")? {
@@ -992,18 +992,16 @@ fn config_from_env() -> Result<EnvConfig> {
992992
false
993993
};
994994

995-
let (disk_rw_mode, disk_rw_mode_overridden) = match env::var("SCCACHE_LOCAL_RW_MODE")
996-
.as_ref()
997-
.map(String::as_str)
998-
{
999-
Ok("READ_ONLY") => (CacheModeConfig::ReadOnly, true),
1000-
Ok("READ_WRITE") => (CacheModeConfig::ReadWrite, true),
1001-
Ok(_) => {
1002-
warn!("Invalid SCCACHE_LOCAL_RW_MODE -- defaulting to READ_WRITE.");
1003-
(CacheModeConfig::ReadWrite, false)
1004-
}
1005-
_ => (CacheModeConfig::ReadWrite, false),
1006-
};
995+
let (disk_rw_mode, disk_rw_mode_overridden) =
996+
match string_from_env_var("SCCACHE_LOCAL_RW_MODE").as_deref() {
997+
Some("READ_ONLY") => (CacheModeConfig::ReadOnly, true),
998+
Some("READ_WRITE") => (CacheModeConfig::ReadWrite, true),
999+
Some(_) => {
1000+
warn!("Invalid SCCACHE_LOCAL_RW_MODE -- defaulting to READ_WRITE.");
1001+
(CacheModeConfig::ReadWrite, false)
1002+
}
1003+
_ => (CacheModeConfig::ReadWrite, false),
1004+
};
10071005

10081006
let any_overridden = disk_dir.is_some()
10091007
|| disk_sz.is_some()
@@ -1421,6 +1419,32 @@ fn test_parse_size() {
14211419
assert_eq!(Some(1024 * TEN_GIGS), parse_size("10T"));
14221420
}
14231421

1422+
#[test]
1423+
fn test_string_from_env_var() {
1424+
let var_name = "TEST_SCCACHE_VAR";
1425+
for value in [None, Some(""), Some("foo")] {
1426+
match value {
1427+
None => unsafe {
1428+
std::env::remove_var(var_name);
1429+
},
1430+
Some(value) => unsafe {
1431+
std::env::set_var(var_name, value);
1432+
},
1433+
}
1434+
let result = string_from_env_var(var_name);
1435+
unsafe {
1436+
std::env::remove_var(var_name);
1437+
}
1438+
1439+
let expected = match value {
1440+
None | Some("") => None,
1441+
Some(value) => Some(value.to_string()),
1442+
};
1443+
1444+
assert_eq!(result, expected);
1445+
}
1446+
}
1447+
14241448
#[test]
14251449
fn config_overrides() {
14261450
let env_conf = EnvConfig {

0 commit comments

Comments
 (0)