libguix 0.1.3

Unofficial Rust client library for GNU Guix.
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

//! `guix gc` — store-wide garbage collection.

use std::time::Duration;

use crate::cmd::guix_cmd;
use crate::error::GuixError;
use crate::operation::{spawn_operation, Operation};
use crate::Guix;

#[derive(Clone)]
pub struct GcOps {
    guix: Guix,
}

impl GcOps {
    pub(crate) fn new(guix: Guix) -> Self {
        Self { guix }
    }

    /// Does **not** thread `-p` — `gc` is store-wide.
    pub fn run(&self, opts: GcOptions) -> Result<Operation, GuixError> {
        let mut args: Vec<String> = vec!["gc".into()];
        if let Some(free) = opts.free_space {
            args.push(format!("-F{}", free.as_bytes()));
        }
        if let Some(d) = opts.delete_unused_after {
            args.push(format!("--delete-generations={}s", d.as_secs()));
        }
        if opts.verify {
            args.push("--verify".into());
        }
        let c = guix_cmd(
            self.guix.binary_path(),
            self.guix.profile_path(),
            false,
            &args,
        );
        spawn_operation(c)
    }
}

#[derive(Debug, Clone, Copy)]
pub struct ByteSize(u64);

impl ByteSize {
    pub fn bytes(n: u64) -> Self {
        Self(n)
    }
    pub fn megabytes(n: u64) -> Self {
        Self(n * 1_000_000)
    }
    pub fn gigabytes(n: u64) -> Self {
        Self(n * 1_000_000_000)
    }
    pub fn as_bytes(self) -> u64 {
        self.0
    }
}

#[derive(Debug, Clone, Default)]
pub struct GcOptions {
    pub free_space: Option<ByteSize>,
    pub delete_unused_after: Option<Duration>,
    pub verify: bool,
}