nodedb 0.4.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
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

// SPDX-License-Identifier: BUSL-1.1

//! Surrogate WAL replay and superuser credential bootstrap.

use std::sync::Arc;

use tracing::{info, warn};

use crate::ServerConfig;
use crate::control::state::SharedState;
use nodedb_wal::WalRecord;

/// Replay surrogate WAL records into the surrogate registry.
///
/// Exits the process if replay fails — a partially-recovered surrogate
/// registry is not safe to continue with.
pub fn replay_surrogate_wal(shared: &Arc<SharedState>, wal_records: &Arc<[WalRecord]>) {
    {
        let catalog = shared.credentials.catalog();
        match crate::wal::replay::replay_surrogate_records(
            wal_records,
            catalog,
            &shared.surrogate_registry,
        ) {
            Ok(stats) => {
                if stats.allocs > 0 || stats.binds > 0 {
                    info!(
                        allocs = stats.allocs,
                        binds = stats.binds,
                        "WAL surrogate replay complete"
                    );
                }
            }
            Err(e) => {
                tracing::error!(
                    error = %e,
                    "StartupError: surrogate WAL replay failed — refusing to start \
                     with a partially-recovered surrogate registry"
                );
                std::process::exit(1);
            }
        }
    }
}

/// Materialize the configured superuser before any listener starts.
pub fn bootstrap_superuser(shared: &Arc<SharedState>, config: &ServerConfig) -> anyhow::Result<()> {
    match &config.auth.mode {
        crate::config::auth::AuthMode::Trust => {
            shared
                .credentials
                .bootstrap_trust_superuser(&config.auth.superuser_name)?;
            info!(
                user = config.auth.superuser_name,
                mode = ?config.auth.mode,
                "trust-mode superuser bootstrapped"
            );
            warn!("╔══════════════════════════════════════════════════════════════╗");
            warn!("║  WARNING: NodeDB is running in TRUST mode.                  ║");
            warn!("║  Password credentials are NOT verified.                    ║");
            warn!("║  This is UNSAFE for any environment beyond local dev/CI.    ║");
            warn!("║  Set auth.mode = \"password\" (or \"certificate\") to require   ║");
            warn!("║  credentials. Trust mode must be an explicit operator       ║");
            warn!("║  opt-in — it is never the NodeDB default.                   ║");
            warn!("╚══════════════════════════════════════════════════════════════╝");
        }
        crate::config::auth::AuthMode::Password | crate::config::auth::AuthMode::Certificate => {
            let password = config
                .auth
                .resolve_superuser_password(&config.server.data_dir)?
                .ok_or_else(|| crate::Error::Config {
                    detail: "superuser password resolution returned no credential".into(),
                })?;
            shared
                .credentials
                .bootstrap_superuser(&config.auth.superuser_name, &password)?;
            info!(
                user = config.auth.superuser_name,
                mode = ?config.auth.mode,
                "superuser bootstrapped"
            );
        }
    }
    Ok(())
}

/// Print the startup banner and, if in trust mode, the trust-mode warning box.
pub fn print_startup_banner(config: &ServerConfig, cluster_mode_str: &str) {
    eprintln!(
        "{}",
        crate::version::format_banner(
            config.server.ports.pgwire,
            config.server.ports.http,
            config.server.ports.native,
            cluster_mode_str,
            &config.server.data_dir.display().to_string(),
            &format!("{:?}", config.auth.mode),
        )
    );
    if config.auth.mode == crate::config::auth::AuthMode::Trust {
        eprintln!("  ╔══════════════════════════════════════════════════════════════╗");
        eprintln!("  ║  WARNING: TRUST MODE — connections accepted without         ║");
        eprintln!("  ║  credentials. Unsafe outside local dev / CI.                ║");
        eprintln!("  ║  Set auth.mode = \"password\" to require credentials.         ║");
        eprintln!("  ╚══════════════════════════════════════════════════════════════╝");
        eprintln!();
    }
}