Remove pratial support for hot reload.

Since most operations easily recover from a server restart hot reload is
not actually needed, also it is only partially supported so it is almost
never used.
Hot reload also increase code complexity, thus we are removing it.

Author: Virv12

pixie-server/src/dnsmasq.rs

@@ -114,13 +114,9 @@ fn get_hosts(
 
 pub async fn main(state: Arc<State>) -> Result<()> {
     let mut units_rx = state.subscribe_units();
-    let mut hostmap_rx = state.subscribe_hostmap();
 
     write_config(&state).await?;
-    let mut hosts = get_hosts(
-        &hostmap_rx.borrow_and_update(),
-        &units_rx.borrow_and_update(),
-    );
+    let mut hosts = get_hosts(&state.hostmap, &units_rx.borrow_and_update());
     write_hosts(&state, &hosts).await?;
 
     let dnsmasq = DnsmasqHandle {
@@ -138,14 +134,10 @@ pub async fn main(state: Arc<State>) -> Result<()> {
     loop {
         tokio::select! {
             ret = units_rx.changed() => ret.unwrap(),
-            ret = hostmap_rx.changed() => ret.unwrap(),
             _ = state.cancel_token.cancelled() => break,
         }
 
-        let hosts2 = get_hosts(
-            &hostmap_rx.borrow_and_update(),
-            &units_rx.borrow_and_update(),
-        );
+        let hosts2 = get_hosts(&state.hostmap, &units_rx.borrow_and_update());
         if hosts != hosts2 {
             hosts = hosts2;
             write_hosts(&state, &hosts).await?;

pixie-server/src/http.rs

@@ -156,19 +156,18 @@ async fn gc(extract::State(state): extract::State<Arc<State>>) -> impl IntoRespo
 ///
 /// Stream of json-formatted events on changes to the database.
 async fn status(extract::State(state): extract::State<Arc<State>>) -> impl IntoResponse {
-    let initial_messages = [StatusUpdate::Config(state.config.clone())];
+    let initial_messages = [
+        StatusUpdate::Config(state.config.clone()),
+        StatusUpdate::HostMap(state.hostmap.clone()),
+    ];
 
     let units_rx = WatchStream::new(state.subscribe_units());
     let image_rx = WatchStream::new(state.subscribe_images());
-    let hostmap_rx = WatchStream::new(state.subscribe_hostmap());
 
     let messages = futures::stream::iter(initial_messages)
         .chain(futures::stream::select(
-            futures::stream::select(
-                image_rx.map(StatusUpdate::ImagesStats),
-                units_rx.map(StatusUpdate::Units),
-            ),
-            hostmap_rx.map(StatusUpdate::HostMap),
+            image_rx.map(StatusUpdate::ImagesStats),
+            units_rx.map(StatusUpdate::Units),
         ))
         .take_until(state.cancel_token.clone().cancelled_owned());
     let lines = messages.map(|msg| serde_json::to_string(&msg).map(|x| x + "\n"));

pixie-server/src/main.rs

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

pixie-server/src/state/mod.rs

@@ -94,7 +94,7 @@ pub struct State {
     /// The config parsed from the config file.
     pub config: Config,
     /// The hostmap built from the hostmap file.
-    hostmap: watch::Sender<HashMap<Ipv4Addr, String>>,
+    pub hostmap: HashMap<Ipv4Addr, String>,
 
     units: watch::Sender<Vec<Unit>>,
     registration_hint: Mutex<Option<RegistrationInfo>>,
@@ -216,24 +216,14 @@ impl State {
             storage_dir,
             run_dir,
             config,
-            hostmap: watch::Sender::new(hostmap),
+            hostmap,
             units,
             registration_hint: Mutex::new(None),
             images_stats: watch::Sender::new(images_stats),
             chunks_stats: Mutex::new(chunks_stats),
             cancel_token,
         })
     }
-
-    pub fn reload(&self) -> Result<()> {
-        let hostmap = build_hostmap(self.config.hosts.hostsfile.as_deref())?;
-        self.hostmap.send_replace(hostmap);
-        Ok(())
-    }
-
-    pub fn subscribe_hostmap(&self) -> watch::Receiver<HashMap<Ipv4Addr, String>> {
-        self.hostmap.subscribe()
-    }
 }
 
 impl Drop for State {

pixie.service

@@ -10,11 +10,9 @@ 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
 Restart=always
 RestartSec=30
 LimitNOFILE=65536
 
-
 [Install]
 WantedBy=multi-user.target