utmd 0.1.5

Minimalist developer sandbox and disposable VMs for UTM on macOS.
Documentation 
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

use crate::cli::CloneArgs;
use crate::config::EffectiveConfig;
use crate::errors::ExitCode;
use crate::models::{CommandResponse, OperationResult};
use crate::naming::generate_name;
use crate::output::Reporter;
use crate::state::{self, VmMetadata};
use crate::utm;
use chrono::Utc;
use color_eyre::Result;
use std::collections::HashSet;

pub fn run(args: CloneArgs, cfg: &EffectiveConfig, reporter: &Reporter) -> Result<ExitCode> {
    let template = args
        .template
        .as_deref()
        .unwrap_or_else(|| cfg.template_for(args.os_type));

    let existing = utm::list_vms(cfg)?
        .into_iter()
        .map(|vm| vm.name)
        .collect::<HashSet<_>>();

    let mut effective_cfg = cfg.clone();
    if let Some(prefix) = args.prefix {
        effective_cfg.default_prefix = prefix;
    }

    let name = match generate_name(
        &effective_cfg,
        args.os_type,
        args.name.as_deref(),
        args.name_exact,
        args.name_template.as_deref(),
        &existing,
    ) {
        Ok(name) => name,
        Err(err) => {
            if reporter.is_json() {
                reporter.print_json(&CommandResponse::<OperationResult>::failure(
                    "create",
                    format!("{}", err),
                ))?;
            } else {
                reporter.error(&format!("{}", err));
            }
            return Ok(ExitCode::Conflict);
        }
    };

    if effective_cfg.dry_run {
        let result = OperationResult {
            ok: true,
            action: "create".to_string(),
            target: Some(name.clone()),
            message: format!("dry-run: would clone '{}' from '{}'", name, template),
            warnings: Vec::new(),
        };
        if reporter.is_json() {
            reporter.print_json(&CommandResponse::success("create", result))?;
        } else {
            reporter.info(&result.message);
        }
        return Ok(ExitCode::Success);
    }

    reporter.info(&format!("cloning '{}' to '{}'", template, name));
    if let Err(err) = utm::clone_vm(cfg, template, &name) {
        if reporter.is_json() {
            reporter.print_json(&CommandResponse::<OperationResult>::failure(
                "create",
                format!("{}", err),
            ))?;
        } else {
            reporter.error(&format!("{}", err));
        }
        return Ok(ExitCode::ExternalCommandFailed);
    }

    state::upsert_vm(
        &cfg.state_path,
        VmMetadata {
            name: name.clone(),
            os: Some(args.os_type.as_str().to_string()),
            template: Some(template.to_string()),
            created_at: Utc::now(),
        },
    )?;

    let result = OperationResult {
        ok: true,
        action: "create".to_string(),
        target: Some(name),
        message: "create completed successfully".to_string(),
        warnings: Vec::new(),
    };

    if reporter.is_json() {
        reporter.print_json(&CommandResponse::success("create", result))?;
    } else {
        reporter.info(&result.message);
    }

    Ok(ExitCode::Success)
}