libzetta 0.5.0

libzetta is a stable interface for programmatic administration of ZFS
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

use crate::zfs::{
    lzc::ZfsLzc, open3::ZfsOpen3, BookmarkRequest, CreateDatasetRequest, DatasetKind,
    DestroyTiming, Properties, Result, SendFlags, ZfsEngine,
};
use std::{collections::HashMap, os::unix::io::AsRawFd, path::PathBuf};

/// Handy wrapper that delegates your call to correct implementation.
pub struct DelegatingZfsEngine {
    lzc: ZfsLzc,
    open3: ZfsOpen3,
}

impl DelegatingZfsEngine {
    pub fn new() -> Result<Self> {
        let lzc = ZfsLzc::new()?;
        let open3 = ZfsOpen3::new();
        Ok(DelegatingZfsEngine { lzc, open3 })
    }
}

impl ZfsEngine for DelegatingZfsEngine {
    fn exists<N: Into<PathBuf>>(&self, name: N) -> Result<bool> {
        self.lzc.exists(name)
    }

    fn create(&self, request: CreateDatasetRequest) -> Result<()> {
        self.lzc.create(request)
    }

    fn snapshot(
        &self,
        snapshots: &[PathBuf],
        user_properties: Option<HashMap<String, String>>,
    ) -> Result<()> {
        self.lzc.snapshot(snapshots, user_properties)
    }

    fn bookmark(&self, bookmarks: &[BookmarkRequest]) -> Result<()> {
        self.lzc.bookmark(bookmarks)
    }

    fn destroy<N: Into<PathBuf>>(&self, name: N) -> Result<()> {
        self.open3.destroy(name)
    }

    fn destroy_snapshots(&self, snapshots: &[PathBuf], timing: DestroyTiming) -> Result<()> {
        self.lzc.destroy_snapshots(snapshots, timing)
    }

    fn destroy_bookmarks(&self, bookmarks: &[PathBuf]) -> Result<()> {
        self.lzc.destroy_bookmarks(bookmarks)
    }

    fn list<N: Into<PathBuf>>(&self, pool: N) -> Result<Vec<(DatasetKind, PathBuf)>> {
        self.open3.list(pool)
    }

    fn list_filesystems<N: Into<PathBuf>>(&self, pool: N) -> Result<Vec<PathBuf>> {
        self.open3.list_filesystems(pool)
    }

    fn list_snapshots<N: Into<PathBuf>>(&self, pool: N) -> Result<Vec<PathBuf>> {
        self.open3.list_snapshots(pool)
    }

    fn list_bookmarks<N: Into<PathBuf>>(&self, pool: N) -> Result<Vec<PathBuf>> {
        self.open3.list_bookmarks(pool)
    }

    fn list_volumes<N: Into<PathBuf>>(&self, pool: N) -> Result<Vec<PathBuf>> {
        self.open3.list_volumes(pool)
    }

    fn read_properties<N: Into<PathBuf>>(&self, path: N) -> Result<Properties> {
        self.open3.read_properties(path)
    }

    fn send_full<N: Into<PathBuf>, FD: AsRawFd>(
        &self,
        path: N,
        fd: FD,
        flags: SendFlags,
    ) -> Result<()> {
        self.lzc.send_full(path, fd, flags)
    }

    fn send_incremental<N: Into<PathBuf>, F: Into<PathBuf>, FD: AsRawFd>(
        &self,
        path: N,
        from: F,
        fd: FD,
        flags: SendFlags,
    ) -> Result<()> {
        self.lzc.send_incremental(path, from, fd, flags)
    }

    fn run_channel_program<N: Into<PathBuf>>(
        &self,
        pool: N,
        program: &str,
        instr_limit: u64,
        mem_limit: u64,
        sync: bool,
        args: libnv::nvpair::NvList,
    ) -> Result<libnv::nvpair::NvList> {
        self.lzc
            .run_channel_program(pool, program, instr_limit, mem_limit, sync, args)
    }
}