Add support to choose VM for start app

client/src/client.rs

@@ -76,8 +76,12 @@ impl AdminClient {
         Ok(response.into_inner().cmd_status)
     }
 
-    pub async fn start(&self, app: String) -> anyhow::Result<()> {
-        let request = pb::admin::ApplicationRequest { app_name: app };
+    pub async fn start(&self, app: String, vm: Option<String>) -> anyhow::Result<()> {
+        let app_name = match vm {
+            Some(vm_name) => format!("{app}:{vm_name}"),
+            None => app,
+        };
+        let request = pb::admin::ApplicationRequest { app_name };
         let response = self.connect_to().await?.start_application(request).await?;
         // Ok(response.into_inner().cmd_status)
         Ok(())

nixos/tests/admin.nix

@@ -203,7 +203,7 @@ in {
               admin = adminSettings;
               tls = mkTls "chromium-vm";
               applications = lib.mkForce (builtins.toJSON {
-                "foot" = "run-waypipe foot";
+                "foot" = "/run/current-system/sw/bin/run-waypipe ${pkgs.foot}/bin/foot";
               });
             };
           };
@@ -260,7 +260,7 @@ in {
 
                   return any(pattern in name for name in nodes)
 
-              retry(func)
+              retry(func, timeout=30)
           # End of borrowed code
 
           import time

src/admin/server.rs

@@ -121,10 +121,11 @@ impl AdminServiceImpl {
         Ok(())
     }
 
-    pub async fn start_vm(&self, name: String) -> anyhow::Result<()> {
+    pub async fn start_vm(&self, name: &str) -> anyhow::Result<()> {
         let endpoint = self.host_endpoint()?;
         let client = SystemDClient::new(endpoint);
-        let vm_name = format_vm_name(&name);
+        let (name, vm_name) = Self::parse_app_vm_pair(name);
+        let vm_name = format_vm_name(&name, vm_name);
         let status = client
             .get_remote_status(vm_name.clone())
             .await
@@ -162,7 +163,7 @@ impl AdminServiceImpl {
             }
             (VmType::AppVM, ServiceType::Mgr) | (VmType::SysVM, ServiceType::Mgr) => {
                 let name = parse_service_name(&entry.name)?;
-                self.start_vm(name.to_string())
+                self.start_vm(name)
                     .await
                     .with_context(|| format!("handing error, by restart VM {}", &entry.name))?;
                 Ok(()) // FIXME: should use `?` from line above, why it didn't work?
@@ -232,17 +233,26 @@ impl AdminServiceImpl {
         self.registry.register(entry)
     }
 
+    fn parse_app_vm_pair(app_and_vm: &str) -> (&str, Option<&str>) {
+        if let Some((app, vm)) = app_and_vm.split_once(":") {
+            (app, Some(vm))
+        } else {
+            (app_and_vm, None)
+        }
+    }
+
     pub async fn start_app(&self, req: ApplicationRequest) -> anyhow::Result<()> {
         if self.state != State::VmsRegistered {
             info!("not all required system-vms are registered")
         }
+
         let systemd_agent = format_service_name(&req.app_name);
 
         // Entry unused in "go" code
         match self.registry.by_name(&systemd_agent) {
             std::result::Result::Ok(e) => e,
             Err(_) => {
-                self.start_vm(req.app_name.clone())
+                self.start_vm(&req.app_name)
                     .await
                     .context(format!("Starting vm for {}", &req.app_name))?;
                 self.registry

src/bin/givc-agent.rs

@@ -67,6 +67,7 @@ async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
 
     let addr = SocketAddr::new(cli.addr.parse()?, cli.port);
 
+    // FIXME: Totally wrong,
     let agent_service_name = format_service_name(&cli.name);
 
     let mut builder = Server::builder();

src/bin/givc-cli.rs

@@ -42,6 +42,8 @@ struct Cli {
 #[derive(Debug, Subcommand)]
 enum Commands {
     Start {
+        #[arg(long)]
+        vm: Option<String>,
         app: String,
     },
     Stop {
@@ -128,7 +130,7 @@ async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
 
     match cli.command {
         Commands::Test { test } => test_subcommands(test, admin).await?,
-        Commands::Start { app } => admin.start(app).await?,
+        Commands::Start { app, vm } => admin.start(app, vm).await?,
         Commands::Stop { app } => admin.stop(app).await?,
 
         Commands::Pause { app } => admin.pause(app).await?,

src/utils/naming.rs

@@ -1,30 +1,31 @@
 use anyhow::*;
 
-pub fn format_vm_name(name: &String) -> String {
-    format!("microvm@{name}-vm.service")
+pub fn format_vm_name(name: &str, vm: Option<&str>) -> String {
+    if let Some(vm_name) = vm {
+        format!("microvm@{vm_name}.service")
+    } else {
+        format!("microvm@{name}-vm.service")
+    }
 }
 
-pub fn format_service_name(name: &String) -> String {
+pub fn format_service_name(name: &str) -> String {
     format!("givc-{}-vm.service", name)
 }
 
-// FIXME: rewrite as `pub fn parse_service_name(name: &str) -> anyhow::Result<&str>`
-pub fn parse_service_name(name: &String) -> anyhow::Result<String> {
+pub fn parse_service_name(name: &str) -> anyhow::Result<&str> {
     name.strip_suffix("-vm.service")
         .and_then(|name| name.strip_prefix("givc-"))
-        .map(str::to_string)
         .ok_or_else(|| anyhow!("Doesn't know how to parse VM name: {name}"))
 }
 
 // From `agent` code, ported for future
-// FIXME: rewrite as `parse_application_name(name: &str) -> anyhow::Result<(&str, i32)>`
-pub fn parse_application_name(name: &String) -> anyhow::Result<(String, i32)> {
+pub fn parse_application_name(name: &str) -> anyhow::Result<(&str, i32)> {
     if let Some(name_no_suffix) = name.strip_suffix(".service") {
         if let Some((left, right)) = name_no_suffix.rsplit_once("@") {
             let num = right
                 .parse::<i32>()
                 .with_context(|| format!("While parsing number part of {}", name))?;
-            return Ok((left.to_string(), num));
+            return Ok((left, num));
         }
     };
     bail!("App name {} not it app@<number>.service format", name)
@@ -36,10 +37,10 @@ mod tests {
 
     #[test]
     fn test_parse_service_name() -> Result<()> {
-        let good = parse_service_name(&String::from("givc-good-vm.service"))?;
+        let good = parse_service_name("givc-good-vm.service")?;
         assert_eq!(good, "good");
 
-        let bad = parse_service_name(&String::from("just-a.service"));
+        let bad = parse_service_name("just-a.service");
         let err = bad.unwrap_err();
         assert_eq!(
             format!("{}", err.root_cause()),
@@ -50,10 +51,10 @@ mod tests {
 
     #[test]
     fn test_parse_application_name() -> Result<()> {
-        let good = parse_application_name(&String::from("[email protected]"))?;
-        assert_eq!(good, (String::from("good-app"), 42));
+        let good = parse_application_name("[email protected]")?;
+        assert_eq!(good, ("good-app", 42));
 
-        let bad = parse_application_name(&String::from("just-a.service"));
+        let bad = parse_application_name("just-a.service");
         let err = bad.unwrap_err();
         assert_eq!(
             format!("{}", err.root_cause()),