libbtrfsutil 0.7.1

libbtrfsutil bindings
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

use std::{error::Error, fmt, fs, io, path::PathBuf, process::Command, time::Duration};

pub struct LoopDevice {
    path: PathBuf,
    name: String,
    mountpoint: Option<PathBuf>,
}

impl LoopDevice {
    pub fn new(path: PathBuf) -> Self {
        let status = Command::new("truncate")
            .arg("--size=512M")
            .arg(&path)
            .status()
            .unwrap();

        assert!(status.success());

        let output = Command::new("losetup")
            .arg("--show")
            .arg("--find")
            .arg(&path)
            .output()
            .unwrap();

        let name = String::from_utf8(output.stdout).unwrap().trim().to_string();

        Self {
            path,
            name,
            mountpoint: None,
        }
    }

    pub fn mount(&mut self, path: PathBuf) -> io::Result<()> {
        assert!(self.mountpoint.is_none());
        fs::create_dir_all(&path)?;
        let status = Command::new("mount").arg(&self.name).arg(&path).status()?;
        assert!(status.success());
        self.mountpoint.replace(path);
        Ok(())
    }

    pub fn umount(&mut self) -> io::Result<()> {
        let mount_path = self.mountpoint.as_ref().unwrap();
        let status = Command::new("umount").arg(mount_path).status()?;
        if !status.success() {
            return Err(io::ErrorKind::Other.into());
        }
        assert!(status.success());
        fs::remove_dir_all(mount_path)?;
        self.mountpoint.take();
        Ok(())
    }

    pub fn mountpoint(&self) -> Option<&PathBuf> {
        self.mountpoint.as_ref()
    }

    pub fn name(&self) -> &str {
        self.name.as_str()
    }
}

impl Drop for LoopDevice {
    fn drop(&mut self) {
        if self.mountpoint.is_some() {
            if self.umount().is_err() {
                std::thread::sleep(Duration::from_secs(1));
                self.umount().unwrap();
            }
        }
        let status = Command::new("losetup")
            .arg("--detach")
            .arg(&self.name)
            .status()
            .unwrap();

        assert!(status.success());

        fs::remove_file(&self.path).unwrap();
    }
}

pub trait CommandExt {
    fn call(&mut self) -> Result<String, Box<dyn Error>>;
}

#[derive(Debug, Clone)]
pub struct CommandCallError {
    code: Option<i32>,
    stderr: String,
}
impl fmt::Display for CommandCallError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "exitcode: {:?}, stderr: {}", self.code, self.stderr)
    }
}
impl Error for CommandCallError {}

impl CommandExt for Command {
    fn call(&mut self) -> Result<String, Box<dyn Error>> {
        let output = self.output()?;
        if output.status.success() {
            Ok(String::from_utf8(output.stdout)?)
        } else {
            Err((CommandCallError {
                code: output.status.code(),
                stderr: String::from_utf8(output.stderr)?,
            })
            .into())
        }
    }
}

pub fn setup(device_path: PathBuf, mnt_dir: PathBuf) -> LoopDevice {
    let mut ret = LoopDevice::new(device_path);
    Command::new("mkfs.btrfs")
        .arg("-f")
        .arg(ret.name())
        .call()
        .unwrap();
    ret.mount(mnt_dir).unwrap();
    ret
}