aranya-daemon 6.0.0

Daemon process for syncing with Aranya peers and maintaining the DAG
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! Aranya syncer used to send/receive graph commands to other peers.

mod client;
mod handle;
mod manager;
mod server;
mod transport;
mod types;

use aranya_runtime::GraphId;
use aranya_util::Addr;

#[cfg(feature = "preview")]
pub(crate) use self::types::HelloSubscription;
pub(super) use self::types::SyncResponse;
pub(crate) use self::{
    client::SyncClient, handle::SyncHandle, manager::SyncManager, server::SyncServer,
    transport::quic, types::SyncPeer,
};

/// The error type which is returned from syncing with peers.
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub(crate) enum Error {
    // TODO(nikki): decide if we want to add a generic.
    /// Something went wrong with the transport layer.
    #[error(transparent)]
    Transport(Box<dyn std::error::Error + Send + Sync + 'static>),

    /// Something went wrong in the Aranya Runtime.
    #[error(transparent)]
    Runtime(#[from] aranya_runtime::SyncError),

    /// Something went wrong in the Aranya Client.
    #[error(transparent)]
    AranyaClient(#[from] aranya_runtime::ClientError),

    /// `postcard` was unable to de/serialize a message into a `SyncType`.
    #[error("postcard failed to de/serialize a message")]
    Postcard(#[from] postcard::Error),

    /// Peer sent an empty response.
    #[cfg(feature = "preview")]
    #[error("peer sent empty response")]
    EmptyResponse,

    /// Failed to collect effects from the sink.
    #[error("failed to collect effects")]
    EffectsSink(#[source] Box<dyn std::error::Error + Send + Sync>),

    /// The syncer is in the middle of shutting down at the end of runtime.
    #[error("the sync manager has shut down")]
    SyncerShutdown,

    /// The server received an invalid/unexpected request.
    #[error("received an invalid request")]
    InvalidRequest,

    /// The server told us that an error occurred while processing a request.
    #[error("the server indicated a sync error")]
    Response(String),

    /// Encountered a bug in the program.
    #[error(transparent)]
    Bug(#[from] buggy::Bug),
}

// Implements this error type to allow it being sent over RPC.
impl From<Error> for aranya_daemon_api::Error {
    #[inline]
    fn from(err: Error) -> Self {
        Self::from_err(err)
    }
}

// Allows Infallible types to be desugared properly with ?.
impl From<std::convert::Infallible> for Error {
    fn from(err: std::convert::Infallible) -> Self {
        match err {}
    }
}

impl Error {
    fn transport(err: impl std::error::Error + Send + Sync + 'static) -> Self {
        Self::Transport(Box::new(err))
    }

    /// Returns whether a `ParallelFinalize` error occurred, which needs to be resolved manually.
    fn is_parallel_finalize(&self) -> bool {
        matches!(
            self,
            Self::AranyaClient(aranya_runtime::ClientError::ParallelFinalize)
        )
    }
}

/// A specialized Result type for sync operations.
///
/// This type is used broadly across [`aranya_daemon::sync`] for any operation which may produce an
/// error.
///
/// This type alias is generally used to avoid writing out [`sync::Error`] directly and is otherwise
/// a direct mapping to [`Result`].
///
/// [`aranya_daemon::sync`]: crate::sync
/// [`sync::Error`]: Error
/// [`Result`]: std::result::Result
type Result<T> = core::result::Result<T, Error>;