nodedb 0.2.0

Local-first, real-time, edge-to-cloud hybrid database for multi-modal workloads
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

// SPDX-License-Identifier: BUSL-1.1

//! Bundle of everything needed to run the cluster after startup.

use std::sync::{Arc, Mutex, RwLock};

use nodedb_cluster::GroupAppliedWatchers;

/// Pending cluster-subsystem startup state.
///
/// Stashed on [`ClusterHandle`] by `init_cluster` and consumed by
/// `start_raft` after `RaftLoop::new` has produced its
/// `Arc<Mutex<MultiRaft>>`. Subsystems share that loop-owned Arc, so
/// they cannot be spawned at `init_cluster` time — see the doc on
/// `nodedb_cluster::start_cluster` for the two-phase startup
/// rationale.
pub struct PendingSubsystems {
    pub config: nodedb_cluster::ClusterConfig,
}

/// Everything the main server needs to wire the cluster into the rest of
/// the process. Produced by [`super::init::init_cluster`] and consumed by
/// [`super::start_raft::start_raft`].
pub struct ClusterHandle {
    /// The QUIC transport (for serving and sending RPCs).
    pub transport: Arc<nodedb_cluster::NexarTransport>,
    /// Cluster topology (shared with SharedState).
    pub topology: Arc<RwLock<nodedb_cluster::ClusterTopology>>,
    /// Cluster routing table (shared with SharedState).
    pub routing: Arc<RwLock<nodedb_cluster::RoutingTable>>,
    /// Lifecycle phase tracker shared with `start_cluster` and the
    /// `/cluster/status` + metrics readers.
    pub lifecycle: nodedb_cluster::ClusterLifecycleTracker,
    /// Live replicated metadata cache. Populated by the
    /// `MetadataCommitApplier` and shared with `SharedState` so planners,
    /// pgwire handlers, and HTTP catalog endpoints can read descriptors
    /// without going back to redb.
    pub metadata_cache: Arc<RwLock<nodedb_cluster::MetadataCache>>,
    /// Per-Raft-group apply watermark registry. Shared with the
    /// `RaftLoop` (which bumps it on apply / snapshot install) and
    /// with `SharedState` (where proposers and consistent-read paths
    /// look up the watcher for the group whose proposal they made).
    pub group_watchers: Arc<GroupAppliedWatchers>,
    /// This node's ID.
    pub node_id: u64,
    /// `MultiRaft` constructed by `start_cluster` with the correct
    /// voter / learner membership already applied. `start_raft` takes
    /// this via `Mutex::lock + .take()` and moves it into the
    /// `RaftLoop`. Wrapped in `Mutex<Option<_>>` so the handle itself
    /// stays `Clone` while still guaranteeing single-transfer
    /// semantics at runtime.
    pub multi_raft: Mutex<Option<nodedb_cluster::MultiRaft>>,
    /// Cluster catalog (redb-backed topology + routing persistence).
    /// Shared with the `HealthMonitor` for persisting topology changes
    /// on failure detection and recovery.
    pub catalog: Arc<nodedb_cluster::ClusterCatalog>,
    /// Running subsystem tasks (SWIM, Reachability, Decommission,
    /// Rebalancer). Set by `start_raft` after `RaftLoop::new` produces
    /// the shared `Arc<Mutex<MultiRaft>>` that subsystems must clone.
    /// `Mutex<Option<...>>` because the value is filled in later than
    /// the surrounding handle is constructed; once set, it must be
    /// retained for the lifetime of the cluster.
    pub running_cluster: Mutex<Option<nodedb_cluster::RunningCluster>>,
    /// Cluster-subsystem startup state to apply once `RaftLoop` is up.
    /// Consumed by `start_raft` (taken via `Mutex::take`) when it
    /// calls [`nodedb_cluster::start_cluster_subsystems`] with the
    /// loop's shared `multi_raft` handle.
    pub pending_subsystems: Mutex<Option<PendingSubsystems>>,
}