diff --git a/.rustfmt.toml b/.rustfmt.toml new file mode 100644 index 0000000..f0fa07f --- /dev/null +++ b/.rustfmt.toml @@ -0,0 +1,2 @@ +hard_tabs = false +tab_spaces = 2 diff --git a/src/config/mod.rs b/src/config/mod.rs index 024e114..9dddd04 100644 --- a/src/config/mod.rs +++ b/src/config/mod.rs @@ -3,9 +3,13 @@ mod options; mod options_test; mod runtime; -pub use options::{ConfigOpts, ConfigOptsConsul, ConfigOptsAcme, ConfigOptsFirewall, ConfigOptsIgd}; -pub use runtime::{RuntimeConfig, RuntimeConfigAcme, RuntimeConfigConsul, RuntimeConfigFirewall, RuntimeConfigIgd}; +pub use options::{ + ConfigOpts, ConfigOptsAcme, ConfigOptsConsul, ConfigOptsFirewall, ConfigOptsIgd, +}; +pub use runtime::{ + RuntimeConfig, RuntimeConfigAcme, RuntimeConfigConsul, RuntimeConfigFirewall, RuntimeConfigIgd, +}; pub const EXPIRATION_TIME: u16 = 300; pub const REFRESH_TIME: u16 = 60; -pub const CONSUL_URL: &str = "http://127.0.0.1:8500"; \ No newline at end of file +pub const CONSUL_URL: &str = "http://127.0.0.1:8500"; diff --git a/src/config/options.rs b/src/config/options.rs index b3a63b0..638a2f3 100644 --- a/src/config/options.rs +++ b/src/config/options.rs @@ -12,93 +12,95 @@ use crate::config::RuntimeConfig; // There is no *need* to have a 'DIPLONAT_XXX_*' prefix for all config options. // If some config options are shared by several modules, a ConfigOptsBase could // contain them, and parse the 'DIPLONAT_*' prefix directly. -// Only in runtime.rs would these options find their proper location in each +// Only in runtime.rs would these options find their proper location in each // module's struct. - /// Consul configuration options #[derive(Clone, Default, Deserialize)] pub struct ConfigOptsConsul { - /// Consul's node name [default: None] - pub node_name: Option, - /// Consul's REST URL [default: "http://127.0.0.1:8500"] - pub url: Option, + /// Consul's node name [default: None] + pub node_name: Option, + /// Consul's REST URL [default: "http://127.0.0.1:8500"] + pub url: Option, } /// ACME configuration options #[derive(Clone, Default, Deserialize)] pub struct ConfigOptsAcme { - /// Whether the ACME module is enabled [default: false] - #[serde(default)] - pub enable: bool, + /// Whether the ACME module is enabled [default: false] + #[serde(default)] + pub enable: bool, - /// The default domain holder's e-mail [default: None] - pub email: Option, + /// The default domain holder's e-mail [default: None] + pub email: Option, } /// Firewall configuration options #[derive(Clone, Default, Deserialize)] pub struct ConfigOptsFirewall { - /// Whether the firewall module is enabled [default: false] - #[serde(default)] - pub enable: bool, + /// Whether the firewall module is enabled [default: false] + #[serde(default)] + pub enable: bool, - /// Refresh time for firewall rules [default: 300] - pub refresh_time: Option, + /// Refresh time for firewall rules [default: 300] + pub refresh_time: Option, } /// IGD configuration options #[derive(Clone, Default, Deserialize)] pub struct ConfigOptsIgd { - /// Whether the IGD module is enabled [default: false] - #[serde(default)] - pub enable: bool, + /// Whether the IGD module is enabled [default: false] + #[serde(default)] + pub enable: bool, - /// This node's private IP address [default: None] - pub private_ip: Option, - /// Expiration time for IGD rules [default: 60] - pub expiration_time: Option, - /// Refresh time for IGD rules [default: 300] - pub refresh_time: Option, + /// This node's private IP address [default: None] + pub private_ip: Option, + /// Expiration time for IGD rules [default: 60] + pub expiration_time: Option, + /// Refresh time for IGD rules [default: 300] + pub refresh_time: Option, } /// Model of all potential configuration options pub struct ConfigOpts { - pub consul: ConfigOptsConsul, - pub acme: ConfigOptsAcme, - pub firewall: ConfigOptsFirewall, - pub igd: ConfigOptsIgd, + pub consul: ConfigOptsConsul, + pub acme: ConfigOptsAcme, + pub firewall: ConfigOptsFirewall, + pub igd: ConfigOptsIgd, } impl ConfigOpts { - pub fn from_env() -> Result { - let consul: ConfigOptsConsul = envy::prefixed("DIPLONAT_CONSUL_").from_env()?; - let acme: ConfigOptsAcme = envy::prefixed("DIPLONAT_ACME_").from_env()?; - let firewall: ConfigOptsFirewall = envy::prefixed("DIPLONAT_FIREWALL_").from_env()?; - let igd: ConfigOptsIgd = envy::prefixed("DIPLONAT_IGD_").from_env()?; + pub fn from_env() -> Result { + let consul: ConfigOptsConsul = envy::prefixed("DIPLONAT_CONSUL_").from_env()?; + let acme: ConfigOptsAcme = envy::prefixed("DIPLONAT_ACME_").from_env()?; + let firewall: ConfigOptsFirewall = envy::prefixed("DIPLONAT_FIREWALL_").from_env()?; + let igd: ConfigOptsIgd = envy::prefixed("DIPLONAT_IGD_").from_env()?; - RuntimeConfig::new(Self { - consul, - acme, - firewall, - igd, - }) - } + RuntimeConfig::new(Self { + consul, + acme, + firewall, + igd, + }) + } - // Currently only used in tests - #[allow(dead_code)] - pub fn from_iter(iter: Iter) -> Result - where Iter: IntoIterator { - let consul: ConfigOptsConsul = envy::prefixed("DIPLONAT_CONSUL_").from_iter(iter.clone())?; - let acme: ConfigOptsAcme = envy::prefixed("DIPLONAT_ACME_").from_iter(iter.clone())?; - let firewall: ConfigOptsFirewall = envy::prefixed("DIPLONAT_FIREWALL_").from_iter(iter.clone())?; - let igd: ConfigOptsIgd = envy::prefixed("DIPLONAT_IGD_").from_iter(iter.clone())?; + // Currently only used in tests + #[allow(dead_code)] + pub fn from_iter(iter: Iter) -> Result + where + Iter: IntoIterator, + { + let consul: ConfigOptsConsul = envy::prefixed("DIPLONAT_CONSUL_").from_iter(iter.clone())?; + let acme: ConfigOptsAcme = envy::prefixed("DIPLONAT_ACME_").from_iter(iter.clone())?; + let firewall: ConfigOptsFirewall = + envy::prefixed("DIPLONAT_FIREWALL_").from_iter(iter.clone())?; + let igd: ConfigOptsIgd = envy::prefixed("DIPLONAT_IGD_").from_iter(iter.clone())?; - RuntimeConfig::new(Self { - consul, - acme, - firewall, - igd, - }) - } -} \ No newline at end of file + RuntimeConfig::new(Self { + consul, + acme, + firewall, + igd, + }) + } +} diff --git a/src/config/options_test.rs b/src/config/options_test.rs index 98fc625..0dfaaac 100644 --- a/src/config/options_test.rs +++ b/src/config/options_test.rs @@ -5,28 +5,43 @@ use crate::config::*; // Environment variables are set for the entire process and // tests are run whithin the same process. -// => We cannot test ConfigOpts::from_env(), +// => We cannot test ConfigOpts::from_env(), // because tests modify each other's environment. // This is why we only test ConfigOpts::from_iter(iter). fn minimal_valid_options() -> HashMap { - let mut opts = HashMap::new(); - opts.insert("DIPLONAT_CONSUL_NODE_NAME".to_string(), "consul_node".to_string()); - opts + let mut opts = HashMap::new(); + opts.insert( + "DIPLONAT_CONSUL_NODE_NAME".to_string(), + "consul_node".to_string(), + ); + opts } fn all_valid_options() -> HashMap { - let mut opts = minimal_valid_options(); - opts.insert("DIPLONAT_CONSUL_URL".to_string(), "http://127.0.0.1:9999".to_string()); - opts.insert("DIPLONAT_ACME_ENABLE".to_string(), "true".to_string()); - opts.insert("DIPLONAT_ACME_EMAIL".to_string(), "bozo@bozo.net".to_string()); - opts.insert("DIPLONAT_FIREWALL_ENABLE".to_string(), "true".to_string()); - opts.insert("DIPLONAT_FIREWALL_REFRESH_TIME".to_string(), "20".to_string()); - opts.insert("DIPLONAT_IGD_ENABLE".to_string(), "true".to_string()); - opts.insert("DIPLONAT_IGD_PRIVATE_IP".to_string(), "172.123.43.555".to_string()); - opts.insert("DIPLONAT_IGD_EXPIRATION_TIME".to_string(), "60".to_string()); - opts.insert("DIPLONAT_IGD_REFRESH_TIME".to_string(), "10".to_string()); - opts + let mut opts = minimal_valid_options(); + opts.insert( + "DIPLONAT_CONSUL_URL".to_string(), + "http://127.0.0.1:9999".to_string(), + ); + opts.insert("DIPLONAT_ACME_ENABLE".to_string(), "true".to_string()); + opts.insert( + "DIPLONAT_ACME_EMAIL".to_string(), + "bozo@bozo.net".to_string(), + ); + opts.insert("DIPLONAT_FIREWALL_ENABLE".to_string(), "true".to_string()); + opts.insert( + "DIPLONAT_FIREWALL_REFRESH_TIME".to_string(), + "20".to_string(), + ); + opts.insert("DIPLONAT_IGD_ENABLE".to_string(), "true".to_string()); + opts.insert( + "DIPLONAT_IGD_PRIVATE_IP".to_string(), + "172.123.43.555".to_string(), + ); + opts.insert("DIPLONAT_IGD_EXPIRATION_TIME".to_string(), "60".to_string()); + opts.insert("DIPLONAT_IGD_REFRESH_TIME".to_string(), "10".to_string()); + opts } // #[test] @@ -39,107 +54,108 @@ fn all_valid_options() -> HashMap { #[test] #[should_panic] fn err_empty_env() { - std::env::remove_var("DIPLONAT_CONSUL_NODE_NAME"); - let opts: HashMap = HashMap::new(); - ConfigOpts::from_iter(opts).unwrap(); + std::env::remove_var("DIPLONAT_CONSUL_NODE_NAME"); + let opts: HashMap = HashMap::new(); + ConfigOpts::from_iter(opts).unwrap(); } #[test] fn ok_minimal_valid_options() { - let opts = minimal_valid_options(); - let rt_config = ConfigOpts::from_iter(opts.clone()).unwrap(); + let opts = minimal_valid_options(); + let rt_config = ConfigOpts::from_iter(opts.clone()).unwrap(); - assert_eq!( - &rt_config.consul.node_name, - opts.get(&"DIPLONAT_CONSUL_NODE_NAME".to_string()).unwrap() - ); - assert_eq!( - rt_config.consul.url, - CONSUL_URL.to_string() - ); - assert!(rt_config.acme.is_none()); - assert!(rt_config.firewall.is_none()); - assert!(rt_config.igd.is_none()); - /*assert_eq!( - rt_config.firewall.refresh_time, - Duration::from_secs(REFRESH_TIME.into()) - ); - assert_eq!( - &rt_config.igd.private_ip, - opts.get(&"DIPLONAT_PRIVATE_IP".to_string()).unwrap() - ); - assert_eq!( - rt_config.igd.expiration_time, - Duration::from_secs(EXPIRATION_TIME.into()) - ); - assert_eq!( - rt_config.igd.refresh_time, - Duration::from_secs(REFRESH_TIME.into()) - );*/ + assert_eq!( + &rt_config.consul.node_name, + opts.get(&"DIPLONAT_CONSUL_NODE_NAME".to_string()).unwrap() + ); + assert_eq!(rt_config.consul.url, CONSUL_URL.to_string()); + assert!(rt_config.acme.is_none()); + assert!(rt_config.firewall.is_none()); + assert!(rt_config.igd.is_none()); + /*assert_eq!( + rt_config.firewall.refresh_time, + Duration::from_secs(REFRESH_TIME.into()) + ); + assert_eq!( + &rt_config.igd.private_ip, + opts.get(&"DIPLONAT_PRIVATE_IP".to_string()).unwrap() + ); + assert_eq!( + rt_config.igd.expiration_time, + Duration::from_secs(EXPIRATION_TIME.into()) + ); + assert_eq!( + rt_config.igd.refresh_time, + Duration::from_secs(REFRESH_TIME.into()) + );*/ } #[test] #[should_panic] fn err_invalid_igd_options() { - let mut opts = minimal_valid_options(); - opts.insert("DIPLONAT_IGD_ENABLE".to_string(), "true".to_string()); - opts.insert("DIPLONAT_IGD_EXPIRATION_TIME".to_string(), "60".to_string()); - opts.insert("DIPLONAT_IGD_REFRESH_TIME".to_string(), "60".to_string()); - ConfigOpts::from_iter(opts).unwrap(); + let mut opts = minimal_valid_options(); + opts.insert("DIPLONAT_IGD_ENABLE".to_string(), "true".to_string()); + opts.insert("DIPLONAT_IGD_EXPIRATION_TIME".to_string(), "60".to_string()); + opts.insert("DIPLONAT_IGD_REFRESH_TIME".to_string(), "60".to_string()); + ConfigOpts::from_iter(opts).unwrap(); } #[test] fn ok_all_valid_options() { - let opts = all_valid_options(); - let rt_config = ConfigOpts::from_iter(opts.clone()).unwrap(); + let opts = all_valid_options(); + let rt_config = ConfigOpts::from_iter(opts.clone()).unwrap(); - let firewall_refresh_time = Duration::from_secs( - opts.get(&"DIPLONAT_FIREWALL_REFRESH_TIME".to_string()).unwrap() - .parse::().unwrap() - .into()); - let igd_expiration_time = Duration::from_secs( - opts.get(&"DIPLONAT_IGD_EXPIRATION_TIME".to_string()).unwrap() - .parse::().unwrap() - .into()); - let igd_refresh_time = Duration::from_secs( - opts.get(&"DIPLONAT_IGD_REFRESH_TIME".to_string()).unwrap() - .parse::().unwrap() - .into()); + let firewall_refresh_time = Duration::from_secs( + opts + .get(&"DIPLONAT_FIREWALL_REFRESH_TIME".to_string()) + .unwrap() + .parse::() + .unwrap() + .into(), + ); + let igd_expiration_time = Duration::from_secs( + opts + .get(&"DIPLONAT_IGD_EXPIRATION_TIME".to_string()) + .unwrap() + .parse::() + .unwrap() + .into(), + ); + let igd_refresh_time = Duration::from_secs( + opts + .get(&"DIPLONAT_IGD_REFRESH_TIME".to_string()) + .unwrap() + .parse::() + .unwrap() + .into(), + ); - assert_eq!( - &rt_config.consul.node_name, - opts.get(&"DIPLONAT_CONSUL_NODE_NAME".to_string()).unwrap() - ); - assert_eq!( - &rt_config.consul.url, - opts.get(&"DIPLONAT_CONSUL_URL".to_string()).unwrap() - ); + assert_eq!( + &rt_config.consul.node_name, + opts.get(&"DIPLONAT_CONSUL_NODE_NAME".to_string()).unwrap() + ); + assert_eq!( + &rt_config.consul.url, + opts.get(&"DIPLONAT_CONSUL_URL".to_string()).unwrap() + ); - assert!(rt_config.acme.is_some()); - let acme = rt_config.acme.unwrap(); - assert_eq!( - &acme.email, - opts.get(&"DIPLONAT_ACME_EMAIL".to_string()).unwrap()); + assert!(rt_config.acme.is_some()); + let acme = rt_config.acme.unwrap(); + assert_eq!( + &acme.email, + opts.get(&"DIPLONAT_ACME_EMAIL".to_string()).unwrap() + ); - assert!(rt_config.firewall.is_some()); - let firewall = rt_config.firewall.unwrap(); - assert_eq!( - firewall.refresh_time, - firewall_refresh_time - ); + assert!(rt_config.firewall.is_some()); + let firewall = rt_config.firewall.unwrap(); + assert_eq!(firewall.refresh_time, firewall_refresh_time); - assert!(rt_config.igd.is_some()); - let igd = rt_config.igd.unwrap(); - assert_eq!( - &igd.private_ip, - opts.get(&"DIPLONAT_IGD_PRIVATE_IP".to_string()).unwrap() - ); - assert_eq!( - igd.expiration_time, - igd_expiration_time - ); - assert_eq!( - igd.refresh_time, - igd_refresh_time - ); -} \ No newline at end of file + assert!(rt_config.igd.is_some()); + let igd = rt_config.igd.unwrap(); + assert_eq!( + &igd.private_ip, + opts.get(&"DIPLONAT_IGD_PRIVATE_IP".to_string()).unwrap() + ); + assert_eq!(igd.expiration_time, igd_expiration_time); + assert_eq!(igd.refresh_time, igd_refresh_time); +} diff --git a/src/config/runtime.rs b/src/config/runtime.rs index f83a6b5..4e718a0 100644 --- a/src/config/runtime.rs +++ b/src/config/runtime.rs @@ -1,8 +1,10 @@ use std::time::Duration; -use anyhow::{Result, anyhow}; +use anyhow::{anyhow, Result}; -use crate::config::{ConfigOpts, ConfigOptsConsul, ConfigOptsAcme, ConfigOptsFirewall, ConfigOptsIgd}; +use crate::config::{ + ConfigOpts, ConfigOptsAcme, ConfigOptsConsul, ConfigOptsFirewall, ConfigOptsIgd, +}; // This code is inspired by the Trunk crate (https://github.com/thedodd/trunk) @@ -13,118 +15,116 @@ use crate::config::{ConfigOpts, ConfigOptsConsul, ConfigOptsAcme, ConfigOptsFire #[derive(Debug)] pub struct RuntimeConfigConsul { - pub node_name: String, - pub url: String, + pub node_name: String, + pub url: String, } #[derive(Debug)] pub struct RuntimeConfigAcme { - pub email: String, + pub email: String, } #[derive(Debug)] pub struct RuntimeConfigFirewall { - pub refresh_time: Duration, + pub refresh_time: Duration, } #[derive(Debug)] pub struct RuntimeConfigIgd { - pub private_ip: String, - pub expiration_time: Duration, - pub refresh_time: Duration, + pub private_ip: String, + pub expiration_time: Duration, + pub refresh_time: Duration, } #[derive(Debug)] pub struct RuntimeConfig { - pub consul: RuntimeConfigConsul, - pub acme: Option, - pub firewall: Option, - pub igd: Option, + pub consul: RuntimeConfigConsul, + pub acme: Option, + pub firewall: Option, + pub igd: Option, } impl RuntimeConfig { - pub fn new(opts: ConfigOpts) -> Result { - let consul = RuntimeConfigConsul::new(opts.consul.clone())?; - let acme = RuntimeConfigAcme::new(opts.acme.clone())?; - let firewall = RuntimeConfigFirewall::new(opts.firewall.clone())?; - let igd = RuntimeConfigIgd::new(opts.igd.clone())?; + pub fn new(opts: ConfigOpts) -> Result { + let consul = RuntimeConfigConsul::new(opts.consul.clone())?; + let acme = RuntimeConfigAcme::new(opts.acme.clone())?; + let firewall = RuntimeConfigFirewall::new(opts.firewall.clone())?; + let igd = RuntimeConfigIgd::new(opts.igd.clone())?; - Ok(Self { - acme, - consul, - firewall, - igd, - }) - } + Ok(Self { + acme, + consul, + firewall, + igd, + }) + } } impl RuntimeConfigConsul { - pub(super) fn new(opts: ConfigOptsConsul) -> Result { - let node_name = opts.node_name.expect( - "'DIPLONAT_CONSUL_NODE_NAME' is required"); - let url = opts.url.unwrap_or(super::CONSUL_URL.to_string()); + pub(super) fn new(opts: ConfigOptsConsul) -> Result { + let node_name = opts + .node_name + .expect("'DIPLONAT_CONSUL_NODE_NAME' is required"); + let url = opts.url.unwrap_or(super::CONSUL_URL.to_string()); - Ok(Self { - node_name, - url, - }) - } + Ok(Self { node_name, url }) + } } impl RuntimeConfigAcme { - pub fn new(opts: ConfigOptsAcme) -> Result> { - if !opts.enable { - return Ok(None); - } + pub fn new(opts: ConfigOptsAcme) -> Result> { + if !opts.enable { + return Ok(None); + } - let email = opts.email.expect( - "'DIPLONAT_ACME_EMAIL' is required if ACME is enabled"); + let email = opts + .email + .expect("'DIPLONAT_ACME_EMAIL' is required if ACME is enabled"); - Ok(Some(Self { - email, - })) - } + Ok(Some(Self { email })) + } } impl RuntimeConfigFirewall { - pub(super) fn new(opts: ConfigOptsFirewall) -> Result> { - if !opts.enable { - return Ok(None); - } + pub(super) fn new(opts: ConfigOptsFirewall) -> Result> { + if !opts.enable { + return Ok(None); + } - let refresh_time = Duration::from_secs( - opts.refresh_time.unwrap_or(super::REFRESH_TIME).into()); + let refresh_time = Duration::from_secs(opts.refresh_time.unwrap_or(super::REFRESH_TIME).into()); - Ok(Some(Self { - refresh_time, - })) - } + Ok(Some(Self { refresh_time })) + } } impl RuntimeConfigIgd { - pub(super) fn new(opts: ConfigOptsIgd) -> Result> { - if !opts.enable { - return Ok(None); - } + pub(super) fn new(opts: ConfigOptsIgd) -> Result> { + if !opts.enable { + return Ok(None); + } - let private_ip = opts.private_ip.expect( - "'DIPLONAT_IGD_PRIVATE_IP' is required if IGD is enabled"); - 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()); + let private_ip = opts + .private_ip + .expect("'DIPLONAT_IGD_PRIVATE_IP' is required if IGD is enabled"); + 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!( + 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(Some(Self { - private_ip, - expiration_time, - refresh_time, - })) - } -} \ No newline at end of file + Ok(Some(Self { + private_ip, + expiration_time, + refresh_time, + })) + } +} diff --git a/src/consul.rs b/src/consul.rs index 9a91782..4e4f79c 100644 --- a/src/consul.rs +++ b/src/consul.rs @@ -1,22 +1,22 @@ use std::collections::HashMap; -use anyhow::{Result, anyhow}; -use serde::{Serialize, Deserialize}; +use anyhow::{anyhow, Result}; +use serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize, Debug)] pub struct ServiceEntry { - pub Tags: Vec + pub Tags: Vec, } #[derive(Serialize, Deserialize, Debug)] pub struct CatalogNode { - pub Services: HashMap + pub Services: HashMap, } pub struct Consul { client: reqwest::Client, url: String, - idx: Option + idx: Option, } impl Consul { @@ -24,7 +24,7 @@ impl Consul { return Self { client: reqwest::Client::new(), url: url.to_string(), - idx: None + idx: None, }; } @@ -35,16 +35,16 @@ impl Consul { pub async fn watch_node(&mut self, host: &str) -> Result { let url = match self.idx { Some(i) => format!("{}/v1/catalog/node/{}?index={}", self.url, host, i), - None => format!("{}/v1/catalog/node/{}", self.url, host) + None => format!("{}/v1/catalog/node/{}", self.url, host), }; let http = self.client.get(&url).send().await?; self.idx = match http.headers().get("X-Consul-Index") { Some(v) => Some(v.to_str()?.parse::()?), - None => return Err(anyhow!("X-Consul-Index header not found")) + None => return Err(anyhow!("X-Consul-Index header not found")), }; let resp: CatalogNode = http.json().await?; - return Ok(resp) + return Ok(resp); } } diff --git a/src/consul_actor.rs b/src/consul_actor.rs index dcbd79e..dc5bb5e 100644 --- a/src/consul_actor.rs +++ b/src/consul_actor.rs @@ -4,8 +4,8 @@ use std::time::Duration; use anyhow::Result; use log::*; -use serde::{Serialize, Deserialize}; -use serde_lexpr::{from_str,error}; +use serde::{Deserialize, Serialize}; +use serde_lexpr::{error, from_str}; use tokio::sync::watch; use tokio::time::delay_for; @@ -16,12 +16,12 @@ use crate::messages; #[derive(Serialize, Deserialize, Debug)] pub enum DiplonatParameter { tcp_port(HashSet), - udp_port(HashSet) + udp_port(HashSet), } #[derive(Serialize, Deserialize, Debug)] pub enum DiplonatConsul { - diplonat(Vec) + diplonat(Vec), } pub struct ConsulActor { @@ -31,13 +31,16 @@ pub struct ConsulActor { node: String, retries: u32, - tx_open_ports: watch::Sender + tx_open_ports: watch::Sender, } fn retry_to_time(retries: u32, max_time: Duration) -> Duration { // 1.2^x seems to be a good value to exponentially increase time at a good pace // eg. 1.2^32 = 341 seconds ~= 5 minutes - ie. after 32 retries we wait 5 minutes - return Duration::from_secs(cmp::min(max_time.as_secs(), 1.2f64.powf(retries as f64) as u64)) + return Duration::from_secs(cmp::min( + max_time.as_secs(), + 1.2f64.powf(retries as f64) as u64, + )); } fn to_parameters(catalog: &consul::CatalogNode) -> Vec { @@ -57,9 +60,9 @@ fn to_parameters(catalog: &consul::CatalogNode) -> Vec { } fn to_open_ports(params: &Vec) -> messages::PublicExposedPorts { - let mut op = messages::PublicExposedPorts { + let mut op = messages::PublicExposedPorts { tcp_ports: HashSet::new(), - udp_ports: HashSet::new() + udp_ports: HashSet::new(), }; for conf in params { @@ -77,9 +80,9 @@ fn to_open_ports(params: &Vec) -> messages::PublicExposedPorts { impl ConsulActor { pub fn new(config: RuntimeConfigConsul) -> Self { - let (tx, rx) = watch::channel(messages::PublicExposedPorts{ + let (tx, rx) = watch::channel(messages::PublicExposedPorts { tcp_ports: HashSet::new(), - udp_ports: HashSet::new() + udp_ports: HashSet::new(), }); return Self { @@ -99,7 +102,11 @@ impl ConsulActor { self.consul.watch_node_reset(); self.retries = cmp::min(std::u32::MAX - 1, self.retries) + 1; let will_retry_in = retry_to_time(self.retries, Duration::from_secs(600)); - error!("Failed to query consul. Will retry in {}s. {}", will_retry_in.as_secs(), e); + error!( + "Failed to query consul. Will retry in {}s. {}", + will_retry_in.as_secs(), + e + ); delay_for(will_retry_in).await; continue; } diff --git a/src/diplonat.rs b/src/diplonat.rs index 6334e5b..3b5793d 100644 --- a/src/diplonat.rs +++ b/src/diplonat.rs @@ -1,4 +1,4 @@ -use anyhow::{Result, anyhow}; +use anyhow::{anyhow, Result}; use tokio::try_join; use crate::config::ConfigOpts; @@ -17,22 +17,17 @@ impl Diplonat { pub async fn new() -> Result { let config = ConfigOpts::from_env()?; println!("{:#?}", config); - + let consul_actor = ConsulActor::new(config.consul); - let firewall_actor = FirewallActor::new( - config.firewall, - &consul_actor.rx_open_ports - ).await?; - - let igd_actor = IgdActor::new( - config.igd, - &consul_actor.rx_open_ports - ).await?; + let firewall_actor = FirewallActor::new(config.firewall, &consul_actor.rx_open_ports).await?; + + let igd_actor = IgdActor::new(config.igd, &consul_actor.rx_open_ports).await?; if firewall_actor.is_none() && igd_actor.is_none() { return Err(anyhow!( - "At least enable *one* module, otherwise it's boring!")); + "At least enable *one* module, otherwise it's boring!" + )); } let ctx = Self { @@ -53,13 +48,13 @@ impl Diplonat { async { match firewall { Some(x) => x.listen().await, - None => Ok(()) + None => Ok(()), } }, async { match igd { Some(x) => x.listen().await, - None => Ok(()) + None => Ok(()), } }, )?; diff --git a/src/fw.rs b/src/fw.rs index a71dd1c..e18a301 100644 --- a/src/fw.rs +++ b/src/fw.rs @@ -1,6 +1,6 @@ use std::collections::HashSet; -use anyhow::{Result,Context}; +use anyhow::{Context, Result}; use iptables; use log::*; use regex::Regex; @@ -8,76 +8,92 @@ use regex::Regex; use crate::messages; pub fn setup(ipt: &iptables::IPTables) -> Result<()> { + // ensure we start from a clean state without any rule already set + cleanup(ipt)?; - // ensure we start from a clean state without any rule already set - cleanup(ipt)?; - - ipt.new_chain("filter", "DIPLONAT").context("Failed to create new chain")?; - ipt.insert_unique("filter", "INPUT", "-j DIPLONAT", 1).context("Failed to insert jump rule")?; + ipt + .new_chain("filter", "DIPLONAT") + .context("Failed to create new chain")?; + ipt + .insert_unique("filter", "INPUT", "-j DIPLONAT", 1) + .context("Failed to insert jump rule")?; - Ok(()) + Ok(()) } pub fn open_ports(ipt: &iptables::IPTables, ports: messages::PublicExposedPorts) -> Result<()> { - for p in ports.tcp_ports { - ipt.append("filter", "DIPLONAT", &format!("-p tcp --dport {} -j ACCEPT", p)).context("Failed to insert port rule")?; - } + for p in ports.tcp_ports { + ipt + .append( + "filter", + "DIPLONAT", + &format!("-p tcp --dport {} -j ACCEPT", p), + ) + .context("Failed to insert port rule")?; + } - for p in ports.udp_ports { - ipt.append("filter", "DIPLONAT", &format!("-p udp --dport {} -j ACCEPT", p)).context("Failed to insert port rule")?; - } + for p in ports.udp_ports { + ipt + .append( + "filter", + "DIPLONAT", + &format!("-p udp --dport {} -j ACCEPT", p), + ) + .context("Failed to insert port rule")?; + } - Ok(()) + Ok(()) } pub fn get_opened_ports(ipt: &iptables::IPTables) -> Result { - let mut ports = messages::PublicExposedPorts { - tcp_ports: HashSet::new(), - udp_ports: HashSet::new() - }; + let mut ports = messages::PublicExposedPorts { + tcp_ports: HashSet::new(), + udp_ports: HashSet::new(), + }; - let list = ipt.list("filter", "DIPLONAT")?; - let re = Regex::new(r"\-A.*? \-p (\w+).*\-\-dport (\d+).*?\-j ACCEPT").context("Regex matching open ports encountered an unexpected rule")?; - for i in list { - let caps = re.captures(&i); - match caps { - Some(c) => { - - if let (Some(raw_proto), Some(raw_port)) = (c.get(1), c.get(2)) { + let list = ipt.list("filter", "DIPLONAT")?; + let re = Regex::new(r"\-A.*? \-p (\w+).*\-\-dport (\d+).*?\-j ACCEPT") + .context("Regex matching open ports encountered an unexpected rule")?; + for i in list { + let caps = re.captures(&i); + match caps { + Some(c) => { + if let (Some(raw_proto), Some(raw_port)) = (c.get(1), c.get(2)) { + let proto = String::from(raw_proto.as_str()); + let number = String::from(raw_port.as_str()).parse::()?; - let proto = String::from(raw_proto.as_str()); - let number = String::from(raw_port.as_str()).parse::()?; - - if proto == "tcp" { - ports.tcp_ports.insert(number); - } else { - ports.udp_ports.insert(number); - } - - } else { - error!("Unexpected rule found in DIPLONAT chain") - } - - }, - _ => {} + if proto == "tcp" { + ports.tcp_ports.insert(number); + } else { + ports.udp_ports.insert(number); + } + } else { + error!("Unexpected rule found in DIPLONAT chain") } + } + _ => {} } + } - Ok(ports) + Ok(ports) } pub fn cleanup(ipt: &iptables::IPTables) -> Result<()> { - - if ipt.chain_exists("filter", "DIPLONAT")? { - ipt.flush_chain("filter", "DIPLONAT").context("Failed to flush the DIPLONAT chain")?; - - if ipt.exists("filter", "INPUT", "-j DIPLONAT")? { - ipt.delete("filter", "INPUT", "-j DIPLONAT").context("Failed to delete jump rule")?; - } - - ipt.delete_chain("filter", "DIPLONAT").context("Failed to delete chain")?; + if ipt.chain_exists("filter", "DIPLONAT")? { + ipt + .flush_chain("filter", "DIPLONAT") + .context("Failed to flush the DIPLONAT chain")?; + + if ipt.exists("filter", "INPUT", "-j DIPLONAT")? { + ipt + .delete("filter", "INPUT", "-j DIPLONAT") + .context("Failed to delete jump rule")?; } - Ok(()) -} + ipt + .delete_chain("filter", "DIPLONAT") + .context("Failed to delete chain")?; + } + Ok(()) +} diff --git a/src/fw_actor.rs b/src/fw_actor.rs index 29e6473..d41a97f 100644 --- a/src/fw_actor.rs +++ b/src/fw_actor.rs @@ -4,18 +4,15 @@ use anyhow::Result; use iptables; use log::*; use tokio::{ - select, - sync::watch, - time::{ - Duration, - self, -}}; + select, + sync::watch, + time::{self, Duration}, +}; use crate::config::RuntimeConfigFirewall; use crate::fw; use crate::messages; - pub struct FirewallActor { pub ipt: iptables::IPTables, @@ -26,13 +23,16 @@ pub struct FirewallActor { } impl FirewallActor { - pub async fn new(config: Option, rxp: &watch::Receiver) -> Result> { + pub async fn new( + config: Option, + rxp: &watch::Receiver, + ) -> Result> { if config.is_none() { return Ok(None); } let config = config.unwrap(); - let ctx = Self { + let ctx = Self { ipt: iptables::new(false)?, last_ports: messages::PublicExposedPorts::new(), refresh: config.refresh_time, @@ -40,7 +40,7 @@ impl FirewallActor { }; fw::setup(&ctx.ipt)?; - + return Ok(Some(ctx)); } @@ -55,7 +55,9 @@ impl FirewallActor { }; // 2. Update last ports if needed - if let Some(p) = new_ports { self.last_ports = p; } + if let Some(p) = new_ports { + self.last_ports = p; + } // 3. Update firewall rules match self.do_fw_update().await { @@ -68,18 +70,26 @@ impl FirewallActor { pub async fn do_fw_update(&self) -> Result<()> { let curr_opened_ports = fw::get_opened_ports(&self.ipt)?; - let diff_tcp = self.last_ports.tcp_ports.difference(&curr_opened_ports.tcp_ports).copied().collect::>(); - let diff_udp = self.last_ports.udp_ports.difference(&curr_opened_ports.udp_ports).copied().collect::>(); + let diff_tcp = self + .last_ports + .tcp_ports + .difference(&curr_opened_ports.tcp_ports) + .copied() + .collect::>(); + let diff_udp = self + .last_ports + .udp_ports + .difference(&curr_opened_ports.udp_ports) + .copied() + .collect::>(); let ports_to_open = messages::PublicExposedPorts { - tcp_ports: diff_tcp, - udp_ports: diff_udp + tcp_ports: diff_tcp, + udp_ports: diff_udp, }; fw::open_ports(&self.ipt, ports_to_open)?; return Ok(()); } - } - diff --git a/src/igd_actor.rs b/src/igd_actor.rs index 19a7e93..928bb04 100644 --- a/src/igd_actor.rs +++ b/src/igd_actor.rs @@ -1,16 +1,14 @@ use std::net::SocketAddrV4; -use anyhow::{Result, Context}; +use anyhow::{Context, Result}; use igd::aio::*; use igd::PortMappingProtocol; use log::*; use tokio::{ - select, - sync::watch, - time::{ - Duration, - self, -}}; + select, + sync::watch, + time::{self, Duration}, +}; use crate::config::RuntimeConfigIgd; use crate::messages; @@ -26,18 +24,21 @@ pub struct IgdActor { } impl IgdActor { - pub async fn new(config: Option, rxp: &watch::Receiver) -> Result> { + pub async fn new( + config: Option, + rxp: &watch::Receiver, + ) -> Result> { if config.is_none() { return Ok(None); } let config = config.unwrap(); let gw = search_gateway(Default::default()) - .await - .context("Failed to find IGD gateway")?; + .await + .context("Failed to find IGD gateway")?; info!("IGD gateway: {}", gw); - let ctx = Self { + let ctx = Self { expire: config.expiration_time, gateway: gw, last_ports: messages::PublicExposedPorts::new(), @@ -60,7 +61,9 @@ impl IgdActor { }; // 2. Update last ports if needed - if let Some(p) = new_ports { self.last_ports = p; } + if let Some(p) = new_ports { + self.last_ports = p; + } // 3. Flush IGD requests match self.do_igd().await { @@ -72,15 +75,26 @@ impl IgdActor { pub async fn do_igd(&self) -> Result<()> { let actions = [ - (PortMappingProtocol::TCP, &self.last_ports.tcp_ports), - (PortMappingProtocol::UDP, &self.last_ports.udp_ports) + (PortMappingProtocol::TCP, &self.last_ports.tcp_ports), + (PortMappingProtocol::UDP, &self.last_ports.udp_ports), ]; for (proto, list) in actions.iter() { for port in *list { let service_str = format!("{}:{}", self.private_ip, port); - let service = service_str.parse::().context("Invalid socket address")?; - self.gateway.add_port(*proto, *port, service, self.expire.as_secs() as u32, "diplonat").await?; + let service = service_str + .parse::() + .context("Invalid socket address")?; + self + .gateway + .add_port( + *proto, + *port, + service, + self.expire.as_secs() as u32, + "diplonat", + ) + .await?; debug!("IGD request successful for {:#?} {}", proto, service); } } diff --git a/src/main.rs b/src/main.rs index 720edf8..99d38f5 100644 --- a/src/main.rs +++ b/src/main.rs @@ -7,8 +7,8 @@ mod fw_actor; mod igd_actor; mod messages; -use log::*; use diplonat::Diplonat; +use log::*; #[tokio::main] async fn main() { diff --git a/src/messages.rs b/src/messages.rs index 09a7c14..63f16b0 100644 --- a/src/messages.rs +++ b/src/messages.rs @@ -3,14 +3,14 @@ use std::collections::HashSet; #[derive(Debug, Clone, PartialEq, Eq)] pub struct PublicExposedPorts { pub tcp_ports: HashSet, - pub udp_ports: HashSet + pub udp_ports: HashSet, } impl PublicExposedPorts { pub fn new() -> Self { return Self { tcp_ports: HashSet::new(), - udp_ports: HashSet::new() - } + udp_ports: HashSet::new(), + }; } }