PR Review

Signed-off-by: Lukas Frank <[email protected]>

Author: lukasfrank

client/build.rs

@@ -2,7 +2,11 @@ fn main() {
     tonic_build::configure()
         .build_server(false)
         .compile(
-            &["../proto/feos.proto", "../proto/container.proto"],
+            &[
+                "../proto/feos.proto",
+                "../proto/container.proto",
+                "../proto/isolated_container.proto",
+            ],
             &["../proto"],
         )
         .unwrap();

client/src/client.rs

@@ -7,6 +7,7 @@ use tonic::transport::Endpoint;
 use tonic::Request;
 
 use crate::client_container::ContainerCommand;
+use crate::client_isolated_container::IsolatedContainerCommand;
 use feos_grpc::feos_grpc_client::FeosGrpcClient;
 use feos_grpc::*;
 
@@ -63,6 +64,7 @@ pub enum Command {
         uuid: String,
     },
     Container(ContainerCommand),
+    IsolatedContainer(IsolatedContainerCommand),
 }
 
 fn format_address(ip: &str, port: u16) -> String {
@@ -89,6 +91,14 @@ pub async fn run_client(opt: Opt) -> Result<(), Box<dyn std::error::Error>> {
             crate::client_container::run_container_client(opt.server_ip, opt.port, container_cmd)
                 .await?;
         }
+        Command::IsolatedContainer(container_cmd) => {
+            crate::client_isolated_container::run_isolated_container_client(
+                opt.server_ip,
+                opt.port,
+                container_cmd,
+            )
+            .await?;
+        }
         Command::Reboot => {
             let request = Request::new(RebootRequest {});
             let response = client.reboot(request).await?;

client/src/client_isolated_container.rs

@@ -0,0 +1,76 @@
+use std::time::Duration;
+use structopt::StructOpt;
+use tokio::time::timeout;
+use tonic::transport::Endpoint;
+use tonic::Request;
+
+use isolated_container_grpc::isolated_container_service_client::IsolatedContainerServiceClient;
+use isolated_container_grpc::*;
+
+pub mod isolated_container_grpc {
+    tonic::include_proto!("isolated_container");
+}
+
+#[derive(StructOpt, Debug)]
+pub enum IsolatedContainerCommand {
+    Create {
+        image: String,
+        #[structopt(name = "COMMAND", required = true, min_values = 1)]
+        command: Vec<String>,
+    },
+    Run {
+        uuid: String,
+    },
+    Stop {
+        uuid: String,
+    },
+    State {
+        uuid: String,
+    },
+}
+
+pub async fn run_isolated_container_client(
+    server_ip: String,
+    port: u16,
+    cmd: IsolatedContainerCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let address = format!("http://{}:{}", server_ip, port);
+    let channel = Endpoint::from_shared(address)?.connect().await?;
+    let mut client = IsolatedContainerServiceClient::new(channel);
+
+    match cmd {
+        IsolatedContainerCommand::Create { image, command } => {
+            let request = Request::new(CreateContainerRequest { image, command });
+            match timeout(Duration::from_secs(30), client.create_container(request)).await {
+                Ok(response) => match response {
+                    Ok(response) => println!("CREATE ISOLATED CONTAINER RESPONSE={:?}", response),
+                    Err(e) => eprintln!("Error creating isolated container: {:?}", e),
+                },
+                Err(_) => eprintln!("Request timed out after 30 seconds"),
+            }
+        }
+        IsolatedContainerCommand::Run { uuid } => {
+            let request = Request::new(RunContainerRequest { uuid });
+            match client.run_container(request).await {
+                Ok(response) => println!("RUN ISOLATED CONTAINER RESPONSE={:?}", response),
+                Err(e) => eprintln!("Error running isolated container: {:?}", e),
+            }
+        }
+        IsolatedContainerCommand::Stop { uuid } => {
+            let request = Request::new(StopContainerRequest { uuid });
+            match client.stop_container(request).await {
+                Ok(response) => println!("STOP ISOLATED CONTAINER RESPONSE={:?}", response),
+                Err(e) => eprintln!("Error stopping isolated container: {:?}", e),
+            }
+        }
+        IsolatedContainerCommand::State { uuid } => {
+            let request = Request::new(StateContainerRequest { uuid });
+            match client.state_container(request).await {
+                Ok(response) => println!("STATE ISOLATED CONTAINER RESPONSE={:?}", response),
+                Err(e) => eprintln!("Error getting isolated container state: {:?}", e),
+            }
+        }
+    }
+
+    Ok(())
+}

client/src/main.rs

@@ -1,5 +1,6 @@
 mod client;
 mod client_container;
+mod client_isolated_container;
 
 use client::Opt;
 use structopt::StructOpt;

src/daemon.rs

@@ -58,35 +58,36 @@ impl FeOSAPI {
             log_receiver,
         }
     }
-}
 
