feature(krata): rework api and make ip assignment persistent to database

crates/runtime/src/launch.rs

@@ -1,19 +1,21 @@
 use std::collections::HashMap;
 use std::fs;
-use std::net::IpAddr;
 use std::path::PathBuf;
 use std::sync::Arc;
 
 use advmac::MacAddr6;
 use anyhow::{anyhow, Result};
-use ipnetwork::IpNetwork;
+use tokio::sync::Semaphore;
+use uuid::Uuid;
+
 use krata::launchcfg::{
     LaunchInfo, LaunchNetwork, LaunchNetworkIpv4, LaunchNetworkIpv6, LaunchNetworkResolver,
     LaunchPackedFormat, LaunchRoot,
 };
 use krataoci::packer::OciPackedImage;
-use tokio::sync::Semaphore;
-use uuid::Uuid;
+pub use xenclient::{
+    pci::PciBdf, DomainPciDevice as PciDevice, DomainPciRdmReservePolicy as PciRdmReservePolicy,
+};
 use xenclient::{DomainChannel, DomainConfig, DomainDisk, DomainNetworkInterface};
 use xenplatform::domain::BaseDomainConfig;
 
@@ -22,10 +24,6 @@ use crate::RuntimeContext;
 
 use super::{ZoneInfo, ZoneState};
 
