syncfast 0.2.0

rsync/rdiff/zsync clone
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

use futures::future::{FutureExt, Map};
use futures::channel::oneshot::{Canceled, Receiver, Sender, channel};
use std::path::Path;

pub struct Condition {
    sender: Option<Sender<()>>,
    receiver: Option<Receiver<()>>,
}

impl Default for Condition {
    fn default() -> Self {
        let (sender, receiver) = channel();
        Condition { sender: Some(sender), receiver: Some(receiver) }
    }
}

pub type ConditionFuture = Map<Receiver<()>, fn(Result<(), Canceled>)>;

impl Condition {
    pub fn set(&mut self) {
        let sender = self.sender.take().expect("Condition::set() called twice");
        sender.send(()).expect("Condition::set()");
    }

    pub fn wait(&mut self) -> ConditionFuture {
        fn error(r: Result<(), Canceled>) {
            r.expect("Condition::wait()");
        }
        self.receiver.take().expect("Condition::wait() called twice").map(error)
    }
}

pub fn move_file(from: &Path, to: &Path) -> std::io::Result<()> {
    match std::fs::rename(from, to) {
        Ok(()) => Ok(()),
        Err(_) => {
            // Try copying then removing source file
            std::fs::copy(from, to)?;
            match std::fs::remove_file(from) {
                Ok(()) => Ok(()),
                Err(e) => {
                    std::fs::remove_file(to).ok(); // Ignore this result on purpose
                    Err(e)
                }
            }
        }
    }
}