-fn handle_error(e: vm::Error) -> tonic::Status {
-    match e {
-        vm::Error::AlreadyExists => Status::new(tonic::Code::AlreadyExists, "vm already exists"),
-        vm::Error::NotFound => Status::new(tonic::Code::NotFound, "vm not found"),
-        vm::Error::SocketFailure(e) => {
-            info!("socket error: {:?}", e);
-            Status::new(tonic::Code::Internal, "failed to ")
-        }
-        vm::Error::InvalidInput(e) => {
-            info!("invalid input error: {:?}", e);
-            Status::new(tonic::Code::Internal, "invalid input")
-        }
-        vm::Error::CHCommandFailure(e) => {
-            info!("failed to connect to cloud hypervisor: {:?}", e);
-            Status::new(
-                tonic::Code::Internal,
-                "failed to connect to cloud hypervisor",
-            )
-        }
-        vm::Error::CHApiFailure(e) => {
-            info!("failed to connect to cloud hypervisor api: {:?}", e);
-            Status::new(
-                tonic::Code::Internal,
-                "failed to connect to cloud hypervisor api",
-            )
+    fn handle_error(&self, e: vm::Error) -> Status {
+        match e {
+            vm::Error::AlreadyExists => {
+                Status::new(tonic::Code::AlreadyExists, "vm already exists")
+            }
+            vm::Error::NotFound => Status::new(tonic::Code::NotFound, "vm not found"),
+            vm::Error::SocketFailure(e) => {
+                info!("socket error: {:?}", e);
+                Status::new(tonic::Code::Internal, "failed to ")
+            }
+            vm::Error::InvalidInput(e) => {
+                info!("invalid input error: {:?}", e);
+                Status::new(tonic::Code::Internal, "invalid input")
+            }
+            vm::Error::CHCommandFailure(e) => {
+                info!("failed to connect to cloud hypervisor: {:?}", e);
+                Status::new(
+                    tonic::Code::Internal,
+                    "failed to connect to cloud hypervisor",
+                )
+            }
+            vm::Error::CHApiFailure(e) => {
+                info!("failed to connect to cloud hypervisor api: {:?}", e);
+                Status::new(
+                    tonic::Code::Internal,
+                    "failed to connect to cloud hypervisor api",
+                )
+            }
         }
-        vm::Error::Failed => Status::new(tonic::Code::AlreadyExists, "vm already exists"),
     }
 }
 
@@ -191,7 +192,9 @@ impl FeosGrpc for FeOSAPI {
         info!("Got create_vm request");
 
         let id = Uuid::new_v4();
-        self.vmm.init_vmm(id, true).map_err(handle_error)?;
+        self.vmm
+            .init_vmm(id, true)
+            .map_err(|e| self.handle_error(e))?;
 
         let root_fs = PathBuf::from(format!(
             "./images/{}/application.vnd.ironcore.image.rootfs.v1alpha1.rootfs",
@@ -205,7 +208,7 @@ impl FeosGrpc for FeOSAPI {
                 vm::BootMode::FirmwareBoot(vm::FirmwareBootMode { root_fs }),
                 request.get_ref().ignition.clone(),
             )
-            .map_err(handle_error)?;
+            .map_err(|e| self.handle_error(e))?;
 
         Ok(Response::new(feos_grpc::CreateVmResponse {
             uuid: id.to_string(),
@@ -221,8 +224,8 @@ impl FeosGrpc for FeOSAPI {
         let id = request.get_ref().uuid.to_owned();
         let id =
             Uuid::parse_str(&id).map_err(|_| Status::invalid_argument("failed to parse uuid"))?;
-        self.vmm.ping_vmm(id).map_err(handle_error)?;
-        let vm_status = self.vmm.get_vm(id).map_err(handle_error)?;
+        self.vmm.ping_vmm(id).map_err(|e| self.handle_error(e))?;
+        let vm_status = self.vmm.get_vm(id).map_err(|e| self.handle_error(e))?;
 
         Ok(Response::new(feos_grpc::GetVmResponse { info: vm_status }))
     }
@@ -236,7 +239,7 @@ impl FeosGrpc for FeOSAPI {
         let id = Uuid::parse_str(&request.get_ref().uuid)
             .map_err(|_| Status::invalid_argument("Failed to parse UUID"))?;
 
-        self.vmm.boot_vm(id).map_err(handle_error)?;
+        self.vmm.boot_vm(id).map_err(|e| self.handle_error(e))?;
 
         Ok(Response::new(feos_grpc::BootVmResponse {}))
     }
@@ -263,7 +266,10 @@ impl FeosGrpc for FeOSAPI {
         };
         let id = Uuid::parse_str(&initial_request.uuid)
             .map_err(|_| Status::invalid_argument("failed to parse uuid"))?;
-        let socket_path = self.vmm.get_vm_console_path(id).map_err(handle_error)?;
+        let socket_path = self
+            .vmm
+            .get_vm_console_path(id)
+            .map_err(|e| self.handle_error(e))?;
 
         tokio::spawn(async move {
             let stream = match UnixStream::connect(&socket_path).await {
@@ -331,7 +337,7 @@ impl FeosGrpc for FeOSAPI {
 
         self.vmm
             .add_net_device(id, net_config)
-            .map_err(handle_error)?;
+            .map_err(|e| self.handle_error(e))?;
 
         Ok(Response::new(feos_grpc::AttachNicVmResponse {}))
     }
@@ -346,7 +352,7 @@ impl FeosGrpc for FeOSAPI {
             .map_err(|_| Status::invalid_argument("Failed to parse UUID"))?;
 
         // TODO differentiate between kill and shutdown
-        self.vmm.kill_vm(id).map_err(handle_error)?;
+        self.vmm.kill_vm(id).map_err(|e| self.handle_error(e))?;
 
         Ok(Response::new(feos_grpc::ShutdownVmResponse {}))
     }
@@ -507,11 +513,7 @@ pub async fn daemon_start(
     Ok(())
 }
 
-pub async fn start_feos(
-    ipv6_address: Ipv6Addr,
-    prefix_length: u8,
-    test_mode: bool,
-) -> Result<(), String> {
+pub async fn start_feos(ipv6_address: Ipv6Addr, prefix_length: u8) -> Result<(), String> {
     println!(
         "