New configuration parsing using envy. Added minimal functionnality for

the future ACME parameters. Tests written and passing.

WIP: added envy dependncy and ConfigOpts structs that will constitute Diplonat's configuration

WIP: ConfigOpts from_env() and validate() methods written. No API change (the env names remain unchanged)! Now need to use our new ConfigOpts struct instead of Environment, and update references to the environment variables in the code.

WIP: RuntimeConfig with business logic done. Tests written, but they are all running from the same process - setting environment variables in each test produces incoherent results. Another solution for testing is needed.

WIP: tests are fully written using 'from_iter' and all passing

1 files changed, 112 insertions, 0 deletions

diff --git a/src/config/runtime.rs b/src/config/runtime.rs
new file mode 100644
index 0000000..6649d39
--- /dev/null
+++ b/src/config/runtime.rs
@@ -0,0 +1,112 @@
+use std::time::Duration;
+
+use anyhow::{Result, anyhow};
+
+use crate::config::{ConfigOpts, ConfigOptsAcme, ConfigOptsBase, ConfigOptsConsul};
+
+// This code is inspired by the Trunk crate (https://github.com/thedodd/trunk)
+
+// In this file, we take ConfigOpts and transform them into ready-to-use RuntimeConfig.
+// We apply default values and business logic.
+
+pub struct RuntimeConfigAcme {
+	pub email: String,
+}
+
+pub struct RuntimeConfigConsul {
+	pub node_name: String,
+	pub url: String,
+}
+
+pub struct RuntimeConfigFirewall {
+	pub refresh_time: Duration,
+}
+
+pub struct RuntimeConfigIgd {
+	pub private_ip: String,
+	pub expiration_time: Duration,
+	pub refresh_time: Duration,
+}
+
+pub struct RuntimeConfig {
+	pub acme: Option<RuntimeConfigAcme>,
+	pub consul: RuntimeConfigConsul,
+	pub firewall: RuntimeConfigFirewall,
+	pub igd: RuntimeConfigIgd,
+}
+
+impl RuntimeConfig {
+	pub fn new(opts: ConfigOpts) -> Result<Self> {
+		let acme = RuntimeConfigAcme::new(opts.acme.clone())?;
+		let consul = RuntimeConfigConsul::new(opts.consul.clone())?;
+		let firewall = RuntimeConfigFirewall::new(opts.base.clone())?;
+		let igd = RuntimeConfigIgd::new(opts.base.clone())?;
+
+		Ok(Self {
+			acme,
+			consul,
+			firewall,
+			igd,
+		})
+	}
+}
+
+impl RuntimeConfigAcme {
+	pub fn new(opts: ConfigOptsAcme) -> Result<Option<Self>> {
+		if !opts.enable {
+			return Ok(None);
+		}
+
+		let email = opts.email.unwrap();
+
+		Ok(Some(Self {
+			email,
+		}))
+	}
+}
+
+impl RuntimeConfigConsul {
+	pub(super) fn new(opts: ConfigOptsConsul) -> Result<Self> {
+		let node_name = opts.node_name.unwrap();
+		let url = opts.url.unwrap_or(super::CONSUL_URL.to_string());
+
+		Ok(Self {
+			node_name,
+			url,
+		})
+	}
+}
+
+impl RuntimeConfigFirewall {
+	pub(super) fn new(opts: ConfigOptsBase) -> Result<Self> {
+		let refresh_time = Duration::from_secs(
+				opts.refresh_time.unwrap_or(super::REFRESH_TIME).into());
+
+		Ok(Self {
+			refresh_time,
+		})
+	}
+}
+
+impl RuntimeConfigIgd {
+	pub(super) fn new(opts: ConfigOptsBase) -> Result<Self> {
+		let private_ip = opts.private_ip.unwrap();
+		let expiration_time = Duration::from_secs(
+				opts.expiration_time.unwrap_or(super::EXPIRATION_TIME).into());
+		let refresh_time = Duration::from_secs(
+				opts.refresh_time.unwrap_or(super::REFRESH_TIME).into());
+
+		if refresh_time.as_secs() * 2 > expiration_time.as_secs() {
+	      return Err(anyhow!(
+	        "IGD expiration time (currently: {}s) must be at least twice bigger than refresh time (currently: {}s)", 
+	        expiration_time.as_secs(),
+	        refresh_time.as_secs()));
+	    }
+
+		Ok(Self {
+			private_ip,
+			expiration_time,
+			refresh_time,
+		})
+	}
+}
\ No newline at end of file