-pub use xenclient::{
-    pci::PciBdf, DomainPciDevice as PciDevice, DomainPciRdmReservePolicy as PciRdmReservePolicy,
-};
-
 pub struct ZoneLaunchRequest {
     pub format: LaunchPackedFormat,
     pub kernel: Vec<u8>,
@@ -40,6 +38,17 @@ pub struct ZoneLaunchRequest {
     pub debug: bool,
     pub image: OciPackedImage,
     pub addons_image: Option<PathBuf>,
+    pub network: ZoneLaunchNetwork,
+}
+
+pub struct ZoneLaunchNetwork {
+    pub ipv4: String,
+    pub ipv4_prefix: u8,
+    pub ipv6: String,
+    pub ipv6_prefix: u8,
+    pub gateway_ipv4: String,
+    pub gateway_ipv6: String,
+    pub zone_mac: MacAddr6,
 }
 
 pub struct ZoneLauncher {
@@ -58,15 +67,7 @@ impl ZoneLauncher {
     ) -> Result<ZoneInfo> {
         let uuid = request.uuid.unwrap_or_else(Uuid::new_v4);
         let xen_name = format!("krata-{uuid}");
-        let mut gateway_mac = MacAddr6::random();
-        gateway_mac.set_local(true);
-        gateway_mac.set_multicast(false);
-        let mut zone_mac = MacAddr6::random();
-        zone_mac.set_local(true);
-        zone_mac.set_multicast(false);
-
         let _launch_permit = self.launch_semaphore.acquire().await?;
-        let mut ip = context.ipvendor.assign(uuid).await?;
         let launch_config = LaunchInfo {
             root: LaunchRoot {
                 format: request.format.clone(),
@@ -81,12 +82,12 @@ impl ZoneLauncher {
             network: Some(LaunchNetwork {
                 link: "eth0".to_string(),
                 ipv4: LaunchNetworkIpv4 {
-                    address: format!("{}/{}", ip.ipv4, ip.ipv4_prefix),
-                    gateway: ip.gateway_ipv4.to_string(),
+                    address: format!("{}/{}", request.network.ipv4, request.network.ipv4_prefix),
+                    gateway: request.network.gateway_ipv4,
                 },
                 ipv6: LaunchNetworkIpv6 {
-                    address: format!("{}/{}", ip.ipv6, ip.ipv6_prefix),
-                    gateway: ip.gateway_ipv6.to_string(),
+                    address: format!("{}/{}", request.network.ipv6, request.network.ipv6_prefix),
+                    gateway: request.network.gateway_ipv6.to_string(),
                 },
                 resolver: LaunchNetworkResolver {
                     nameservers: vec![
@@ -145,8 +146,7 @@ impl ZoneLauncher {
         }
         let cmdline = cmdline_options.join(" ");
 
-        let zone_mac_string = zone_mac.to_string().replace('-', ":");
-        let gateway_mac_string = gateway_mac.to_string().replace('-', ":");
+        let zone_mac_string = request.network.zone_mac.to_string().replace('-', ":");
 
         let mut disks = vec![
             DomainDisk {
@@ -190,30 +190,6 @@ impl ZoneLauncher {
         let mut extra_keys = vec![
             ("krata/uuid".to_string(), uuid.to_string()),
             ("krata/loops".to_string(), loops.join(",")),
-            (
-                "krata/network/zone/ipv4".to_string(),
-                format!("{}/{}", ip.ipv4, ip.ipv4_prefix),
-            ),
-            (
-                "krata/network/zone/ipv6".to_string(),
-                format!("{}/{}", ip.ipv6, ip.ipv6_prefix),
-            ),
-            (
-                "krata/network/zone/mac".to_string(),
-                zone_mac_string.clone(),
-            ),
-            (
-                "krata/network/gateway/ipv4".to_string(),
-                format!("{}/{}", ip.gateway_ipv4, ip.ipv4_prefix),
-            ),
-            (
-                "krata/network/gateway/ipv6".to_string(),
-                format!("{}/{}", ip.gateway_ipv6, ip.ipv6_prefix),
-            ),
-            (
-                "krata/network/gateway/mac".to_string(),
-                gateway_mac_string.clone(),
-            ),
         ];
 
         if let Some(name) = request.name.as_ref() {
@@ -251,29 +227,14 @@ impl ZoneLauncher {
             extra_rw_paths: vec!["krata/zone".to_string()],
         };
         match context.xen.create(&config).await {
-            Ok(created) => {
-                ip.commit().await?;
-                Ok(ZoneInfo {
-                    name: request.name.as_ref().map(|x| x.to_string()),
-                    uuid,
-                    domid: created.domid,
-                    image: request.image.digest,
-                    loops: vec![],
-                    zone_ipv4: Some(IpNetwork::new(IpAddr::V4(ip.ipv4), ip.ipv4_prefix)?),
-                    zone_ipv6: Some(IpNetwork::new(IpAddr::V6(ip.ipv6), ip.ipv6_prefix)?),
-                    zone_mac: Some(zone_mac_string.clone()),
-                    gateway_ipv4: Some(IpNetwork::new(
-                        IpAddr::V4(ip.gateway_ipv4),
-                        ip.ipv4_prefix,
-                    )?),
-                    gateway_ipv6: Some(IpNetwork::new(
-                        IpAddr::V6(ip.gateway_ipv6),
-                        ip.ipv6_prefix,
-                    )?),
-                    gateway_mac: Some(gateway_mac_string.clone()),
-                    state: ZoneState { exit_code: None },
-                })
-            }
+            Ok(created) => Ok(ZoneInfo {
+                name: request.name.as_ref().map(|x| x.to_string()),
+                uuid,
+                domid: created.domid,
+                image: request.image.digest,
+                loops: vec![],
+                state: ZoneState { exit_code: None },
+            }),
             Err(error) => {
                 let _ = context.autoloop.unloop(&image_squashfs_loop.path).await;
                 let _ = context.autoloop.unloop(&cfgblk_squashfs_loop.path).await;

crates/runtime/src/lib.rs

@@ -1,12 +1,17 @@
-use std::{fs, net::Ipv4Addr, path::PathBuf, str::FromStr, sync::Arc};
+use std::{fs, path::PathBuf, str::FromStr, sync::Arc};
 
 use anyhow::{anyhow, Result};
+<<<<<<< HEAD
 use ip::IpVendor;
 use ipnetwork::{IpNetwork, Ipv4Network, Ipv6Network};
 use krataloopdev::LoopControl;
 use log::{debug, error};
+=======
+>>>>>>> 267dc66 (feature(krata): rework api and make ip assignment persistent to database)
 use tokio::sync::Semaphore;
 use uuid::Uuid;
+
+use krataloopdev::LoopControl;
 use xenclient::XenClient;
 use xenstore::{XsdClient, XsdInterface};
 
@@ -19,7 +24,6 @@ use self::{
 pub mod autoloop;
 pub mod cfgblk;
 pub mod channel;
-pub mod ip;
 pub mod launch;
 pub mod power;
 
@@ -48,12 +52,6 @@ pub struct ZoneInfo {
     pub domid: u32,
     pub image: String,
     pub loops: Vec<ZoneLoopInfo>,
-    pub zone_ipv4: Option<IpNetwork>,
-    pub zone_ipv6: Option<IpNetwork>,
-    pub zone_mac: Option<String>,
-    pub gateway_ipv4: Option<IpNetwork>,
-    pub gateway_ipv6: Option<IpNetwork>,
-    pub gateway_mac: Option<String>,
     pub state: ZoneState,
 }
 
@@ -61,10 +59,10 @@ pub struct ZoneInfo {
 pub struct RuntimeContext {
     pub autoloop: AutoLoop,
     pub xen: XenClient<RuntimePlatform>,
-    pub ipvendor: IpVendor,
 }
 
 impl RuntimeContext {
+<<<<<<< HEAD
     pub async fn new(host_uuid: Uuid) -> Result<Self> {
         debug!("initializing XenClient");
         let xen = XenClient::new(0, RuntimePlatform::new()).await?;
@@ -79,10 +77,17 @@ impl RuntimeContext {
         let autoloop = AutoLoop::new(LoopControl::open()?);
 
         debug!("krata runtime initialized!");
+=======
+    pub async fn new() -> Result<Self> {
+        let xen = XenClient::new(0, RuntimePlatform::new()).await?;
+>>>>>>> 267dc66 (feature(krata): rework api and make ip assignment persistent to database)
         Ok(RuntimeContext {
             autoloop,
             xen,
+<<<<<<< HEAD
             ipvendor,
+=======
+>>>>>>> 267dc66 (feature(krata): rework api and make ip assignment persistent to database)
         })
     }
 
@@ -123,61 +128,6 @@ impl RuntimeContext {
                 .store
                 .read_string(&format!("{}/krata/loops", &dom_path))
                 .await?;
-            let zone_ipv4 = self
-                .xen
-                .store
-                .read_string(&format!("{}/krata/network/zone/ipv4", &dom_path))
-                .await?;
-            let zone_ipv6 = self
-                .xen
-                .store
-                .read_string(&format!("{}/krata/network/zone/ipv6", &dom_path))
-                .await?;
-            let zone_mac = self
-                .xen
-                .store
-                .read_string(&format!("{}/krata/network/zone/mac", &dom_path))
-                .await?;
-            let gateway_ipv4 = self
-                .xen
-                .store
-                .read_string(&format!("{}/krata/network/gateway/ipv4", &dom_path))
-                .await?;
-            let gateway_ipv6 = self
-                .xen
-                .store
-                .read_string(&format!("{}/krata/network/gateway/ipv6", &dom_path))
-                .await?;
-            let gateway_mac = self
-                .xen
-                .store
-                .read_string(&format!("{}/krata/network/gateway/mac", &dom_path))
-                .await?;
-
-            let zone_ipv4 = if let Some(zone_ipv4) = zone_ipv4 {
-                IpNetwork::from_str(&zone_ipv4).ok()
-            } else {
-                None
-            };
-
-            let zone_ipv6 = if let Some(zone_ipv6) = zone_ipv6 {
-                IpNetwork::from_str(&zone_ipv6).ok()
-            } else {
-                None
-            };
-
-            let gateway_ipv4 = if let Some(gateway_ipv4) = gateway_ipv4 {
-                IpNetwork::from_str(&gateway_ipv4).ok()
-            } else {
-                None
-            };
-
-            let gateway_ipv6 = if let Some(gateway_ipv6) = gateway_ipv6 {
-                IpNetwork::from_str(&gateway_ipv6).ok()
-            } else {
-                None
-            };
-
             let exit_code = self
                 .xen
                 .store
@@ -198,12 +148,6 @@ impl RuntimeContext {
                 domid,
                 image,
                 loops,
-                zone_ipv4,
-                zone_ipv6,
-                zone_mac,
-                gateway_ipv4,
-                gateway_ipv6,
-                gateway_mac,
                 state,
             });
         }
@@ -245,16 +189,14 @@ impl RuntimeContext {
 
 #[derive(Clone)]
 pub struct Runtime {
-    host_uuid: Uuid,
     context: RuntimeContext,
     launch_semaphore: Arc<Semaphore>,
 }
 
 impl Runtime {
-    pub async fn new(host_uuid: Uuid) -> Result<Self> {
-        let context = RuntimeContext::new(host_uuid).await?;
+    pub async fn new() -> Result<Self> {
+        let context = RuntimeContext::new().await?;
         Ok(Self {
-            host_uuid,
             context,
             launch_semaphore: Arc::new(Semaphore::new(10)),
         })
@@ -290,11 +232,6 @@ impl Runtime {
             return Err(anyhow!("unable to find krata uuid based on the domain",));
         }
         let uuid = Uuid::parse_str(&uuid)?;
-        let ip = self
-            .context
-            .ipvendor
-            .read_domain_assignment(uuid, domid)
-            .await?;
         let loops = store
             .read_string(format!("{}/krata/loops", dom_path).as_str())
             .await?;
@@ -314,16 +251,6 @@ impl Runtime {
                 }
             }
         }
-
-        if let Some(ip) = ip {
-            if let Err(error) = self.context.ipvendor.recall(&ip).await {
-                error!(
-                    "failed to recall ip assignment for zone {}: {}",
-                    uuid, error
-                );
-            }
-        }
-
         Ok(uuid)
     }
 
@@ -332,11 +259,11 @@ impl Runtime {
     }
 
     pub async fn dupe(&self) -> Result<Runtime> {
-        Runtime::new(self.host_uuid).await
+        Runtime::new().await
     }
 
     pub async fn power_management_context(&self) -> Result<PowerManagementContext> {
-        let context = RuntimeContext::new(self.host_uuid).await?;
+        let context = RuntimeContext::new().await?;
         Ok(PowerManagementContext { context })
     }
 }