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)),
     )
 }

src/rewriter.rs

@@ -58,23 +58,34 @@ impl Rewriter {
                 // Open 2 files; one to read and translate, and one to write.
                 let source_file = File::open(&src_path)?;
                 let mut dest_file = File::create(&dst_path)?;
-                let reader = BufReader::new(source_file);
+                let mut buff = Vec::with_capacity(2048);
+                let mut reader = BufReader::new(source_file);
 
-                for line in reader.lines() {
-                    let line = line?;
+                while let Ok(count) = reader.read_until(b'\n', &mut buff) {
+                    if count == 0 {
+                        break;
+                    }
                     // If the line is not subject to replacement, copy it and
                     // carry on.
-                    if !line.contains(&self.source) {
-                        writeln!(dest_file, "{}", line)?;
+                    let line = &buff[0..count];
+                    let m = contains(&self.source.as_bytes(), line);
+                    if m.is_none() {
+                        dest_file.write(&line)?;
+                        buff.clear();
                         continue;
                     }
+                    let m = m.unwrap();
+                    let start = &line[0..m.0];
+                    let end = &line[m.1..];
 
                     // Else, repeat the line multiple times, replacing the string
                     // in question
                     for replacement in &replacements {
-                        let new_line = line.replace(&self.source, &replacement);
-                        writeln!(dest_file, "{}", new_line)?;
+                        dest_file.write(start)?;
+                        dest_file.write(replacement.as_bytes())?;
+                        dest_file.write(end)?;
                     }
+                    buff.clear();
                 }
             }
         }
@@ -82,6 +93,21 @@ impl Rewriter {
     }
 }
 
+fn contains(needle: &[u8], haystack: &[u8]) -> Option<(usize, usize)> {
+    let mut i = 0;
+    while i + needle.len() <= haystack.len() {
+        let mut j = 0;
+        while i+j < haystack.len() && j < needle.len() && haystack[i+j] == needle[j] {
+            j += 1;
+        }
+        if j == needle.len() {
+            return Some((i, i+j));
+        }
+        i += 1;
+    }
+    None
+}
+
 #[cfg(test)]
 mod tests {
     use include_directory::{Dir, include_directory};

src/server.rs

@@ -27,18 +27,16 @@ impl Server {
         }
     }
 
-    pub fn register(&mut self, request: &Request) -> Result<()> {
-        let ip = request.remote_addr().ip().to_string();
+    pub fn register(&mut self, _request: &Request, ip: &str) -> Result<()> {
         info!("Registering {} as a handler", ip);
-        self.rewriter.add_replacement(ip);
+        self.rewriter.add_replacement(ip.to_string());
         self.generate_config()?;
         Ok(())
     }
 
-    pub fn unregister(&mut self, request: &Request) -> Result<()> {
-        let ip = request.remote_addr().ip().to_string();
+    pub fn unregister(&mut self, _request: &Request, ip: &str) -> Result<()> {
         info!("Deregistering {} as a handler", ip);
-        self.rewriter.remove_replacement(&ip);
+        self.rewriter.remove_replacement(ip);
         self.generate_config()?;
         Ok(())
     }

src/testdata/testsrc/hello.txt

@@ -1,4 +1,4 @@
 This is a line
 This is to_be_replaced line
 
-This is another line
+This is another line

src/testdata/testsrc/recursive/world.txt

@@ -1,3 +1,3 @@
 This is a to_be_replaced line.
 
-In a nested directory.
+In a nested directory.