Struct RSync 

pub struct RSync { /* private fields */ }

Implementations

impl RSync

pub fn new(source: ReaderWriter, dest: ReaderWriter) -> Self

pub fn with_restore_fs_mtime(self, restore_fs_mtime: bool) -> Self

pub fn with_includes(self, includes: &[&str]) -> RSyncResult<Self>

pub fn with_excludes(self, excludes: &[&str]) -> RSyncResult<Self>

pub async fn sync( &self, ) -> impl Stream<Item = RSyncResult<impl Future<Output = RSyncResult<RSyncStatus>> + '_>> + '_

Sync synchronize source to destination by comparing crc32c if destination already exists

Example

use std::{path::PathBuf, str::FromStr};

use futures::{StreamExt, TryStreamExt};
use gcs_rsync::{
    storage::credentials::authorizeduser,
    sync::{RSync, RSyncResult, ReaderWriter},
};

#[tokio::main]
async fn main() -> RSyncResult<()> {
    let token_generator = Box::new(authorizeduser::default().await.unwrap());

    let home_dir = ".";
    let test_prefix = "bucket_prefix_to_sync";
    let bucket = "bucket_name";

    let source = ReaderWriter::gcs(token_generator, bucket, test_prefix)
        .await
        .unwrap();

    let dest_folder = {
        let mut p = PathBuf::from_str(home_dir).unwrap();
        p.push(test_prefix);
        p
    };
    let dest = ReaderWriter::fs(dest_folder.as_path());

    let rsync = RSync::new(source, dest);

    rsync
        .sync()
        .await
        .try_buffer_unordered(12)
        .for_each(|x| {
            println!("{:?}", x);
            futures::future::ready(())
        })
        .await;

    Ok(())
}

pub async fn mirror( &self, ) -> RSyncResult<impl Stream<Item = RSyncResult<impl Future<Output = RSyncResult<RMirrorStatus>> + '_>> + '_>

Mirror synchronize source to destination by deleting extras (destination)

Example

use std::{path::PathBuf, str::FromStr};

use futures::{StreamExt, TryStreamExt};
use gcs_rsync::{
    storage::credentials::authorizeduser,
    sync::{RSync, RSyncResult, ReaderWriter},
};

#[tokio::main]
async fn main() -> RSyncResult<()> {
    let token_generator = Box::new(authorizeduser::default().await.unwrap());

    let home_dir = ".";
    let test_prefix = "bucket_prefix_to_sync";
    let bucket = "bucket_name";

    let source = ReaderWriter::gcs(token_generator, bucket, test_prefix)
        .await
        .unwrap();

    let dest_folder = {
        let mut p = PathBuf::from_str(home_dir).unwrap();
        p.push(test_prefix);
        p
    };
    let dest = ReaderWriter::fs(dest_folder.as_path());

    let rsync = RSync::new(source, dest);

    match rsync.mirror().await {
        Ok(mirror_result) => {
            mirror_result
                .try_buffer_unordered(12)
                .for_each(|x| {
                    println!("{:?}", x);
                    futures::future::ready(())
                })
                .await;
        }
        Err(e) => {
            println!("cannot mirror due to error {:?}", e);
        },
    };
    Ok(())
}