Reload hostmap on sighup

pixie-server/Cargo.toml

@@ -18,7 +18,7 @@ postcard = { version = "1.0.8", default-features = false, features = ["alloc"] }
 serde = "1.0.193"
 serde_derive = "1.0.193"
 serde_yaml = "0.9"
-tokio = { version = "1.34.0", features = ["macros", "fs", "rt-multi-thread", "sync"] }
+tokio = { version = "1.34.0", features = ["macros", "fs", "rt-multi-thread", "sync", "signal"] }
 serde_json = "1.0.108"
 hostfile = "0.2.0"
 hex = "0.4.3"

pixie-server/src/dnsmasq.rs

@@ -1,4 +1,5 @@
 use std::{
+    collections::HashMap,
     fs::File,
     io::{BufWriter, Error, Write},
     net::Ipv4Addr,
@@ -99,23 +100,30 @@ async fn write_hosts(state: &State, hosts: &[(MacAddr6, Ipv4Addr, Option<String>
     Ok(())
 }
 
-fn get_hosts(state: &State, units: &[Unit]) -> Vec<(MacAddr6, Ipv4Addr, Option<String>)> {
+fn get_hosts(
+    hostmap: &HashMap<Ipv4Addr, String>,
+    units: &[Unit],
+) -> Vec<(MacAddr6, Ipv4Addr, Option<String>)> {
     units
         .iter()
         .map(|unit| {
             let mac = unit.mac;
             let ip = unit.static_ip();
-            let hostname = state.hostmap.get(&ip).cloned();
+            let hostname = hostmap.get(&ip).cloned();
             (mac, ip, hostname)
         })
         .collect()
 }
 
 pub async fn main(state: Arc<State>) -> Result<()> {
     let mut units_rx = state.units.subscribe();
+    let mut hostmap_rx = state.hostmap.subscribe();
 
     write_config(&state).await?;
-    let mut hosts = get_hosts(&state, &units_rx.borrow_and_update());
+    let mut hosts = get_hosts(
+        &hostmap_rx.borrow_and_update(),
+        &units_rx.borrow_and_update(),
+    );
     write_hosts(&state, &hosts).await?;
 
     let dnsmasq = DnsmasqHandle {
@@ -132,14 +140,18 @@ pub async fn main(state: Arc<State>) -> Result<()> {
 
     loop {
         tokio::select! {
-            _ = units_rx.changed() => {
-                let hosts2 = get_hosts(&state, &units_rx.borrow_and_update());
-                if hosts != hosts2 {
-                    hosts = hosts2;
-                    write_hosts(&state, &hosts).await?;
-                    dnsmasq.reload()?;
-                }
-            }
+            ret = units_rx.changed() => ret.unwrap(),
+            ret = hostmap_rx.changed() => ret.unwrap(),
+        }
+
+        let hosts2 = get_hosts(
+            &hostmap_rx.borrow_and_update(),
+            &units_rx.borrow_and_update(),
+        );
+        if hosts != hosts2 {
+            hosts = hosts2;
+            write_hosts(&state, &hosts).await?;
+            dnsmasq.reload()?;
         }
     }
 }

pixie-server/src/http.rs

@@ -161,23 +161,19 @@ async fn gc(extract::State(state): extract::State<Arc<State>>) -> impl IntoRespo
 }
 
 async fn status(extract::State(state): extract::State<Arc<State>>) -> impl IntoResponse {
-    let initial_messages = vec![
-        StatusUpdate::Config(state.config.clone()),
-        StatusUpdate::HostMap(state.hostmap.clone()),
-    ];
-    let mut units_rx = state.units.subscribe();
-    units_rx.mark_changed();
-    let units_rx = WatchStream::new(units_rx);
-
-    let mut image_rx = state.image_stats.subscribe();
-    image_rx.mark_changed();
-    let image_rx = WatchStream::new(image_rx);
-
-    let messages =
-        futures::stream::iter(initial_messages.into_iter()).chain(futures::stream::select(
+    let initial_messages = [StatusUpdate::Config(state.config.clone())];
+
+    let units_rx = WatchStream::new(state.units.subscribe());
+    let image_rx = WatchStream::new(state.image_stats.subscribe());
+    let hostmap_rx = WatchStream::new(state.hostmap.subscribe());
+
+    let messages = futures::stream::iter(initial_messages).chain(futures::stream::select(
+        futures::stream::select(
             image_rx.map(StatusUpdate::ImageStats),
             units_rx.map(StatusUpdate::Units),
-        ));
+        ),
+        hostmap_rx.map(StatusUpdate::HostMap),
+    ));
     let lines = messages.map(|msg| serde_json::to_string(&msg).map(|x| x + "\n"));
 
     let mut res = Response::new(Body::from_stream(lines));

pixie-server/src/main.rs

@@ -127,6 +127,15 @@ async fn main() -> Result<()> {
 
     let state = Arc::new(State::load(options.storage_dir)?);
 
+    let state2 = state.clone();
+    tokio::spawn(async move {
+        let mut signal = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::hangup())
+            .expect("failed to register signal handler");
+        while let Some(()) = signal.recv().await {
+            state2.reload().unwrap();
+        }
+    });
+
     async fn flatten(task: JoinHandle<Result<()>>) -> Result<()> {
         task.await??;
         Ok(())

pixie-server/src/state.rs

@@ -35,7 +35,7 @@ fn get_image_csize(image: &Image) -> u64 {
 pub struct State {
     pub storage_dir: PathBuf,
     pub config: Config,
-    pub hostmap: HashMap<Ipv4Addr, String>,
+    pub hostmap: watch::Sender<HashMap<Ipv4Addr, String>>,
 
     pub units: watch::Sender<Vec<Unit>>,
     // TODO: use an Option
@@ -64,6 +64,7 @@ impl State {
                 }
             }
         }
+        let hostmap = watch::Sender::new(hostmap);
 
         let units_path = storage_dir.join("registered.json");
         let units = watch::Sender::new({
@@ -152,6 +153,21 @@ impl State {
         })
     }
 
+    pub fn reload(&self) -> Result<()> {
+        let mut hostmap = HashMap::new();
+        if let Some(hostsfile) = &self.config.hosts.hostsfile {
+            let hosts = hostfile::parse_file(hostsfile)
+                .map_err(|e| anyhow!("Error parsing host file: {e}"))?;
+            for host in hosts {
+                if let IpAddr::V4(ip) = host.ip {
+                    hostmap.insert(ip, host.names[0].clone());
+                }
+            }
+        }
+        self.hostmap.send_replace(hostmap);
+        Ok(())
+    }
+
     pub fn gc_chunks(&self) -> Result<()> {
         self.image_stats.send_modify(|image_stats| {
             let mut chunk_stats = self.chunk_stats.lock().unwrap();

pixie.service

@@ -9,6 +9,7 @@ Group=root
 ExecStart=/usr/local/bin/pixie-server -s /var/local/lib/pixie
 Environment=RUST_LOG=info
 WorkingDirectory=/var/local/lib/pixie
+ExecReload=kill -HUP $MAINPID
 
 [Install]
 WantedBy=multi-user.target