network: implement proper backend destruction

network/src/lib.rs

@@ -1,10 +1,10 @@
-use std::time::Duration;
+use std::{collections::HashMap, time::Duration};
 
 use anyhow::Result;
 use autonet::{AutoNetworkChangeset, AutoNetworkCollector, NetworkMetadata};
 use futures::{future::join_all, TryFutureExt};
 use log::warn;
-use tokio::time::sleep;
+use tokio::{task::JoinHandle, time::sleep};
 use uuid::Uuid;
 use vbridge::VirtualBridge;
 
@@ -21,12 +21,14 @@ pub mod raw_socket;
 pub mod vbridge;
 
 pub struct NetworkService {
+    pub backends: HashMap<Uuid, JoinHandle<()>>,
     pub bridge: VirtualBridge,
 }
 
 impl NetworkService {
     pub fn new() -> Result<NetworkService> {
         Ok(NetworkService {
+            backends: HashMap::new(),
             bridge: VirtualBridge::new()?,
         })
     }
@@ -47,30 +49,47 @@ impl NetworkService {
         collector: &mut AutoNetworkCollector,
         changeset: AutoNetworkChangeset,
     ) -> Result<()> {
+        for removal in &changeset.removed {
+            if let Some(handle) = self.backends.remove(&removal.uuid) {
+                handle.abort();
+            }
+        }
+
         let futures = changeset
             .added
             .iter()
             .map(|metadata| {
-                self.add_network_backend(metadata.clone())
+                self.add_network_backend(metadata)
                     .map_err(|x| (metadata.clone(), x))
             })
             .collect::<Vec<_>>();
 
-        let failed = futures::executor::block_on(async move {
+        let (launched, failed) = futures::executor::block_on(async move {
             let mut failed: Vec<Uuid> = Vec::new();
+            let mut launched: Vec<(Uuid, JoinHandle<()>)> = Vec::new();
             let results = join_all(futures).await;
             for result in results {
-                if let Err((metadata, error)) = result {
-                    warn!(
-                        "failed to launch network backend for hypha guest {}: {}",
-                        metadata.uuid, error
-                    );
-                    failed.push(metadata.uuid);
-                }
+                match result {
+                    Ok(launch) => {
+                        launched.push(launch);
+                    }
+
+                    Err((metadata, error)) => {
+                        warn!(
+                            "failed to launch network backend for hypha guest {}: {}",
+                            metadata.uuid, error
+                        );
+                        failed.push(metadata.uuid);
+                    }
+                };
             }
-            failed
+            (launched, failed)
         });
 
+        for (uuid, handle) in launched {
+            self.backends.insert(uuid, handle);
+        }
+
         for uuid in failed {
             collector.mark_unknown(uuid)?;
         }
@@ -78,10 +97,12 @@ impl NetworkService {
         Ok(())
     }
 
-    async fn add_network_backend(&self, metadata: NetworkMetadata) -> Result<()> {
-        let mut network = NetworkBackend::new(metadata, self.bridge.clone())?;
+    async fn add_network_backend(
+        &self,
+        metadata: &NetworkMetadata,
+    ) -> Result<(Uuid, JoinHandle<()>)> {
+        let mut network = NetworkBackend::new(metadata.clone(), self.bridge.clone())?;
         network.init().await?;
-        network.launch().await?;
-        Ok(())
+        Ok((metadata.uuid, network.launch().await?))
     }
 }