in src/config.rs [635:921]
fn config_from_env() -> Result<EnvConfig> {
// ======= AWS =======
let s3 = if let Ok(bucket) = env::var("SCCACHE_BUCKET") {
let region = env::var("SCCACHE_REGION").ok();
let no_credentials = bool_from_env_var("SCCACHE_S3_NO_CREDENTIALS")?.unwrap_or(false);
let use_ssl = bool_from_env_var("SCCACHE_S3_USE_SSL")?;
let server_side_encryption = bool_from_env_var("SCCACHE_S3_SERVER_SIDE_ENCRYPTION")?;
let endpoint = env::var("SCCACHE_ENDPOINT").ok();
let key_prefix = key_prefix_from_env_var("SCCACHE_S3_KEY_PREFIX");
let enable_virtual_host_style = bool_from_env_var("SCCACHE_S3_ENABLE_VIRTUAL_HOST_STYLE")?;
Some(S3CacheConfig {
bucket,
region,
no_credentials,
key_prefix,
endpoint,
use_ssl,
server_side_encryption,
enable_virtual_host_style,
})
} else {
None
};
if s3.as_ref().map(|s3| s3.no_credentials).unwrap_or_default()
&& (env::var_os("AWS_ACCESS_KEY_ID").is_some()
|| env::var_os("AWS_SECRET_ACCESS_KEY").is_some())
{
bail!("If setting S3 credentials, SCCACHE_S3_NO_CREDENTIALS must not be set.");
}
// ======= redis =======
let redis = match (
env::var("SCCACHE_REDIS").ok(),
env::var("SCCACHE_REDIS_ENDPOINT").ok(),
env::var("SCCACHE_REDIS_CLUSTER_ENDPOINTS").ok(),
) {
(None, None, None) => None,
(url, endpoint, cluster_endpoints) => {
let db = number_from_env_var("SCCACHE_REDIS_DB")
.transpose()?
.unwrap_or(DEFAULT_REDIS_DB);
let username = env::var("SCCACHE_REDIS_USERNAME").ok();
let password = env::var("SCCACHE_REDIS_PASSWORD").ok();
let ttl = number_from_env_var("SCCACHE_REDIS_EXPIRATION")
.or_else(|| number_from_env_var("SCCACHE_REDIS_TTL"))
.transpose()?
.unwrap_or(DEFAULT_REDIS_CACHE_TTL);
let key_prefix = key_prefix_from_env_var("SCCACHE_REDIS_KEY_PREFIX");
Some(RedisCacheConfig {
url,
endpoint,
cluster_endpoints,
username,
password,
db,
ttl,
key_prefix,
})
}
};
if env::var_os("SCCACHE_REDIS_EXPIRATION").is_some()
&& env::var_os("SCCACHE_REDIS_TTL").is_some()
{
bail!("You mustn't set both SCCACHE_REDIS_EXPIRATION and SCCACHE_REDIS_TTL. Use only one.");
}
// ======= memcached =======
let memcached = if let Ok(url) =
env::var("SCCACHE_MEMCACHED").or_else(|_| env::var("SCCACHE_MEMCACHED_ENDPOINT"))
{
let username = env::var("SCCACHE_MEMCACHED_USERNAME").ok();
let password = env::var("SCCACHE_MEMCACHED_PASSWORD").ok();
let expiration = number_from_env_var("SCCACHE_MEMCACHED_EXPIRATION")
.transpose()?
.unwrap_or(DEFAULT_MEMCACHED_CACHE_EXPIRATION);
let key_prefix = key_prefix_from_env_var("SCCACHE_MEMCACHED_KEY_PREFIX");
Some(MemcachedCacheConfig {
url,
username,
password,
expiration,
key_prefix,
})
} else {
None
};
if env::var_os("SCCACHE_MEMCACHED").is_some()
&& env::var_os("SCCACHE_MEMCACHED_ENDPOINT").is_some()
{
bail!("You mustn't set both SCCACHE_MEMCACHED and SCCACHE_MEMCACHED_ENDPOINT. Please, use only SCCACHE_MEMCACHED_ENDPOINT.");
}
// ======= GCP/GCS =======
if (env::var("SCCACHE_GCS_CREDENTIALS_URL").is_ok()
|| env::var("SCCACHE_GCS_OAUTH_URL").is_ok()
|| env::var("SCCACHE_GCS_KEY_PATH").is_ok())
&& env::var("SCCACHE_GCS_BUCKET").is_err()
{
bail!(
"If setting GCS credentials, SCCACHE_GCS_BUCKET and an auth mechanism need to be set."
);
}
let gcs = env::var("SCCACHE_GCS_BUCKET").ok().map(|bucket| {
let key_prefix = key_prefix_from_env_var("SCCACHE_GCS_KEY_PREFIX");
if env::var("SCCACHE_GCS_OAUTH_URL").is_ok() {
eprintln!("SCCACHE_GCS_OAUTH_URL has been deprecated");
eprintln!("if you intend to use vm metadata for auth, please set correct service account instead");
}
let credential_url = env::var("SCCACHE_GCS_CREDENTIALS_URL").ok();
let cred_path = env::var("SCCACHE_GCS_KEY_PATH").ok();
let service_account = env::var("SCCACHE_GCS_SERVICE_ACCOUNT").ok();
let rw_mode = match env::var("SCCACHE_GCS_RW_MODE").as_ref().map(String::as_str) {
Ok("READ_ONLY") => CacheModeConfig::ReadOnly,
Ok("READ_WRITE") => CacheModeConfig::ReadWrite,
// TODO: unsure if these should warn during the configuration loading
// or at the time when they're actually used to connect to GCS
Ok(_) => {
warn!("Invalid SCCACHE_GCS_RW_MODE -- defaulting to READ_ONLY.");
CacheModeConfig::ReadOnly
}
_ => {
warn!("No SCCACHE_GCS_RW_MODE specified -- defaulting to READ_ONLY.");
CacheModeConfig::ReadOnly
}
};
GCSCacheConfig {
bucket,
key_prefix,
cred_path,
service_account,
rw_mode,
credential_url,
}
});
// ======= GHA =======
let gha = if let Ok(version) = env::var("SCCACHE_GHA_VERSION") {
// If SCCACHE_GHA_VERSION has been set, we don't need to check
// SCCACHE_GHA_ENABLED's value anymore.
Some(GHACacheConfig {
enabled: true,
version,
})
} else if bool_from_env_var("SCCACHE_GHA_ENABLED")?.unwrap_or(false) {
// If only SCCACHE_GHA_ENABLED has been set to the true value, enable with
// default version.
Some(GHACacheConfig {
enabled: true,
version: "".to_string(),
})
} else {
None
};
// ======= Azure =======
let azure = if let (Ok(connection_string), Ok(container)) = (
env::var("SCCACHE_AZURE_CONNECTION_STRING"),
env::var("SCCACHE_AZURE_BLOB_CONTAINER"),
) {
let key_prefix = key_prefix_from_env_var("SCCACHE_AZURE_KEY_PREFIX");
Some(AzureCacheConfig {
connection_string,
container,
key_prefix,
})
} else {
None
};
// ======= WebDAV =======
let webdav = if let Ok(endpoint) = env::var("SCCACHE_WEBDAV_ENDPOINT") {
let key_prefix = key_prefix_from_env_var("SCCACHE_WEBDAV_KEY_PREFIX");
let username = env::var("SCCACHE_WEBDAV_USERNAME").ok();
let password = env::var("SCCACHE_WEBDAV_PASSWORD").ok();
let token = env::var("SCCACHE_WEBDAV_TOKEN").ok();
Some(WebdavCacheConfig {
endpoint,
key_prefix,
username,
password,
token,
})
} else {
None
};
// ======= OSS =======
let oss = if let Ok(bucket) = env::var("SCCACHE_OSS_BUCKET") {
let endpoint = env::var("SCCACHE_OSS_ENDPOINT").ok();
let key_prefix = key_prefix_from_env_var("SCCACHE_OSS_KEY_PREFIX");
let no_credentials = bool_from_env_var("SCCACHE_OSS_NO_CREDENTIALS")?.unwrap_or(false);
Some(OSSCacheConfig {
bucket,
endpoint,
key_prefix,
no_credentials,
})
} else {
None
};
if oss
.as_ref()
.map(|oss| oss.no_credentials)
.unwrap_or_default()
&& (env::var_os("ALIBABA_CLOUD_ACCESS_KEY_ID").is_some()
|| env::var_os("ALIBABA_CLOUD_ACCESS_KEY_SECRET").is_some())
{
bail!("If setting OSS credentials, SCCACHE_OSS_NO_CREDENTIALS must not be set.");
}
// ======= Local =======
let disk_dir = env::var_os("SCCACHE_DIR").map(PathBuf::from);
let disk_sz = env::var("SCCACHE_CACHE_SIZE")
.ok()
.and_then(|v| parse_size(&v));
let mut preprocessor_mode_config = PreprocessorCacheModeConfig::activated();
let preprocessor_mode_overridden = if let Some(value) = bool_from_env_var("SCCACHE_DIRECT")? {
preprocessor_mode_config.use_preprocessor_cache_mode = value;
true
} else {
false
};
let (disk_rw_mode, disk_rw_mode_overridden) = match env::var("SCCACHE_LOCAL_RW_MODE")
.as_ref()
.map(String::as_str)
{
Ok("READ_ONLY") => (CacheModeConfig::ReadOnly, true),
Ok("READ_WRITE") => (CacheModeConfig::ReadWrite, true),
Ok(_) => {
warn!("Invalid SCCACHE_LOCAL_RW_MODE -- defaulting to READ_WRITE.");
(CacheModeConfig::ReadWrite, false)
}
_ => (CacheModeConfig::ReadWrite, false),
};
let any_overridden = disk_dir.is_some()
|| disk_sz.is_some()
|| preprocessor_mode_overridden
|| disk_rw_mode_overridden;
let disk = if any_overridden {
Some(DiskCacheConfig {
dir: disk_dir.unwrap_or_else(default_disk_cache_dir),
size: disk_sz.unwrap_or_else(default_disk_cache_size),
preprocessor_cache_mode: preprocessor_mode_config,
rw_mode: disk_rw_mode,
})
} else {
None
};
let cache = CacheConfigs {
azure,
disk,
gcs,
gha,
memcached,
redis,
s3,
webdav,
oss,
};
Ok(EnvConfig { cache })
}