Sandboxer: Replace features with bin parameter

Fix #54

.gitignore

@@ -6,3 +6,4 @@ target
 !**/src/api/mod.rs
 shim/Cargo.lock
 vmm/common/Cargo.lock
+!/vmm/sandbox/src/bin/

vmm/sandbox/Cargo.toml

@@ -7,12 +7,6 @@ edition = "2021"
 [profile.release]
 panic = 'abort'
 
-[features]
-default = []
-qemu = ["qapi/qmp", "qapi/async-tokio-all", "unshare", "os_pipe"]
-cloud_hypervisor = ["api_client"]
-stratovirt = ["qapi/qmp", "qapi/async-tokio-all", "unshare", "os_pipe"]
-
 [dependencies]
 tokio = { version = "1.19.2", features = ["full"] }
 containerd-sandbox = {git="https://github.com/kuasar-io/rust-extensions.git"}
@@ -36,13 +30,14 @@ prost-types = "0.10.1"
 time = "0.3.5"
 log = { version = "0.4.17", features = ["std"] }
 uuid = { version = "1.1.2", features = ["v4"] }
-unshare = { version = "0.7.0", optional = true }
-os_pipe = { version = "0.9.2", optional = true }
-qapi = { version = "0.8.0", features = ["qmp", "async-tokio-all"], optional = true }
+unshare = "0.7.0"
+os_pipe = { version = "1.1.4" }
+qapi = { version = "0.8.0", features = ["qmp", "async-tokio-all"] }
 sandbox-derive = { path = "derive" }
-api_client = { git = "https://github.com/cloud-hypervisor/cloud-hypervisor.git", optional = true }
+api_client = { git = "https://github.com/cloud-hypervisor/cloud-hypervisor.git" }
 rtnetlink = "0.12"
 netlink-packet-route = "0.15"
 netlink-packet-core = "0.5.0"
 ttrpc = { version = "0.7", features = ["async"] }
 protobuf = "3.2"
+proc-macro2 = "1.0.66"

vmm/sandbox/src/bin/cloud_hypervisor.rs

