cubic 0.17.0

Cubic is a lightweight command line manager for virtual machines. It has a simple, daemon-less and rootless design. All Cubic virtual machines run isolated in the user context. Cubic is built on top of QEMU, KVM and cloud-init. Show all supported images: $ cubic images Create a new virtual machine instance: $ cubic create mymachine --image ubuntu:noble List all virtual machine instances: $ cubic instances Start an instance: $ cubic start <instance name> Stop an instance: $ cubic stop <instance name> Open a shell in the instance: $ cubic ssh <machine name> Copy a file from the host to the instance: $ cubic scp <path/to/host/file> <machine>:<path/to/guest/file> Copy a file from the instance to the hots: $ cubic scp <machine>:<path/to/guest/file> <path/to/host/file> 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use crate::emulator::Emulator;
use crate::env::Environment;
use crate::error::Error;
use crate::fs::FS;
use crate::instance::{Instance, InstanceStore};
use crate::ssh_cmd::PortChecker;
use crate::util::setup_cloud_init;

pub struct StartInstanceAction {
    instance: Instance,
}

impl StartInstanceAction {
    pub fn new(instance: &Instance) -> Self {
        Self {
            instance: instance.clone(),
        }
    }

    pub fn run(
        &mut self,
        instance_dao: &dyn InstanceStore,
        env: &Environment,
        qemu_args: &Option<String>,
        verbose: bool,
    ) -> Result<(), Error> {
        if instance_dao.is_running(&self.instance) {
            return Ok(());
        }

        FS::new().setup_directory_access(&env.get_instance_runtime_dir(&self.instance.name))?;
        setup_cloud_init(env, &self.instance)?;

        let mut emulator = Emulator::from(self.instance.arch)?;
        emulator.set_cpus(self.instance.cpus);
        emulator.set_memory(self.instance.mem);
        emulator.set_console(&env.get_console_file(&self.instance.name));
        emulator.add_drive(&env.get_instance_image_file(&self.instance.name), "qcow2");
        emulator.add_drive(&env.get_user_data_image_file(&self.instance.name), "raw");
        emulator.set_network(&self.instance.hostfwd, self.instance.ssh_port);
        if let Some(args) = qemu_args {
            emulator.set_qemu_args(args);
        }
        emulator.set_verbose(verbose);
        emulator.set_pid_file(&env.get_qemu_pid_file(&self.instance.name));

        if let Ok(qemu_root) = std::env::var("SNAP") {
            emulator.add_env(
                "QEMU_MODULE_DIR",
                "/snap/cubic/current/usr/lib/x86_64-linux-gnu/qemu",
            );
            emulator.add_search_path(&format!("{qemu_root}/usr/share/qemu"));
            emulator.add_search_path(&format!("{qemu_root}/usr/share/qemu-efi-aarch64"));
            emulator.add_search_path(&format!("{qemu_root}/usr/share/seabios"));
            emulator.add_search_path(&format!("{qemu_root}/usr/lib/ipxe/qemu"));
        }

        emulator.add_qmp("qmp", &env.get_monitor_file(&self.instance.name));
        emulator.add_guest_agent(
            "guest-agent",
            &env.get_guest_agent_file(&self.instance.name),
        );
        emulator.run()
    }

    pub fn is_done(&self) -> bool {
        PortChecker::new().is_open(self.instance.ssh_port)
    }
}