1use serde::{Deserialize, Serialize};
2pub use tokio::sync::broadcast::{self, Receiver, Sender};
3use tracing::*;
4use uuid::Uuid;
5
6use crate::{LbErrKind, LocalLb};
7
8#[derive(Clone)]
9pub struct EventSubs {
10 tx: Sender<Event>,
11}
12
13#[derive(Clone, Debug, Serialize, Deserialize)]
14pub enum Event {
15 MetadataChanged(Actor),
19
20 DocumentWritten(Uuid, Actor),
23
24 PendingSharesChanged,
25
26 Sync(SyncIncrement),
27
28 StatusUpdated,
29
30 UserSignedIn,
31}
32
33#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
34pub enum Actor {
35 User,
36 Sync,
37}
38
39impl Default for EventSubs {
40 fn default() -> Self {
41 let (tx, _) = broadcast::channel::<Event>(10000);
42 Self { tx }
43 }
44}
45
46impl EventSubs {
47 pub(crate) fn pending_shares_changed(&self) {
48 self.queue(Event::PendingSharesChanged);
49 }
50
51 pub(crate) fn meta_changed(&self, actor: Actor) {
52 self.queue(Event::MetadataChanged(actor));
53 }
54
55 pub(crate) fn doc_written(&self, id: Uuid, actor: Actor) {
56 self.queue(Event::DocumentWritten(id, actor));
57 }
58
59 pub(crate) fn sync_update(&self, s: SyncIncrement) {
60 self.queue(Event::Sync(s));
61 }
62
63 pub(crate) fn status_updated(&self) {
64 self.queue(Event::StatusUpdated);
65 }
66
67 pub(crate) fn signed_in(&self) {
69 self.queue(Event::UserSignedIn);
70 }
71
72 fn queue(&self, evt: Event) {
73 if let Err(e) = self.tx.send(evt.clone()) {
74 error!(?evt, ?e, "could not queue");
75 }
76 }
77}
78
79impl LocalLb {
80 pub fn subscribe(&self) -> Receiver<Event> {
81 self.events.tx.subscribe()
82 }
83}
84
85#[derive(Debug, Clone, Serialize, Deserialize)]
86pub enum SyncIncrement {
87 SyncStarted,
88 PullingDocument(Uuid, bool),
89 PushingDocument(Uuid, bool),
90 SyncFinished(Option<LbErrKind>),
91}