zrb 0.3.0

Incremental ZFS snapshot replication over SSH with resumable transfers and retention-based pruning
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

use std::process::Stdio;

use thiserror::Error;
use tokio::process::{Child, ChildStdin, ChildStdout, Command};

use crate::config::RemoteConfig;

#[derive(Debug, Error)]
pub enum TransportError {
    #[error("SSH connect to {destination}: {source}")]
    Spawn {
        destination: String,
        source: std::io::Error,
    },
}

pub struct SshConnection {
    pub stdin: ChildStdin,
    pub stdout: ChildStdout,
    pub child: Child,
}

/// Spawn `ssh` to `remote` with optional extra arguments and return piped stdio.
///
/// The caller reads/writes the zrb Protocol directly over `stdout`/`stdin`.
/// Call `child.wait().await` after the session ends to reap the process.
///
/// # Errors
/// Returns [`TransportError::Spawn`] if the `ssh` process cannot be started.
///
/// # Panics
/// Never panics — stdin/stdout are always present because `Stdio::piped()` is set unconditionally.
pub fn connect(
    remote: &RemoteConfig,
    extra_opts: &[String],
) -> Result<SshConnection, TransportError> {
    let mut cmd = Command::new("ssh");
    if let Some(port) = remote.port {
        cmd.arg("-p").arg(port.to_string());
    }
    if let Some(user) = &remote.user {
        cmd.arg("-l").arg(user);
    }
    if let Some(key) = &remote.ssh_key {
        cmd.arg("-i").arg(key);
    }
    for opt in &remote.ssh_opts {
        cmd.arg(opt);
    }
    for opt in extra_opts {
        cmd.arg(opt);
    }
    cmd.arg(&remote.host);
    cmd.arg("zrb server");
    cmd.stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::inherit());
    let destination = match remote.port {
        Some(p) => format!("{}:{}", remote.host, p),
        None => remote.host.clone(),
    };
    log::debug!("ssh connect {destination}");
    let mut child = cmd.spawn().map_err(|source| TransportError::Spawn {
        destination,
        source,
    })?;
    let stdin = child.stdin.take().expect("stdin piped");
    let stdout = child.stdout.take().expect("stdout piped");
    Ok(SshConnection {
        stdin,
        stdout,
        child,
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn spawn_error_includes_host_and_port() {
        let err = TransportError::Spawn {
            destination: "nas.local:2222".to_owned(),
            source: std::io::Error::new(std::io::ErrorKind::NotFound, "No such file"),
        };
        let msg = err.to_string();
        assert!(msg.contains("nas.local"), "missing host in: {msg}");
        assert!(msg.contains("2222"), "missing port in: {msg}");
    }

    #[test]
    fn spawn_error_without_port_has_no_port_number() {
        let err = TransportError::Spawn {
            destination: "nas.local".to_owned(),
            source: std::io::Error::new(std::io::ErrorKind::NotFound, "No such file"),
        };
        let msg = err.to_string();
        assert!(
            msg.starts_with("SSH connect to nas.local: "),
            "unexpected format: {msg}"
        );
    }
}