Line data    Source code

       1              : //! Wrapper around `std::env::var` for parsing environment variables.
       2              : 
       3              : use std::fmt::Display;
       4              : use std::str::FromStr;
       5              : 
       6              : /// For types `V` that implement [`FromStr`].
       7          217 : pub fn var<V, E>(varname: &str) -> Option<V>
       8          217 : where
       9          217 :     V: FromStr<Err = E>,
      10          217 :     E: Display,
      11              : {
      12          217 :     match std::env::var(varname) {
      13            0 :         Ok(s) => Some(
      14            0 :             s.parse()
      15            0 :                 .map_err(|e| {
      16            0 :                     format!("failed to parse env var {varname} using FromStr::parse: {e:#}")
      17            0 :                 })
      18            0 :                 .unwrap(),
      19              :         ),
      20          217 :         Err(std::env::VarError::NotPresent) => None,
      21              :         Err(std::env::VarError::NotUnicode(_)) => {
      22            0 :             panic!("env var {varname} is not unicode")
      23              :         }
      24              :     }
      25            3 : }
      26              : 
      27              : /// For types `V` that implement [`serde::de::DeserializeOwned`].
      28           17 : pub fn var_serde_json_string<V>(varname: &str) -> Option<V>
      29           17 : where
      30           17 :     V: serde::de::DeserializeOwned,
      31              : {
      32           17 :     match std::env::var(varname) {
      33            0 :         Ok(s) => Some({
      34            0 :             let value = serde_json::Value::String(s);
      35            0 :             serde_json::from_value(value)
      36            0 :                 .map_err(|e| {
      37            0 :                     format!("failed to parse env var {varname} as a serde_json json string: {e:#}")
      38            0 :                 })
      39            0 :                 .unwrap()
      40              :         }),
      41           17 :         Err(std::env::VarError::NotPresent) => None,
      42              :         Err(std::env::VarError::NotUnicode(_)) => {
      43            0 :             panic!("env var {varname} is not unicode")
      44              :         }
      45              :     }
      46            0 : }
      47              : 
      48              : /* BEGIN_HADRON */
      49              : pub enum DeploymentMode {
      50              :     Local,
      51              :     Dev,
      52              :     Staging,
      53              :     Prod,
      54              : }
      55              : 
      56            0 : pub fn get_deployment_mode() -> Option<DeploymentMode> {
      57            0 :     match std::env::var("DEPLOYMENT_MODE") {
      58            0 :         Ok(env) => match env.as_str() {
      59            0 :             "development" => Some(DeploymentMode::Dev),
      60            0 :             "staging" => Some(DeploymentMode::Staging),
      61            0 :             "production" => Some(DeploymentMode::Prod),
      62              :             _ => {
      63            0 :                 tracing::error!("Unexpected DEPLOYMENT_MODE: {}", env);
      64            0 :                 None
      65              :             }
      66              :         },
      67              :         Err(_) => {
      68              :             // tracing::error!("DEPLOYMENT_MODE not set");
      69            0 :             None
      70              :         }
      71              :     }
      72            0 : }
      73              : 
      74            0 : pub fn is_dev_or_staging() -> bool {
      75            0 :     matches!(
      76            0 :         get_deployment_mode(),
      77              :         Some(DeploymentMode::Dev) | Some(DeploymentMode::Staging)
      78              :     )
      79            0 : }
      80              : 
      81              : pub enum TestingMode {
      82              :     Chaos,
      83              :     Stress,
      84              : }
      85              : 
      86            0 : pub fn get_test_mode() -> Option<TestingMode> {
      87            0 :     match std::env::var("HADRON_TEST_MODE") {
      88            0 :         Ok(env) => match env.as_str() {
      89            0 :             "chaos" => Some(TestingMode::Chaos),
      90            0 :             "stress" => Some(TestingMode::Stress),
      91              :             _ => {
      92            0 :                 tracing::error!("Unexpected HADRON_TEST_MODE: {}", env);
      93            0 :                 None
      94              :             }
      95              :         },
      96              :         Err(_) => {
      97            0 :             tracing::error!("HADRON_TEST_MODE not set");
      98            0 :             None
      99              :         }
     100              :     }
     101            0 : }
     102              : 
     103            0 : pub fn is_chaos_testing() -> bool {
     104            0 :     matches!(get_test_mode(), Some(TestingMode::Chaos))
     105            0 : }
     106              : /* END_HADRON */