rust-ipfs 0.16.0

IPFS node 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

#[cfg(not(target_arch = "wasm32"))]
use connexa::keystore::store::fs::FilesystemKeystore as PersistenceKeystore;
use connexa::keystore::{EncryptedEntry, KeyMetadata, Keystore};

#[cfg(target_arch = "wasm32")]
use connexa::keystore::store::indexeddb::IndexedDbKeystore as PersistenceKeystore;

use connexa::keystore::store::memory::MemoryKeystore;
use either::Either;

use connexa::keystore::Error;

type KeystoreResult<T> = Result<T, Error>;

pub struct DefaultKeystore {
    keystore: Either<MemoryKeystore, PersistenceKeystore>,
}

impl Default for DefaultKeystore {
    fn default() -> Self {
        Self {
            keystore: Either::Left(MemoryKeystore::default()),
        }
    }
}

impl DefaultKeystore {
    #[cfg(not(target_arch = "wasm32"))]
    pub fn set_path(path: impl AsRef<std::path::Path>) -> Self {
        Self {
            keystore: Either::Right(PersistenceKeystore::new(path)),
        }
    }

    #[cfg(target_arch = "wasm32")]
    pub fn set_identifier(namespace: impl Into<Option<String>>) -> Self {
        let namespace = namespace.into();
        let namespace = namespace.unwrap_or_else(|| "rust-ipfs".into());
        Self {
            keystore: Either::Right(PersistenceKeystore::new(namespace)),
        }
    }
}

impl Keystore for DefaultKeystore {
    async fn put(&self, entry: EncryptedEntry) -> KeystoreResult<()> {
        match &self.keystore {
            Either::Left(keystore) => keystore.put(entry).await,
            Either::Right(keystore) => keystore.put(entry).await,
        }
    }

    async fn put_many(&self, entries: Vec<EncryptedEntry>) -> KeystoreResult<()> {
        match &self.keystore {
            Either::Left(keystore) => keystore.put_many(entries).await,
            Either::Right(keystore) => keystore.put_many(entries).await,
        }
    }

    async fn get(&self, label: &str) -> KeystoreResult<Option<EncryptedEntry>> {
        match &self.keystore {
            Either::Left(keystore) => keystore.get(label).await,
            Either::Right(keystore) => keystore.get(label).await,
        }
    }

    async fn list(&self) -> KeystoreResult<Vec<KeyMetadata>> {
        match &self.keystore {
            Either::Left(keystore) => keystore.list().await,
            Either::Right(keystore) => keystore.list().await,
        }
    }

    async fn remove(&self, label: &str) -> KeystoreResult<bool> {
        match &self.keystore {
            Either::Left(keystore) => keystore.remove(label).await,
            Either::Right(keystore) => keystore.remove(label).await,
        }
    }
}