add: multiple fixes, docs for deployment

src/main.rs

@@ -1,4 +1,5 @@
 use std::sync::Mutex;
+use std::process::Command;
 
 use clap::Parser;
 
@@ -28,7 +29,7 @@ struct Args {
     /// and instead N lines (one per replacement) is added to
     /// the output.
     #[arg(short, long)]
-    rewrite_string: String,
+    needle: String,
 
     /// The folder which contains the templates that
     /// will be be searched for the needle.
@@ -45,8 +46,13 @@ struct Args {
     #[arg(short, long)]
     workspace_dir: String,
 
+    /// Address to listen for http requests on.
     #[arg(short, long, default_value_t = String::from("0.0.0.0:8080"))]
     listen: String,
+
+    /// Command to reload nginx.
+    #[arg(short, long, default_value_t = String::from("sudo nginx -s reload"))]
+    reload_cmd: String,
 }
 
 fn main() {
@@ -54,13 +60,32 @@ fn main() {
     env_logger::Builder::from_env(Env::default().default_filter_or("info")).init();
     let args = Args::parse();
 
-    let rewriter = Rewriter::new(args.rewrite_string);
+    let rewriter = Rewriter::new(args.needle);
     let server_impl = Mutex::new(Server::new(rewriter, args.workspace_dir, args.template_dir, args.config_symlink));
+    let reload_command = args.reload_cmd.leak();
+    let reload_command: Vec<&str> = reload_command.split_ascii_whitespace().collect();
 
     rouille::start_server(args.listen, move |request| {
         info!("Processing request: {:?}", request);
         match handle(request, &server_impl) {
-            Ok(resp) => resp,
+            Ok((resp, reload)) => {
+                if reload && reload_command.len() > 0 {
+                    let output = Command::new(reload_command[0])
+                        .args(&reload_command[1..])
+                        .output();
+                    match output {
+                        Ok(o) => {
+                            info!("Ran {:?}; exit code: {}", reload_command, o.status);
+                            info!("Ran {:?}; stdout: {}", reload_command, String::from_utf8_lossy(&o.stdout));
+                            info!("Ran {:?}; stderr: {}", reload_command, String::from_utf8_lossy(&o.stderr));
+                        },
+                        Err(e) => {
+                            warn!("Failed to run {:?}: {:?}", reload_command, e);
+                        }
+                    };
+                }
+                resp
+            },
             Err(e) => {
                 warn!("{:?}", e);
                 Response{status_code: 500, ..Response::empty_400()}
@@ -69,16 +94,16 @@ fn main() {
     });
 }
 
-fn handle(request: &Request, server_impl: &Mutex<Server>) -> Result<Response> {
+fn handle(request: &Request, server_impl: &Mutex<Server>) -> Result<(Response, bool)> {
     router!(request,
-        (POST) (/register) => {
-            server_impl.lock().unwrap().register(request)?;
-            Ok(Response{status_code: 200, ..Response::empty_204()})
+        (POST) (/register/{ip: String}) => {
+            server_impl.lock().unwrap().register(request, &ip)?;
+            Ok((Response{status_code: 200, ..Response::empty_204()}, true))
         },
-        (DELETE) (/register) => {
-            server_impl.lock().unwrap().unregister(request)?;
-            Ok(Response{status_code: 200, ..Response::empty_204()})
+        (DELETE) (/register/{ip: String}) => {
+            server_impl.lock().unwrap().unregister(request, &ip)?;
+            Ok((Response{status_code: 200, ..Response::empty_204()}, true))
         },
-        _ => Ok(Response::empty_404()),
+        _ => Ok((Response::empty_404(), false)),
     )
 }