feat: hot-reloading of config file

rpxy-bin/Cargo.toml

@@ -35,7 +35,7 @@ rustls-pemfile = "1.0.3"
 # config
 clap = { version = "4.3.17", features = ["std", "cargo", "wrap_help"] }
 toml = { version = "0.7.6", default-features = false, features = ["parse"] }
-# hot_reload = "0.1.2"
+hot_reload = "0.1.4"
 
 # logging
 tracing = { version = "0.1.37" }

rpxy-bin/src/config/mod.rs

@@ -1,4 +1,9 @@
 mod parse;
+mod service;
 mod toml;
 
-pub use parse::build_settings;
+pub use {
+  self::toml::ConfigToml,
+  parse::{build_settings, parse_opts},
+  service::ConfigTomlReloader,
+};

rpxy-bin/src/config/parse.rs

@@ -7,28 +7,30 @@ use crate::{
 use clap::Arg;
 use rpxy_lib::{AppConfig, AppConfigList, ProxyConfig};
 
-pub fn build_settings() -> std::result::Result<(ProxyConfig, AppConfigList<CryptoFileSource>), anyhow::Error> {
+pub fn parse_opts() -> Result<String, anyhow::Error> {
   let _ = include_str!("../../Cargo.toml");
   let options = clap::command!().arg(
     Arg::new("config_file")
       .long("config")
       .short('c')
       .value_name("FILE")
-      .help("Configuration file path like \"./config.toml\""),
+      .required(true)
+      .help("Configuration file path like ./config.toml"),
   );
   let matches = options.get_matches();
 
   ///////////////////////////////////
-  let config = if let Some(config_file_path) = matches.get_one::<String>("config_file") {
-    ConfigToml::new(config_file_path)?
-  } else {
-    // Default config Toml
-    ConfigToml::default()
-  };
+  let config_file_path = matches.get_one::<String>("config_file").unwrap();
 
+  Ok(config_file_path.to_string())
+}
+
+pub fn build_settings(
+  config: &ConfigToml,
+) -> std::result::Result<(ProxyConfig, AppConfigList<CryptoFileSource>), anyhow::Error> {
   ///////////////////////////////////
   // build proxy config
-  let proxy_config: ProxyConfig = (&config).try_into()?;
+  let proxy_config: ProxyConfig = config.try_into()?;
   // For loggings
   if proxy_config.listen_sockets.iter().any(|addr| addr.is_ipv6()) {
     info!("Listen both IPv4 and IPv6")
@@ -50,7 +52,7 @@ pub fn build_settings() -> std::result::Result<(ProxyConfig, AppConfigList<Crypt
 
   ///////////////////////////////////
   // backend_apps
-  let apps = config.apps.ok_or(anyhow!("Missing application spec"))?;
+  let apps = config.apps.clone().ok_or(anyhow!("Missing application spec"))?;
 
   // assertions for all backend apps
   ensure!(!apps.0.is_empty(), "Wrong application spec.");
@@ -88,9 +90,8 @@ pub fn build_settings() -> std::result::Result<(ProxyConfig, AppConfigList<Crypt
 
   let app_config_list = AppConfigList {
     inner: app_config_list_inner,
-    default_app: config.default_app.map(|v| v.to_ascii_lowercase()), // default backend application for plaintext http requests
+    default_app: config.default_app.clone().map(|v| v.to_ascii_lowercase()), // default backend application for plaintext http requests
   };
 
   Ok((proxy_config, app_config_list))
-  // todo!()
 }

rpxy-bin/src/config/service.rs

@@ -0,0 +1,24 @@
+use super::toml::ConfigToml;
+use async_trait::async_trait;
+use hot_reload::{Reload, ReloaderError};
+
+#[derive(Clone)]
+pub struct ConfigTomlReloader {
+  pub config_path: String,
+}
+
+#[async_trait]
+impl Reload<ConfigToml> for ConfigTomlReloader {
+  type Source = String;
+  async fn new(source: &Self::Source) -> Result<Self, ReloaderError<ConfigToml>> {
+    Ok(Self {
+      config_path: source.clone(),
+    })
+  }
+
+  async fn reload(&self) -> Result<Option<ConfigToml>, ReloaderError<ConfigToml>> {
+    let conf = ConfigToml::new(&self.config_path)
+      .map_err(|_e| ReloaderError::<ConfigToml>::Reload("Failed to reload config toml"))?;
+    Ok(Some(conf))
+  }
+}

rpxy-bin/src/config/toml.rs

@@ -8,11 +8,12 @@ use rustc_hash::FxHashMap as HashMap;
 use serde::Deserialize;
 use std::{fs, net::SocketAddr};
 
-#[derive(Deserialize, Debug, Default)]
+#[derive(Deserialize, Debug, Default, PartialEq, Eq, Clone)]
 pub struct ConfigToml {
   pub listen_port: Option<u16>,
   pub listen_port_tls: Option<u16>,
   pub listen_ipv6: Option<bool>,
+  pub tcp_listen_backlog: Option<u32>,
   pub max_concurrent_streams: Option<u32>,
   pub max_clients: Option<u32>,
   pub apps: Option<Apps>,
@@ -21,7 +22,7 @@ pub struct ConfigToml {
 }
 
 #[cfg(feature = "http3")]
-#[derive(Deserialize, Debug, Default)]
+#[derive(Deserialize, Debug, Default, PartialEq, Eq, Clone)]
 pub struct Http3Option {
   pub alt_svc_max_age: Option<u32>,
   pub request_max_body_size: Option<usize>,
@@ -31,24 +32,24 @@ pub struct Http3Option {
   pub max_idle_timeout: Option<u64>,
 }
 
-#[derive(Deserialize, Debug, Default)]
+#[derive(Deserialize, Debug, Default, PartialEq, Eq, Clone)]
 pub struct Experimental {
   #[cfg(feature = "http3")]
   pub h3: Option<Http3Option>,
   pub ignore_sni_consistency: Option<bool>,
 }
 
-#[derive(Deserialize, Debug, Default)]
+#[derive(Deserialize, Debug, Default, PartialEq, Eq, Clone)]
 pub struct Apps(pub HashMap<String, Application>);
 
-#[derive(Deserialize, Debug, Default)]
+#[derive(Deserialize, Debug, Default, PartialEq, Eq, Clone)]
 pub struct Application {
   pub server_name: Option<String>,
   pub reverse_proxy: Option<Vec<ReverseProxyOption>>,
   pub tls: Option<TlsOption>,
 }
 
-#[derive(Deserialize, Debug, Default)]
+#[derive(Deserialize, Debug, Default, PartialEq, Eq, Clone)]
 pub struct TlsOption {
   pub tls_cert_path: Option<String>,
   pub tls_cert_key_path: Option<String>,
@@ -56,7 +57,7 @@ pub struct TlsOption {
   pub client_ca_cert_path: Option<String>,
 }
 
-#[derive(Deserialize, Debug, Default)]
+#[derive(Deserialize, Debug, Default, PartialEq, Eq, Clone)]
 pub struct ReverseProxyOption {
   pub path: Option<String>,
   pub replace_path: Option<String>,
@@ -65,7 +66,7 @@ pub struct ReverseProxyOption {
   pub load_balance: Option<String>,
 }
 
-#[derive(Deserialize, Debug, Default)]
+#[derive(Deserialize, Debug, Default, PartialEq, Eq, Clone)]
 pub struct UpstreamParams {
   pub location: String,
   pub tls: Option<bool>,
@@ -112,6 +113,11 @@ impl TryInto<ProxyConfig> for &ConfigToml {
       })
       .collect();
 
+    // tcp backlog
+    if let Some(backlog) = self.tcp_listen_backlog {
+      proxy_config.tcp_listen_backlog = backlog;
+    }
+
     // max values
     if let Some(c) = self.max_clients {
       proxy_config.max_clients = c as usize;

rpxy-bin/src/constants.rs

@@ -1,2 +1,3 @@
 pub const LISTEN_ADDRESSES_V4: &[&str] = &["0.0.0.0"];
 pub const LISTEN_ADDRESSES_V6: &[&str] = &["[::]"];
+pub const CONFIG_WATCH_DELAY_SECS: u32 = 20;

rpxy-bin/src/main.rs

@@ -11,7 +11,12 @@ mod constants;
 mod error;
 mod log;
 
-use crate::{config::build_settings, log::*};
+use crate::{
+  config::{build_settings, parse_opts, ConfigToml, ConfigTomlReloader},
+  constants::CONFIG_WATCH_DELAY_SECS,
+  log::*,
+};
+use hot_reload::{ReloaderReceiver, ReloaderService};
 use rpxy_lib::entrypoint;
 
 fn main() {
@@ -23,17 +28,68 @@ fn main() {
   let runtime = runtime_builder.build().unwrap();
 
   runtime.block_on(async {
-    let (proxy_conf, app_conf) = match build_settings() {
-      Ok(g) => g,
-      Err(e) => {
-        error!("Invalid configuration: {}", e);
+    // Initially load config
+    let Ok(config_path) = parse_opts() else {
+        error!("Invalid toml file");
         std::process::exit(1);
-      }
     };
+    let (config_service, config_rx) =
+      ReloaderService::<ConfigTomlReloader, ConfigToml>::new(&config_path, CONFIG_WATCH_DELAY_SECS, false)
+        .await
+        .unwrap();
 
-    entrypoint(proxy_conf, app_conf, runtime.handle().clone())
-      .await
-      .unwrap()
+    tokio::select! {
+      _ = config_service.start() => {
+        error!("config reloader service exited");
+      }
+      _ = rpxy_service(config_rx, runtime.handle().clone()) => {
+        error!("rpxy service existed");
+      }
+    }
   });
-  warn!("rpxy exited!");
+}
+
+async fn rpxy_service(
+  mut config_rx: ReloaderReceiver<ConfigToml>,
+  runtime_handle: tokio::runtime::Handle,
+) -> Result<(), anyhow::Error> {
+  // Initial loading
+  config_rx.changed().await?;
+  let config_toml = config_rx.borrow().clone().unwrap();
+  let (mut proxy_conf, mut app_conf) = match build_settings(&config_toml) {
+    Ok(v) => v,
+    Err(e) => {
+      error!("Invalid configuration: {e}");
+      return Err(anyhow::anyhow!(e));
+    }
+  };
+
+  // Continuous monitoring
+  loop {
+    tokio::select! {
+      _ = entrypoint(&proxy_conf, &app_conf, &runtime_handle) => {
+        error!("rpxy entrypoint exited");
+        break;
+      }
+      _ = config_rx.changed() => {
+        if config_rx.borrow().is_none() {
+          error!("Something wrong in config reloader receiver");
+          break;
+        }
+        let config_toml = config_rx.borrow().clone().unwrap();
+        match build_settings(&config_toml) {
+          Ok((p, a)) => {
+            (proxy_conf, app_conf) = (p, a)
+          },
+          Err(e) => {
+            error!("Invalid configuration. Configuration does not updated: {e}");
+            continue;
+          }
+        };
+        info!("Configuration updated. Force to re-bind TCP/UDP sockets");
+      }
+      else => break
+    }
+  }
+  Ok(())
 }