ipfs-embed 0.3.1

small embeddable ipfs implementation
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

use crate::storage::key::Key;
use crate::storage::Storage;
use async_std::prelude::*;
use async_std::task::{Context, Poll};
use core::convert::TryFrom;
use core::pin::Pin;
use libipld::cid::Cid;
use sled::{Event, Subscriber};

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum NetworkEvent {
    Want(Cid),
    Cancel(Cid),
    Provide(Cid),
    Unprovide(Cid),
}

pub struct NetworkSubscriber {
    public: Subscriber,
    want: Subscriber,
}

impl Storage {
    pub fn watch_network(&self) -> NetworkSubscriber {
        log::trace!("watching public() with prefix {:?}", Key::Public.prefix());
        log::trace!("watching want() with prefix {:?}", Key::Want.prefix());
        NetworkSubscriber {
            public: self.tree.watch_prefix(Key::Public.prefix()),
            want: self.tree.watch_prefix(Key::Want.prefix()),
        }
    }
}

impl Stream for NetworkSubscriber {
    type Item = NetworkEvent;

    fn poll_next(mut self: Pin<&mut Self>, ctx: &mut Context) -> Poll<Option<Self::Item>> {
        match Pin::new(&mut self.want).poll(ctx) {
            Poll::Ready(Some(event)) => {
                let key = match &event {
                    Event::Insert { key, .. } => key,
                    Event::Remove { key } => key,
                };
                let cid = Cid::try_from(&key[1..]).expect("valid cid");
                let event = match event {
                    Event::Insert { .. } => {
                        log::trace!("emit want event {}", cid.to_string());
                        NetworkEvent::Want(cid)
                    }
                    Event::Remove { .. } => {
                        log::trace!("emit cancel event {}", cid.to_string());
                        NetworkEvent::Cancel(cid)
                    }
                };
                return Poll::Ready(Some(event));
            }
            Poll::Ready(None) => return Poll::Ready(None),
            Poll::Pending => {}
        }
        match Pin::new(&mut self.public).poll(ctx) {
            Poll::Ready(Some(event)) => {
                let key = match &event {
                    Event::Insert { key, .. } => key,
                    Event::Remove { key } => key,
                };
                let cid = Cid::try_from(&key[1..]).expect("valid cid");
                let event = match event {
                    Event::Insert { .. } => {
                        log::trace!("emit provide event {}", cid.to_string());
                        NetworkEvent::Provide(cid)
                    }
                    Event::Remove { .. } => {
                        log::trace!("emit unprovide event {}", cid.to_string());
                        NetworkEvent::Unprovide(cid)
                    }
                };
                return Poll::Ready(Some(event));
            }
            Poll::Ready(None) => return Poll::Ready(None),
            Poll::Pending => {}
        }
        Poll::Pending
    }
}