blockstore 0.8.0

An IPLD blockstore capable of holding arbitrary data indexed by CID
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use std::fmt::{self, Debug};
use std::pin::pin;
use std::sync::Arc;

use tokio::sync::Notify;

pub(crate) struct Counter {
    counter: Arc<()>,
    notify: Arc<Notify>,
}

pub(crate) struct CounterGuard {
    counter: Option<Arc<()>>,
    notify: Arc<Notify>,
}

impl Drop for CounterGuard {
    fn drop(&mut self) {
        self.counter.take();
        self.notify.notify_waiters();
    }
}

impl Counter {
    pub(crate) fn new() -> Counter {
        Counter {
            counter: Arc::new(()),
            notify: Arc::new(Notify::new()),
        }
    }

    pub(crate) fn guard(&self) -> CounterGuard {
        CounterGuard {
            counter: Some(self.counter.clone()),
            notify: self.notify.clone(),
        }
    }

    /// Wait all guards to drop.
    pub(crate) async fn wait_guards(&mut self) {
        let mut notified = pin!(self.notify.notified());

        while Arc::strong_count(&self.counter) > 1 {
            notified.as_mut().await;
            notified.set(self.notify.notified());
        }
    }
}

impl Debug for Counter {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("Counter { .. }")
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::time::{Duration, Instant};
    use tokio::spawn;
    use tokio::time::{sleep, timeout};

    #[tokio::test]
    async fn counter_works() {
        let mut counter = Counter::new();
        counter.wait_guards().await;

        let guard1 = counter.guard();
        let guard2 = counter.guard();
        let now = Instant::now();

        spawn(async move {
            let _guard = guard1;
            sleep(Duration::from_millis(100)).await;
        });

        spawn(async move {
            let _guard = guard2;
            sleep(Duration::from_millis(200)).await;
        });

        timeout(Duration::from_millis(300), counter.wait_guards())
            .await
            .unwrap();

        let elapsed = now.elapsed();
        assert!(elapsed >= Duration::from_millis(200) && elapsed < Duration::from_millis(300));
    }
}