Crate rustsync

An implementation of an rsync-like protocol (not compatible with rsync), in pure Rust.

extern crate rand;
extern crate rustsync;
use rustsync::*;
use rand::Rng;
fn main() {
  // Create 4 different random strings first.
  let chunk_size = 1000;
  let a = rand::thread_rng()
          .gen_ascii_chars()
          .take(chunk_size)
          .collect::<String>();
  let b = rand::thread_rng()
          .gen_ascii_chars()
          .take(chunk_size)
          .collect::<String>();
  let b_ = rand::thread_rng()
          .gen_ascii_chars()
          .take(chunk_size * 2)
          .collect::<String>();
  let c = rand::thread_rng()
          .gen_ascii_chars()
          .take(chunk_size)
          .collect::<String>();

  // Now concatenate them in two different ways.

  let mut source = a.clone() + &b + &c;
  let mut modified = a + &b_ + &c;

  // Fake the rsync protocol with block size 32.
  // Here, think of `source` as a file we want to download,
  // and `modified` is a local copy.

  let block = [0; 32];
  let source_sig = signature(source.as_bytes(), block).unwrap();
  let comp = compare(&source_sig, modified.as_bytes(), block).unwrap();

  let mut restored = Vec::new();
  restore_seek(&mut restored, std::io::Cursor::new(source.as_bytes()), vec![0; 1000], &comp).unwrap();
  assert_eq!(&restored[..], modified.as_bytes())
}

Structs

Delta	The result of comparing two files
FutureCompare
FutureRestore
FutureSignature
ReadBlock
Signature	The "signature" of the file, which is essentially a content-indexed description of the blocks in the file.
WriteBlock

Enums

Block

Functions

compare	Compare a signature with an existing file. This is the second step of the protocol, r is the local file when downloading, and the remote file when uploading.
compare_fut	Same as compare, except that this function reads the file asynchronously.
restore	Restore a file, using a "delta" (resulting from compare)
restore_seek	Same as restore, except that this function uses a seekable, readable stream instead of the entire file in a slice.
restore_seek_fut	Same as restore_seek, except that this function writes its output asynchronously.
signature	Create the "signature" of a file, essentially a content-indexed map of blocks. The first step of the protocol is to run this function on the "source" (the remote file when downloading, the local file while uploading).
signature_fut	This is the same as signature, except that this function reads the input source asynchronously.