krunvm 0.1.6

Create microVMs from OCI images
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

// Copyright 2021 Red Hat, Inc.
// SPDX-License-Identifier: Apache-2.0

use std::collections::HashMap;

use crate::{ArgMatches, KrunvmConfig, APP_NAME};

use super::list::printvm;
use super::utils::{parse_mapped_ports, parse_mapped_volumes};

pub fn changevm(cfg: &mut KrunvmConfig, matches: &ArgMatches) {
    let mut cfg_changed = false;

    let name = matches.value_of("NAME").unwrap();

    let mut vmcfg = if let Some(new_name) = matches.value_of("new-name") {
        if cfg.vmconfig_map.contains_key(new_name) {
            println!("A VM with name {} already exists", new_name);
            std::process::exit(-1);
        }

        let mut vmcfg = match cfg.vmconfig_map.remove(name) {
            None => {
                println!("No VM found with name {}", name);
                std::process::exit(-1);
            }
            Some(vmcfg) => vmcfg,
        };

        cfg_changed = true;
        let name = new_name.to_string();
        vmcfg.name = name.clone();
        cfg.vmconfig_map.insert(name.clone(), vmcfg);
        cfg.vmconfig_map.get_mut(&name).unwrap()
    } else {
        match cfg.vmconfig_map.get_mut(name) {
            None => {
                println!("No VM found with name {}", name);
                std::process::exit(-1);
            }
            Some(vmcfg) => vmcfg,
        }
    };

    if let Some(cpus_str) = matches.value_of("cpus") {
        match cpus_str.parse::<u32>() {
            Err(_) => println!("Invalid value for \"cpus\""),
            Ok(cpus) => {
                if cpus > 8 {
                    println!("Error: the maximum number of CPUs supported is 8");
                } else {
                    vmcfg.cpus = cpus;
                    cfg_changed = true;
                }
            }
        }
    }

    if let Some(mem_str) = matches.value_of("mem") {
        match mem_str.parse::<u32>() {
            Err(_) => println!("Invalid value for \"mem\""),
            Ok(mem) => {
                if mem > 16384 {
                    println!("Error: the maximum amount of RAM supported is 16384 MiB");
                } else {
                    vmcfg.mem = mem;
                    cfg_changed = true;
                }
            }
        }
    }

    if matches.is_present("remove-volumes") {
        vmcfg.mapped_volumes = HashMap::new();
        cfg_changed = true;
    } else {
        let volume_matches = if matches.is_present("volume") {
            matches.values_of("volume").unwrap().collect()
        } else {
            vec![]
        };
        let mapped_volumes = parse_mapped_volumes(volume_matches);

        if !mapped_volumes.is_empty() {
            vmcfg.mapped_volumes = mapped_volumes;
            cfg_changed = true;
        }
    }

    if matches.is_present("remove-ports") {
        vmcfg.mapped_ports = HashMap::new();
        cfg_changed = true;
    } else {
        let port_matches = if matches.is_present("port") {
            matches.values_of("port").unwrap().collect()
        } else {
            vec![]
        };
        let mapped_ports = parse_mapped_ports(port_matches);

        if !mapped_ports.is_empty() {
            vmcfg.mapped_ports = mapped_ports;
            cfg_changed = true;
        }
    }

    if let Some(workdir) = matches.value_of("workdir") {
        vmcfg.workdir = workdir.to_string();
        cfg_changed = true;
    }

    println!();
    printvm(vmcfg);
    println!();

    if cfg_changed {
        confy::store(APP_NAME, &cfg).unwrap();
    }
}