samod 0.9.0

A rust library for managing automerge documents, compatible with the js automerge-repo library
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::sync::Arc;

use samod_core::PeerId;

use crate::{
    Repo,
    announce_policy::{AlwaysAnnounce, AnnouncePolicy, LocalAnnouncePolicy},
    observer::RepoObserver,
    runtime::{LocalRuntimeHandle, RuntimeHandle},
    storage::{InMemoryStorage, LocalStorage, Storage},
};

/// How to run concurrent documents
///
/// See the [concurrency section](./index.html#concurrency) of the module level
/// documentation
pub enum ConcurrencyConfig {
    /// Run each document in a separate task on the async runtime
    AsyncRuntime,
    /// Run each document on a rayon threadpool
    #[cfg(feature = "threadpool")]
    Threadpool(rayon::ThreadPool),
}

/// A struct for configuring a [`Repo`](crate::Repo)
///
/// ## `Send` and non-`Send` futures
///
/// Once you've finished configuring the builder, you call either [`load`](Self::load) or
/// [`load_local`](Self::load_local) to create a [`Repo`]. The difference between the two is that
/// [`load`](Self::load) is only available for runtimes which implement `RuntimeHandle` and
/// thus require `Send` futures (such as tokio). [`load_local`](Self::load_local) on the other
/// hand works with runtimes that implement [`LocalRuntimeHandle`] and thus does
/// not require [`Send`] futures. If you want to use
/// [`load_local`](Self::load_local) you need to configure the storage and
/// announce policy implementations to be implementations of [`LocalStorage`]
/// and [`LocalAnnouncePolicy`] respectively. See the [module level
/// documentation on runtimes](./index.html#runtimes) for more details.
pub struct RepoBuilder<S, R, A> {
    pub(crate) storage: S,
    pub(crate) runtime: R,
    pub(crate) announce_policy: A,
    pub(crate) peer_id: Option<PeerId>,
    pub(crate) concurrency: ConcurrencyConfig,
    pub(crate) observer: Option<Arc<dyn RepoObserver>>,
}

impl<S, R, A> RepoBuilder<S, R, A> {
    pub fn with_storage<S2>(self, storage: S2) -> RepoBuilder<S2, R, A> {
        RepoBuilder {
            storage,
            peer_id: self.peer_id,
            runtime: self.runtime,
            announce_policy: self.announce_policy,
            concurrency: self.concurrency,
            observer: self.observer,
        }
    }

    pub fn with_runtime<R2>(self, runtime: R2) -> RepoBuilder<S, R2, A> {
        RepoBuilder {
            runtime,
            peer_id: self.peer_id,
            storage: self.storage,
            announce_policy: self.announce_policy,
            concurrency: self.concurrency,
            observer: self.observer,
        }
    }

    pub fn with_peer_id(mut self, peer_id: PeerId) -> Self {
        self.peer_id = Some(peer_id);
        self
    }

    pub fn with_announce_policy<A2>(self, announce_policy: A2) -> RepoBuilder<S, R, A2> {
        RepoBuilder {
            runtime: self.runtime,
            peer_id: self.peer_id,
            storage: self.storage,
            announce_policy,
            concurrency: self.concurrency,
            observer: self.observer,
        }
    }

    /// Configure how the repository should process concurrent documents
    ///
    /// See the [concurrency section](./index.html#concurrency) of the module level
    /// documentation
    pub fn with_concurrency(mut self, concurrency: ConcurrencyConfig) -> Self {
        self.concurrency = concurrency;
        self
    }

    /// Set an observer for receiving structured observability events.
    pub fn with_observer(mut self, observer: impl RepoObserver) -> Self {
        self.observer = Some(Arc::new(observer));
        self
    }
}

impl<R> RepoBuilder<InMemoryStorage, R, AlwaysAnnounce> {
    pub fn new(runtime: R) -> RepoBuilder<InMemoryStorage, R, AlwaysAnnounce> {
        RepoBuilder {
            storage: InMemoryStorage::new(),
            runtime,
            peer_id: None,
            announce_policy: AlwaysAnnounce,
            concurrency: ConcurrencyConfig::AsyncRuntime,
            observer: None,
        }
    }
}

impl<S: Storage, R: RuntimeHandle + Clone + Send, A: AnnouncePolicy> RepoBuilder<S, R, A> {
    /// Create the repository
    pub async fn load(self) -> Repo {
        Repo::load(self).await
    }
}

impl<S: LocalStorage, R: LocalRuntimeHandle + Clone + 'static, A: LocalAnnouncePolicy>
    RepoBuilder<S, R, A>
{
    /// Create the repository
    pub async fn load_local(self) -> Repo {
        Repo::load_local(self).await
    }
}