ripsync 1.2.0

A fast, memory-safe rsync alternative for local and SSH sync — rsync's superpower, none of its footguns.
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

//! Cross-process remote-protocol test: spawn the real `ripsync --server` binary
//! and drive it over OS pipes with the core initiator. This validates the
//! `--server` argv intercept, the server dispatch, and the framing over actual
//! pipes (not the in-process channel used by the core's `net_pipe` test).

use std::fs;
use std::process::{Command, Stdio};

use assert_cmd::cargo::CommandCargoExt;
use ripsync_core::Filter;
use ripsync_core::RunControl;
use ripsync_core::net::proto::{NetOptions, Role};
use ripsync_core::net::run_initiator;
use ripsync_core::net::transport::IoDuplex;
use ripsync_core::report::NullReporter;

#[test]
fn server_binary_push_over_pipes() {
    let tmp = tempfile::tempdir().unwrap();
    let src = tmp.path().join("src");
    let dst = tmp.path().join("dst");
    fs::create_dir_all(src.join("a")).unwrap();
    fs::write(src.join("a/x.txt"), "hello over a real pipe\n").unwrap();
    fs::write(src.join("top.bin"), vec![3u8; 2048]).unwrap();
    fs::create_dir_all(&dst).unwrap();

    // Spawn the actual binary as the far-end peer.
    let mut child = Command::cargo_bin("ripsync")
        .unwrap()
        .arg("--server")
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::inherit())
        .spawn()
        .expect("spawn ripsync --server");

    let stdout = child.stdout.take().unwrap();
    let stdin = child.stdin.take().unwrap();
    let mut conn = IoDuplex::new(stdout, stdin);

    let ctrl = RunControl::default();
    let excludes = Filter::none();
    let options = NetOptions {
        preserve_mtime: true,
        ..NetOptions::default()
    };
    let stats = run_initiator(
        &mut conn,
        Role::Push,
        &src,
        &dst,
        options,
        &excludes,
        0,
        &ctrl,
        &NullReporter,
    )
    .expect("push to ripsync --server");

    drop(conn);
    let _ = child.wait();

    assert_eq!(stats.errors, 0, "transfer reported errors");
    assert_eq!(
        fs::read_to_string(dst.join("a/x.txt")).unwrap(),
        "hello over a real pipe\n"
    );
    assert_eq!(fs::read(dst.join("top.bin")).unwrap(), vec![3u8; 2048]);
}