add: utility to constantly refresh skubelb

Cargo.toml

@@ -11,5 +11,6 @@ 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"

Dockerfile

@@ -1,12 +0,0 @@
-# Build Stage
-FROM rust:latest AS builder
-WORKDIR /app
-COPY . .
-RUN cargo build --release
-
-# Runtime Stage
-FROM debian:stable-slim
-WORKDIR /app
-COPY --from=builder /app/target/release/handler .
-COPY --from=builder /app/target/release/skubelb .
-CMD ["./handler"]

Makefile

@@ -1,16 +0,0 @@
-MAJOR_VERSION = 0
-MINOR_VERSION = 0
-PATH_VERSION = 1
-
-TAG = $(MAJOR_VERSION).$(MINOR_VERSION).$(PATH_VERSION)
-
-build:
-	docker build . -t skubelb-handler:$(TAG)
-	docker tag skubelb-handler:$(TAG) us-west4-docker.pkg.dev/nixernetes/images/skubelb-handler:$(TAG)
-
-kube:
-	cat kubernetes.yaml.tmpl | sed 's/TAG/$(TAG)/' > kubernetes.yaml
-
-deploy: build kube
-	docker push us-west4-docker.pkg.dev/nixernetes/images/skubelb-handler:$(TAG)
-	kubectl apply -f kubernetes.yaml

kubernetes.yaml

@@ -1,41 +0,0 @@
-apiVersion: apps/v1
-kind: DaemonSet
-metadata:
-  name: skubelb
-  namespace: skubelb
-  labels:
-    k8s-app: skubelb
-spec:
-  selector:
-    matchLabels:
-      name: skubelb
-  template:
-    metadata:
-      labels:
-        name: skubelb
-    spec:
-      tolerations:
-      # these tolerations are to have the daemonset runnable on control plane nodes
-      # remove them if your control plane nodes should not run pods
-      - key: node-role.kubernetes.io/control-plane
-        operator: Exists
-        effect: NoSchedule
-      - key: node-role.kubernetes.io/master
-        operator: Exists
-        effect: NoSchedule
-      containers:
-      - name: skubelb
-        image: us-west4-docker.pkg.dev/nixernetes/images/skubelb-handler:0.0.1
-        env:
-        - name: NODE_IP
-          valueFrom:
-            fieldRef:
-              fieldPath: status.hostIP
-        command: ["sh", "-c", "./handler -s 10.128.0.2:8888 -l ${NODE_IP}"]
-        resources:
-          limits:
-            memory: 200Mi
-          requests:
-            cpu: 10m
-            memory: 100Mi
-      terminationGracePeriodSeconds: 30

kubernetes.yaml.tmpl

@@ -1,41 +0,0 @@
-apiVersion: apps/v1
-kind: DaemonSet
-metadata:
-  name: skubelb
-  namespace: skubelb
-  labels:
-    k8s-app: skubelb
-spec:
-  selector:
-    matchLabels:
-      name: skubelb
-  template:
-    metadata:
-      labels:
-        name: skubelb
-    spec:
-      tolerations:
-      # these tolerations are to have the daemonset runnable on control plane nodes
-      # remove them if your control plane nodes should not run pods
-      - key: node-role.kubernetes.io/control-plane
-        operator: Exists
-        effect: NoSchedule
-      - key: node-role.kubernetes.io/master
-        operator: Exists
-        effect: NoSchedule
-      containers:
-      - name: skubelb
-        image: us-west4-docker.pkg.dev/nixernetes/images/skubelb-handler:TAG
-        env:
-        - name: NODE_IP
-          valueFrom:
-            fieldRef:
-              fieldPath: status.hostIP
-        command: ["sh", "-c", "./handler -s 10.128.0.2:8888 -l ${NODE_IP}"]
-        resources:
-          limits:
-            memory: 200Mi
-          requests:
-            cpu: 10m
-            memory: 100Mi
-      terminationGracePeriodSeconds: 30

src/bin/handler.rs

@@ -0,0 +1,42 @@
+use std::thread::sleep;
+use std::time::Duration;
+
+use clap::Parser;
+
+use log::error;
+
+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));
+        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)?;
-            let must_reload = server_impl.cleanup()?;
-            Ok((Response{status_code: 200, ..Response::empty_204()}, must_reload))
+            server_impl.cleanup()?;
+            Ok((Response{status_code: 200, ..Response::empty_204()}, true))
         },
         (DELETE) (/register/{ip: String}) => {
             let mut server_impl = server_impl.lock().map_err(|_| anyhow!("failed to acquire lock"))?;
             server_impl.unregister(request, &ip)?;
-            let must_reload = server_impl.cleanup()?;
-            Ok((Response{status_code: 200, ..Response::empty_204()}, must_reload))
+            server_impl.cleanup()?;
+            Ok((Response{status_code: 200, ..Response::empty_204()}, true))
         },
         _ => Ok((Response::empty_404(), false)),
     )

src/rewriter.rs

@@ -23,14 +23,14 @@ impl Rewriter {
         }
     }
 
-    pub fn add_replacement(&mut self, replacement: String, cleanup: Instant) -> bool {
-        self.replacement_cleanup.insert(replacement.clone(), cleanup);
-        self.replacements.insert(replacement)
+    pub fn add_replacement(&mut self, replacement: String, cleanup: Instant) {
+        self.replacements.insert(replacement.clone());
+        self.replacement_cleanup.insert(replacement, cleanup);
     }
 
-    pub fn remove_replacement(&mut self, replacement: &str) -> bool {
+    pub fn remove_replacement(&mut self, replacement: &str) {
+        self.replacements.remove(replacement);
         self.replacement_cleanup.remove(replacement);
-        self.replacements.remove(replacement)
     }
 
     pub fn rewrite_folder(&self, src: &str, dst: &str) -> Result<()> {
@@ -98,7 +98,7 @@ impl Rewriter {
         Ok(())
     }
 
-    pub fn cleanup(&mut self) -> bool {
+    pub fn cleanup(&mut self) {
         let now = Instant::now();
         let mut to_remove = vec![];
         for (name, when) in self.replacement_cleanup.iter() {
@@ -106,11 +106,10 @@ impl Rewriter {
                 to_remove.push(name.clone());
             }
         }
-        let will_cleanup = to_remove.len() > 0;
+
         for name in to_remove {
             self.remove_replacement(&name);
         }
-        will_cleanup
     }
 }
 

src/server.rs

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