sal-virt 0.1.0

SAL Virt - Virtualization and containerization tools including Buildah, Nerdctl, and RFS
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use super::{cmd::execute_rfs_command, error::RfsError, types::Mount};

/// List all mounted filesystems
///
/// # Returns
///
/// * `Result<Vec<Mount>, RfsError>` - List of mounts or error
pub fn list_mounts() -> Result<Vec<Mount>, RfsError> {
    // Execute the list command
    let result = execute_rfs_command(&["list", "--json"])?;

    // Parse the JSON output
    match serde_json::from_str::<serde_json::Value>(&result.stdout) {
        Ok(json) => {
            if let serde_json::Value::Array(mounts_json) = json {
                let mut mounts = Vec::new();

                for mount_json in mounts_json {
                    // Extract mount ID
                    let id = match mount_json.get("id").and_then(|v| v.as_str()) {
                        Some(id) => id.to_string(),
                        None => return Err(RfsError::ListFailed("Missing mount ID".to_string())),
                    };

                    // Extract source
                    let source = match mount_json.get("source").and_then(|v| v.as_str()) {
                        Some(source) => source.to_string(),
                        None => return Err(RfsError::ListFailed("Missing source".to_string())),
                    };

                    // Extract target
                    let target = match mount_json.get("target").and_then(|v| v.as_str()) {
                        Some(target) => target.to_string(),
                        None => return Err(RfsError::ListFailed("Missing target".to_string())),
                    };

                    // Extract filesystem type
                    let fs_type = match mount_json.get("type").and_then(|v| v.as_str()) {
                        Some(fs_type) => fs_type.to_string(),
                        None => {
                            return Err(RfsError::ListFailed("Missing filesystem type".to_string()))
                        }
                    };

                    // Extract options
                    let options = match mount_json.get("options").and_then(|v| v.as_array()) {
                        Some(options_array) => {
                            let mut options_vec = Vec::new();
                            for option_value in options_array {
                                if let Some(option_str) = option_value.as_str() {
                                    options_vec.push(option_str.to_string());
                                }
                            }
                            options_vec
                        }
                        None => Vec::new(), // Empty vector if no options found
                    };

                    // Create Mount struct and add to vector
                    mounts.push(Mount {
                        id,
                        source,
                        target,
                        fs_type,
                        options,
                    });
                }

                Ok(mounts)
            } else {
                Err(RfsError::ListFailed("Expected JSON array".to_string()))
            }
        }
        Err(e) => Err(RfsError::ListFailed(format!(
            "Failed to parse mount list JSON: {}",
            e
        ))),
    }
}

/// Unmount a filesystem by target path
///
/// # Arguments
///
/// * `target` - Target mount point
///
/// # Returns
///
/// * `Result<(), RfsError>` - Success or error
pub fn unmount(target: &str) -> Result<(), RfsError> {
    // Execute the unmount command
    let result = execute_rfs_command(&["unmount", target])?;

    // Check for errors
    if !result.success {
        return Err(RfsError::UnmountFailed(format!(
            "Failed to unmount {}: {}",
            target, result.stderr
        )));
    }

    Ok(())
}

/// Unmount all filesystems
///
/// # Returns
///
/// * `Result<(), RfsError>` - Success or error
pub fn unmount_all() -> Result<(), RfsError> {
    // Execute the unmount all command
    let result = execute_rfs_command(&["unmount", "--all"])?;

    // Check for errors
    if !result.success {
        return Err(RfsError::UnmountFailed(format!(
            "Failed to unmount all filesystems: {}",
            result.stderr
        )));
    }

    Ok(())
}

/// Get information about a mounted filesystem
///
/// # Arguments
///
/// * `target` - Target mount point
///
/// # Returns
///
/// * `Result<Mount, RfsError>` - Mount information or error
pub fn get_mount_info(target: &str) -> Result<Mount, RfsError> {
    // Get all mounts
    let mounts = list_mounts()?;

    // Find the mount with the specified target
    for mount in mounts {
        if mount.target == target {
            return Ok(mount);
        }
    }

    // Mount not found
    Err(RfsError::Other(format!("No mount found at {}", target)))
}