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(50)
          .collect::<String>();
  let b_ = rand::thread_rng()
          .gen_ascii_chars()
          .take(100)
          .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;

  // Suppose we want to download `modified`, and we already have
  // `source`, which only differs by a few characters in the
  // middle.

  // We first have to choose a block size, which will be recorded
  // in the signature below. Blocks should normally be much bigger
  // than this in order to be efficient on large files.

  let block = [0; 32];

  // We then create a signature of `source`, to be uploaded to the
  // remote machine. Signatures are typically much smaller than
  // files, with just a few bytes per block.

  let source_sig = signature(source.as_bytes(), block).unwrap();

  // Then, we let the server compare our signature with their
  // version.

  let comp = compare(&source_sig, modified.as_bytes(), block).unwrap();

  // We finally download the result of that comparison, and
  // restore their file from that.

  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.