fix: only refresh when there is a change

Cargo.toml

@@ -11,6 +11,5 @@ dir-diff = "0.3.3"
 env_logger = "0.11.7"
 include_directory = "0.1.1"
 log = "0.4.27"
-reqwest = { version = "0.12.23", features = ["blocking"] }
 rouille = "3.6.2"
 tempdir = "0.3.7"

src/bin/handler.rs

@@ -1,43 +0,0 @@
-use std::thread::sleep;
-use std::time::Duration;
-
-use clap::Parser;
-
-use log::{error, info};
-
-use anyhow::Result;
-use env_logger::Env;
-
-/// Implements a client that constantly refreshes with the server.
-#[derive(Parser, Debug)]
-#[command(version, about, long_about = None)]
-struct Args {
-    /// The skubelb server we should register with
-    #[arg(short, long)]
-    server: String,
-
-    /// The listen address that should be sent to skubelb.
-    #[arg(short, long)]
-    listen: String,
-}
-
-fn main() {
-    // Log info and above by default
-    env_logger::Builder::from_env(Env::default().default_filter_or("info")).init();
-    let args = Args::parse();
-
-    match handle(&args.server, &args.listen) {
-        Ok(_) => (),
-        Err(e) => error!("{}", e),
-    }
-}
-
-fn handle(remote: &str, listen: &str) -> Result<()> {
-    let client = reqwest::blocking::Client::new();
-    let url = format!("http://{}/register/{}", remote, listen);
-    loop {
-        sleep(Duration::from_secs(20));
-        info!("sending post to {}", url);
-        client.post(&url).send()?;
-    }
-}

src/main.rs

@@ -135,14 +135,14 @@ fn handle(request: &Request, server_impl: &Mutex<Server>) -> Result<(Response, b
         (POST) (/register/{ip: String}) => {
             let mut server_impl = server_impl.lock().map_err(|_| anyhow!("failed to acquire lock"))?;
             server_impl.register(request, &ip)?;
-            server_impl.cleanup()?;
+            let must_reload = server_impl.cleanup()?;
-            Ok((Response{status_code: 200, ..Response::empty_204()}, true))
+            Ok((Response{status_code: 200, ..Response::empty_204()}, must_reload))
         },
         (DELETE) (/register/{ip: String}) => {
             let mut server_impl = server_impl.lock().map_err(|_| anyhow!("failed to acquire lock"))?;
             server_impl.unregister(request, &ip)?;
-            server_impl.cleanup()?;
+            let must_reload = server_impl.cleanup()?;
-            Ok((Response{status_code: 200, ..Response::empty_204()}, true))
+            Ok((Response{status_code: 200, ..Response::empty_204()}, must_reload))
         },
         _ => Ok((Response::empty_404(), false)),
     )

src/rewriter.rs

@@ -23,14 +23,14 @@ impl Rewriter {
         }
     }
 
-    pub fn add_replacement(&mut self, replacement: String, cleanup: Instant) {
+    pub fn add_replacement(&mut self, replacement: String, cleanup: Instant) -> bool {
-        self.replacements.insert(replacement.clone());
+        self.replacement_cleanup.insert(replacement.clone(), cleanup);
-        self.replacement_cleanup.insert(replacement, cleanup);
+        self.replacements.insert(replacement)
     }
 
-    pub fn remove_replacement(&mut self, replacement: &str) {
+    pub fn remove_replacement(&mut self, replacement: &str) -> bool {
-        self.replacements.remove(replacement);
         self.replacement_cleanup.remove(replacement);
+        self.replacements.remove(replacement)
     }
 
     pub fn rewrite_folder(&self, src: &str, dst: &str) -> Result<()> {

src/server.rs

@@ -4,7 +4,7 @@ use std::{
     time::{Duration, Instant},
 };
 
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result, anyhow};
 use chrono::Utc;
 use log::info;
 use rouille::Request;
@@ -47,17 +47,19 @@ impl Server {
     pub fn register(&mut self, _request: &Request, ip: &str) -> Result<()> {
         info!("Registering {} as a handler", ip);
         let cleanup_time = Instant::now()
-            .checked_add(Duration::from_secs(60 * 5))
+            .checked_add(Duration::from_secs(60))
             .ok_or(anyhow!("failed to convert time"))?;
-        self.rewriter.add_replacement(ip.to_string(), cleanup_time);
+        if self.rewriter.add_replacement(ip.to_string(), cleanup_time) {
-        self.generate_config()?;
+            self.generate_config()?;
+        }
         Ok(())
     }
 
     pub fn unregister(&mut self, _request: &Request, ip: &str) -> Result<()> {
         info!("Deregistering {} as a handler", ip);
-        self.rewriter.remove_replacement(ip);
+        if self.rewriter.remove_replacement(ip) {
-        self.generate_config()?;
+            self.generate_config()?;
+        }
         Ok(())
     }