@@ -0,0 +1,65 @@
+/*
+Copyright 2022 The Kuasar Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+use std::str::FromStr;
+
+use anyhow::Result;
+use vmm_sandboxer::{
+    cloud_hypervisor::{
+        config::CloudHypervisorVMConfig, factory::CloudHypervisorVMFactory,
+        hooks::CloudHypervisorHooks,
+    },
+    load_config,
+    sandbox::KuasarSandboxer,
+    CONFIG_CLH_PATH,
+};
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    // Initialize logging
+    let mut builder = env_logger::Builder::from_default_env();
+    builder.format_timestamp_micros();
+
+    // Initialize sandboxer
+    let sandboxer = init_cloud_hypervisor_sandboxer().await?;
+
+    // If 'log_level' field isn't set in the config file, keep the log level from the default env
+    // Otherwise, set the log level configured in the config file
+    if !sandboxer.log_level().is_empty() {
+        let log_level = log::LevelFilter::from_str(sandboxer.log_level())?;
+        builder.filter_level(log_level);
+    }
+    builder.init();
+
+    // Run the sandboxer
+    containerd_sandbox::run("kuasar-sandboxer", sandboxer)
+        .await
+        .unwrap();
+
+    Ok(())
+}
+
+async fn init_cloud_hypervisor_sandboxer(
+) -> Result<KuasarSandboxer<CloudHypervisorVMFactory, CloudHypervisorHooks>> {
+    let (config, persist_dir_path) =
+        load_config::<CloudHypervisorVMConfig>(CONFIG_CLH_PATH).await?;
+    let hooks = CloudHypervisorHooks {};
+    let mut s = KuasarSandboxer::new(config.sandbox, config.hypervisor, hooks);
+    if !persist_dir_path.is_empty() {
+        s.recover(&persist_dir_path).await?;
+    }
+    Ok(s)
+}

vmm/sandbox/src/bin/qemu.rs

@@ -0,0 +1,79 @@
+/*
+Copyright 2022 The Kuasar Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+use std::{env, path::Path, str::FromStr};
+
+use anyhow::Result;
+use vmm_sandboxer::{
+    kata_config::KataConfig,
+    qemu::{factory::QemuVMFactory, hooks::QemuHooks},
+    sandbox::KuasarSandboxer,
+};
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    // Initialize logging
+    let mut builder = env_logger::Builder::from_default_env();
+    builder.format_timestamp_micros();
+
+    // Initialize sandboxer
+    let sandboxer = init_qemu_sandboxer().await?;
+
+    // If 'log_level' field isn't set in the config file, keep the log level from the default env
+    // Otherwise, set the log level configured in the config file
+    if !sandboxer.log_level().is_empty() {
+        let log_level = log::LevelFilter::from_str(sandboxer.log_level())?;
+        builder.filter_level(log_level);
+    }
+    builder.init();
+
+    // Run the sandboxer
+    containerd_sandbox::run("kuasar-sandboxer", sandboxer)
+        .await
+        .unwrap();
+
+    Ok(())
+}
+
+async fn init_qemu_sandboxer() -> Result<KuasarSandboxer<QemuVMFactory, QemuHooks>> {
+    // For compatibility with kata config
+    let config_path = env::var("KATA_CONFIG_PATH")
+        .unwrap_or_else(|_| "/usr/share/defaults/kata-containers/configuration.toml".to_string());
+
+    let path = Path::new(&config_path);
+    if path.exists() {
+        KataConfig::init(path).await?;
+    }
+
+    let vmm_config = KataConfig::hypervisor_config("qemu", |h| h.clone()).await?;
+    let vmm_config = vmm_config.to_qemu_config()?;
+    let sandbox_config = KataConfig::sandbox_config("qemu").await?;
+    let hooks = QemuHooks::new(vmm_config.clone());
+    let mut s = KuasarSandboxer::new(sandbox_config, vmm_config, hooks);
+
+    // Check for "--dir" argument and recover from persisted directory
+    let os_args: Vec<_> = env::args_os().collect();
+    for i in 0..os_args.len() {
+        if os_args[i].to_str().unwrap() == "--dir" {
+            let persist_dir_path = os_args[i + 1].to_str().unwrap().to_string();
+            if Path::new(&persist_dir_path).exists() {
+                s.recover(&persist_dir_path).await?;
+            }
+        }
+    }
+
+    Ok(s)
+}

vmm/sandbox/src/bin/stratovirt.rs

@@ -0,0 +1,65 @@
+/*
+Copyright 2022 The Kuasar Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+use std::str::FromStr;
+
+use anyhow::Result;
+use env_logger::Builder;
+use vmm_sandboxer::{
+    load_config,
+    sandbox::KuasarSandboxer,
+    stratovirt::{
+        config::StratoVirtVMConfig, factory::StratoVirtVMFactory, hooks::StratoVirtHooks,
+    },
+    CONFIG_STRATOVIRT_PATH,
+};
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    // Initialize logging
+    let mut builder = Builder::from_default_env();
+    builder.format_timestamp_micros();
+
+    // Initialize sandboxer
+    let sandboxer = init_stratovirt_sandboxer().await?;
+
+    // If 'log_level' field isn't set in the config file, keep the log level from the default env
+    // Otherwise, set the log level configured in the config file
+    if !sandboxer.log_level().is_empty() {
+        let log_level = log::LevelFilter::from_str(sandboxer.log_level())?;
+        builder.filter_level(log_level);
+    }
+    builder.init();
+
+    // Run the sandboxer
+    containerd_sandbox::run("kuasar-sandboxer", sandboxer)
+        .await
+        .unwrap();
+
+    Ok(())
+}
+
+async fn init_stratovirt_sandboxer() -> Result<KuasarSandboxer<StratoVirtVMFactory, StratoVirtHooks>>
+{
+    let (config, persist_dir_path) =
+        load_config::<StratoVirtVMConfig>(CONFIG_STRATOVIRT_PATH).await?;
+    let hooks = StratoVirtHooks::new(config.hypervisor.clone());
+    let mut s = KuasarSandboxer::new(config.sandbox, config.hypervisor, hooks);
+    if !persist_dir_path.is_empty() {
+        s.recover(&persist_dir_path).await?;
+    }
+    Ok(s)
+}

vmm/sandbox/src/cloud_hypervisor/mod.rs

@@ -243,7 +243,7 @@ impl VM for CloudHypervisorVM {
     }
 
     async fn wait_channel(&self) -> Option<Receiver<(u32, i128)>> {
-        return self.wait_chan.clone();
+        self.wait_chan.clone()
     }
 }
 

vmm/sandbox/src/kata_config.rs

@@ -24,9 +24,10 @@ use tokio::sync::{RwLock, RwLockReadGuard};
 
 use crate::{sandbox::SandboxConfig, utils::read_file, vm::ShareFsType};
 
-cfg_qemu! {
-    use crate::qemu::config::QemuVMConfig;
-}
+// cfg_qemu! {
+//     use crate::qemu::config::QemuVMConfig;
+// }
+use crate::qemu::config::QemuVMConfig;
 
 lazy_static! {
     pub static ref CONFIG: RwLock<KataConfig> = {
@@ -215,7 +216,7 @@ impl KataConfig {
     }
 }
 
-#[cfg(feature = "qemu")]
+// #[cfg(feature = "qemu")]
 impl Hypervisor {
     #[allow(clippy::field_reassign_with_default)]
     pub fn to_qemu_config(&self) -> Result<QemuVMConfig> {

vmm/sandbox/src/lib.rs

@@ -0,0 +1,76 @@
+/*
+Copyright 2022 The Kuasar Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+use std::path::Path;
+
+use serde::de::DeserializeOwned;
+
+use crate::{config::Config, sandbox::KuasarSandbox};
+
+#[macro_use]
+mod device;
+
+mod client;
+mod container;
+mod io;
+mod network;
+mod param;
+mod storage;
+mod utils;
+mod vm;
+
+pub mod config;
+pub mod kata_config;
+pub mod sandbox;
+pub mod qemu;
+pub mod stratovirt;
+pub mod cloud_hypervisor;
+
+pub const NAMESPACE_PID: &str = "pid";
+pub const NAMESPACE_NET: &str = "network";
+pub const NAMESPACE_MNT: &str = "mount";
+pub const NAMESPACE_CGROUP: &str = "cgroup";
+
+pub const FS_SHARE_PATH: &str = "shared_fs";
+
+pub const CONFIG_STRATOVIRT_PATH: &str = "/var/lib/kuasar/config_stratovirt.toml";
+pub const CONFIG_CLH_PATH: &str = "/var/lib/kuasar/config_clh.toml";
+
+pub async fn load_config<T: DeserializeOwned>(
+    default_config_path: &str,
+) -> anyhow::Result<(Config<T>, String)> {
+    let os_args: Vec<_> = std::env::args_os().collect();
+    let mut config_path = default_config_path.to_string();
+    let mut dir_path = String::new();
+    for i in 0..os_args.len() {
+        if os_args[i].to_str().unwrap() == "--config" {
+            config_path = os_args[i + 1].to_str().unwrap().to_string()
+        }
+        if os_args[i].to_str().unwrap() == "--dir" {
+            dir_path = os_args[i + 1].to_str().unwrap().to_string();
+            if !Path::new(&dir_path).exists() {
+                tokio::fs::create_dir_all(&dir_path).await.unwrap();
+            }
+        }
+    }
+    let path = Path::new(&config_path);
+    let config: Config<T> = if path.exists() {
+        Config::parse(path).await?
+    } else {
+        panic!("config file {} not exist", config_path);
+    };
+    Ok((config, dir_path))
+}