aboutsummaryrefslogtreecommitdiffstats
path: root/src/main.rs
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-16 21:38:52 +0000
committertv <tv@krebsco.de>2026-11-16 23:07:02 +0100
commit0023300b417b2375026750b1b0924adfd94c4e03 (patch)
tree31d7dc44200ecbb25400a96327bfb410140a9790 /src/main.rs
parent96eacbbd2df4127920976fc2e7c4efc53cd83f52 (diff)
continuum is a library
Everything the node is moves from the binary into a library (`src/lib.rs`), so that other binaries can use it: a party's client of a federation next. The node's binary (`src/main.rs`) runs it (`continuum::run`), which wires things together as `main` did. The library's doc comments are prose, not examples to test (`doctest = false`); its tests are the library's, as `cargo quick` and `cargo sim` run them.
Diffstat (limited to 'src/main.rs')
-rw-r--r--src/main.rs507
1 files changed, 3 insertions, 504 deletions
diff --git a/src/main.rs b/src/main.rs
index 40ae93a..00ab098 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,507 +1,6 @@
-//! continuum: a replicated Automerge document, read and written by path, synchronized
-//! over Mycelium, libp2p or Tor.
-//!
-//! main.rs only wires things together: arguments, the starting document, the node
-//! (`node`), bootstrap and the HTTP server.
-
-use std::sync::Arc;
-use std::sync::atomic::{AtomicBool, Ordering};
-
-use anyhow::{Context, Result};
-use tokio::sync::watch;
-use tracing::{debug, error, info, warn};
-
-mod access;
-mod api;
-mod backoff;
-mod clock;
-mod compress;
-mod config;
-mod document;
-#[cfg(feature = "federation")]
-mod federation;
-mod files;
-mod force;
-mod identity;
-mod locks;
-mod logging;
-mod node;
-mod remake;
-#[cfg(test)]
-mod simtest;
-mod state;
-mod swarm;
-#[cfg(test)]
-mod testrand;
-mod transport;
-mod units;
-
-use api::auth::AuthState;
-use document::Document;
-use document::replica::Epoch;
-use swarm::bootstrap;
-use transport::Transport;
+//! A continuum node: the library's (`continuum::run`).
#[tokio::main]
-async fn main() -> Result<()> {
- logging::init();
-
- let config = config::load()?;
- if config.print_only {
- println!(
- "{}",
- serde_json::to_string_pretty(&config.report(config::Values::Interpolated))?
- );
- return Ok(());
- }
- let args = &config.settings;
- if let Some(format) = logging::LogFormat::parse(&args.log_format) {
- logging::set_format(format);
- }
- for (transport, built, options) in config.unused_transport_options() {
- warn!(
- transport,
- built,
- options = ?options,
- "Options of a transport this node doesn't use are ignored"
- );
- }
- // Only with libp2p: without, `config` refuses `relay-only` already.
- #[cfg(feature = "libp2p")]
- if args.relay_only {
- return relay_only(args).await;
- }
-
- // Read before anything starts, so a bad key file fails right away.
- let node_key_file = args
- .node_key_file
- .as_deref()
- .context("node-key-file is required")?;
- let node_key = Arc::new(identity::NodeKey::load(
- node_key_file,
- args.node_key_create,
- )?);
- info!(node_id = %node_key.id(), "Node identity");
- let swarm_key = match &args.swarm_key_file {
- Some(path) => Some(Arc::new(swarm::auth::SwarmKey::from_file(
- path,
- args.swarm_key_create,
- )?)),
- None => {
- warn!("No swarm key: any node that can reach a member may join");
- None
- }
- };
-
- // First thing: until a handler is installed, SIGINT and SIGTERM kill the process on
- // the spot, and startup (starting transports, bootstrap) can take minutes.
- let stop = watch_for_shutdown().context("Installing signal handlers")?;
- // A broken htpasswd will abort startup.
- let auth_state =
- AuthState::from_settings(&args)?.context("htpasswd or user-header is required")?;
- // A new swarm's first users, if it is to have a user registry; the users of the
- // htpasswd file that aren't among them may do nothing until they are added.
- let first_users = if args.genesis {
- access::registry::first_users(&args.bootstrap_users, &args.bootstrap_keys)
- .map_err(anyhow::Error::msg)?
- } else {
- Default::default()
- };
- let first_policy = if args.genesis {
- access::policy::first(args.bootstrap_policy.as_deref(), &args.bootstrap_keys)
- .map_err(anyhow::Error::msg)?
- } else {
- None
- };
- if !first_users.is_empty()
- && let Some(path) = args.htpasswd.as_deref()
- {
- let missing: Vec<String> = api::auth::htpasswd_names(path)?
- .into_iter()
- .filter(|name| !args.bootstrap_users.contains(name))
- .collect();
- if !missing.is_empty() {
- warn!(users = ?missing, "Users of htpasswd not among bootstrap-users: the new swarm's registry doesn't have them, so they may do nothing until added (docs/access.md)");
- }
- }
-
- info!(
- bind_addr = ?args.bind_addr.iter().map(ToString::to_string).collect::<Vec<_>>(),
- transports = ?args.transports,
- "Starting replication service"
- );
-
- let force = force::Force::parse(args.force.iter().map(String::as_str), config::FORCE)
- .map_err(anyhow::Error::msg)?;
- let files = Arc::new(files::Files::default());
- let mut seeds: Vec<String> = args.seeds.clone();
- let (state_file, remembered) = match &args.state_file {
- Some(path) => {
- let (file, remembered) =
- swarm::state_file::StateFile::open(path.clone(), Arc::clone(&files));
- (Some(Arc::new(file)), remembered)
- }
- None => (None, None),
- };
- logging::set_raw_ids(args.log_raw_ids);
- if let Some(remembered) = &remembered {
- logging::set_aliases(remembered.aliases.clone().into_iter().collect());
- info!(
- swarm_id = %remembered.swarm_id,
- seeds = remembered.seeds.len(),
- "Remembering a swarm from the state file"
- );
- for seed in &remembered.seeds {
- if !seeds.contains(seed) {
- seeds.push(seed.clone());
- }
- }
- } else if args.genesis && state_file.is_none() {
- warn!(
- "--genesis without --state-file: every restart with --genesis starts another new swarm"
- );
- }
- debug!(seed_count = seeds.len(), "Loaded bootstrap configuration");
-
- let starting = bootstrap::starting_document(
- &bootstrap::StartOptions {
- recover_from: args.recover_from.as_deref(),
- document_file: args.document_file.as_deref(),
- genesis: args.genesis,
- remembered: remembered.as_ref().map(|r| r.swarm_id.as_str()),
- },
- &files,
- &force,
- )?;
- // A swarm holding a store: started from its root, or joined by its ID.
- #[cfg(feature = "federation")]
- let store =
- bootstrap::StoreStart::of(args.store_root.as_deref(), args.store_id.as_deref(), &files)?;
- #[cfg(feature = "federation")]
- let starting = match &store {
- Some(store) => {
- store.starting(starting, remembered.as_ref().map(|r| r.swarm_id.as_str()))?
- }
- None => starting,
- };
- let (
- initial_doc,
- starting_epoch,
- starting_swarm,
- earlier_actors,
- initial_signatures,
- resumable,
- ) = match starting {
- Some(starting) => (
- starting.doc,
- Some(starting.epoch),
- Some((starting.swarm_id, starting.origin)),
- starting.earlier_actors,
- starting.signatures,
- starting.resumable,
- ),
- None => (Document::new(), None, None, Vec::new(), Vec::new(), None),
- };
- let mut initial_doc = initial_doc;
- let document_file = args.document_file.clone().map(|path| {
- Arc::new(document::file::DocumentFile::new(
- path,
- Arc::clone(&files),
- args.document_append,
- args.document_rewrite,
- ))
- });
- // A clean stop's mark undone before anything is written, and before deciding the
- // actor: a crash from here on leaves a file that doesn't say so. A file that still
- // says so (the mark not undone) gets a fresh actor.
- let opened = document_file.as_ref().is_none_or(|file| file.open());
- // Writing on as the actor of before, where this node stopped cleanly: everything it
- // wrote as that one is in the document, so no change of it comes twice.
- match resumable.filter(|_| args.keep_actor && opened) {
- Some(actor) => {
- info!(actor = %actor, "Writing on as the actor of before (--keep-actor)");
- initial_doc.set_actor(actor);
- }
- None if args.keep_actor && !opened => {
- warn!(
- "Writing as a fresh actor: the document file couldn't be marked as opened (--keep-actor)"
- );
- }
- None if args.keep_actor && starting_epoch.is_some() => {
- info!("Writing as a fresh actor: this node didn't stop cleanly (--keep-actor)");
- }
- None => {}
- }
- if let Some(spec) = &args.remake {
- remake::remake_genesis(spec, &files, &mut initial_doc)
- .with_context(|| format!("Making the genesis document (--remake {spec})"))?;
- info!(remake = %spec, "Made the genesis document");
- }
- let initial_epoch = match (starting_epoch, args.debug_epoch) {
- (Some(epoch), _) => epoch,
- (None, Some(generation)) => Epoch {
- generation,
- id: [0xee; 32],
- },
- (None, None) => Epoch::GENESIS,
- };
- debug!(epoch = %initial_epoch, "Local epoch");
-
- // The enabled, in the order of preference (`--transport-order`, checked when
- // loading).
- let mut transports: Vec<(&'static str, Arc<dyn Transport>)> = Vec::new();
- for name in &args.transports {
- let Some(transport) = transport::start(name, args, &node_key, stop.clone()).await? else {
- return Ok(());
- };
- info!(
- transport = transport.0,
- address = transport.1.local_id(),
- "Transport ready"
- );
- transports.push(transport);
- }
- let delivery_limit = transports
- .iter()
- .map(|(_, transport)| transport.delivery_limit())
- .max()
- .unwrap_or_default();
- // An answer may come over any of them.
- let sync_reply_timeout = transports
- .iter()
- .map(|(_, transport)| transport.sync_reply_timeout())
- .max()
- .unwrap_or(state::SYNC_REPLY_TIMEOUT);
- let mut transports = transports.into_iter();
- let (scheme, transport) = transports.next().context("No transports")?;
-
- let node = node::Node::new(node::NodeConfig {
- transport,
- identity: Some(transport::identity::IdentityConfig {
- key: Arc::clone(&node_key),
- scheme,
- more: transports.collect(),
- }),
- initial_epoch,
- initial_doc,
- earlier_actors,
- initial_signatures,
- timing: state::Timing::new(args.keepalive, sync_reply_timeout, delivery_limit)
- .with_probe_max(args.dormant_probe_max),
- neighbours_k: args.neighbours,
- alias: args.alias.clone(),
- dashboard_url: args.dashboard_url.clone(),
- electorate_window: args.electorate_window,
- clock_skew_warn: args.clock_skew_warn,
- stream_heartbeat: args.stream_heartbeat,
- superseded_writes: args.superseded_writes,
- topology: args.topology,
- dissemination: args.dissemination,
- // At most 4MiB (`Settings::check`).
- blob_chunk_bytes: args.blob_chunk as u32,
- swarm_key,
- protocol_writers: args.protocol_writers.iter().cloned().collect(),
- first_users,
- first_policy,
- node_key: Some(Arc::clone(&node_key)),
- sign_every: args.sign_every,
- token_lifetime: args.token_lifetime,
- session_lifetime: args.session_lifetime,
- challenge_lifetime: args.challenge_lifetime,
- genesis_root: args.genesis_root.as_deref().and_then(swarm::roots::parse),
- #[cfg(feature = "federation")]
- store: store.as_ref().map(|store| store.id),
- #[cfg(feature = "federation")]
- holding: federation::held::Holding::open(
- args.store_file.clone(),
- Arc::clone(&files),
- args.store_checkpoint
- .as_deref()
- .and_then(federation::store::Id::from_hex),
- args.store_party.clone(),
- )?
- .near(args.store_neighbour_parties.clone()),
- strict_keys: args
- .strict_keys
- .iter()
- .filter_map(|line| access::sshsig::PublicKey::parse(line).ok())
- .collect(),
- key_logins_per_user: args.key_logins_per_user,
- refused_writes_per_minute: args.refused_writes_per_minute,
- cors_origins: args.cors_origins.clone(),
- files,
- state_file,
- document_file,
- config_reports: config.reports(),
- clock: Default::default(),
- });
- let state = node.state.clone();
-
- // Join the remembered swarm and no other; HELLOs claim it. A document to start on
- // names its swarm itself (checked against the remembered one above).
- let start = match starting_swarm {
- Some((swarm_id, origin)) => {
- state.set_expected_swarm_id(swarm_id).await?;
- bootstrap::Start::FromDocument(origin)
- }
- None => {
- let expected = remembered.map(|remembered| remembered.swarm_id);
- #[cfg(feature = "federation")]
- let expected = expected.or_else(|| store.as_ref().map(bootstrap::StoreStart::swarm_id));
- if let Some(expected) = expected {
- state.set_expected_swarm_id(expected).await?;
- }
- if args.genesis {
- bootstrap::Start::Genesis
- } else {
- bootstrap::Start::Join
- }
- }
- };
-
- node.spawn_workers();
-
- // The API is up while the node joins: what it serves then is the handlers' business
- // (`docs/lifecycle.md`), and /peers and /admin/stats show how joining goes.
- let joined = AtomicBool::new(false);
- let app = api::router(state.clone(), auth_state, args.debug_api);
-
- // The node shutting down (`AppState::closing`): the servers drain.
- let closing = state.closing.subscribe();
- let server_fut = api::listen::serve(&args.bind_addr, app, move || {
- let closing = closing.clone();
- async move {
- stopped(closing).await;
- info!("Shutdown signal received. Draining API connections...")
- }
- })
- .await?;
- tokio::pin!(server_fut);
-
- // Joins, then runs until stopped; returns only if joining fails.
- let joining = async {
- bootstrap::bootstrap(&state, &seeds, start)
- .await
- .context("Joining swarm")?;
- node::spawn_ready_workers(&state);
- info!(
- swarm_id = ?state.swarm_id().await,
- ready = state.is_ready().await,
- "Bootstrap completed"
- );
- swarm::state_file::update(&state, true).await;
- joined.store(true, Ordering::Release);
- std::future::pending::<Result<()>>().await
- };
- tokio::pin!(joining);
-
- tokio::select! {
- failed = joining.as_mut() => {
- state.closing.send_replace(true);
- let _ = server_fut.as_mut().await;
- return failed;
- }
-
- exit_status = state.transport.wait_for_exit() => {
- error!(status = ?exit_status, "A transport stopped");
- state.closing.send_replace(true);
- let _ = server_fut.as_mut().await;
- }
-
- server_result = server_fut.as_mut() => {
- if let Err(e) = server_result {
- error!("Axum HTTP server encountered a runtime error: {:?}", e);
- } else {
- info!("Axum HTTP engine shutdown cleanly.");
- }
- }
-
- _ = stopped(stop.clone()) => {
- state.closing.send_replace(true);
- let _ = server_fut.as_mut().await;
- }
- }
-
- info!("HTTP API server stopped");
- if !joined.load(Ordering::Acquire) {
- info!("Stopped while joining the swarm");
- return Ok(());
- }
- swarm::peer::farewell(&state).await;
- swarm::state_file::update(&state, true).await;
- swarm::document_file::flush(&state).await;
- swarm::document_file::close(&state).await;
- Ok(())
-}
-
-/// `--relay-only`: libp2p relaying for nodes of swarms, and the HTTP API's relay part
-/// (with `--htpasswd`), until stopped.
-#[cfg(feature = "libp2p")]
-async fn relay_only(args: &config::Settings) -> Result<()> {
- let stop = watch_for_shutdown().context("Installing signal handlers")?;
- let auth_state = AuthState::from_settings(args)?;
- let transport: Arc<dyn Transport> = Arc::new(transport::libp2p::Libp2pTransport::start(
- transport::libp2p::Libp2pConfig::from_settings(args, true)?,
- )?);
- info!(peer_id = transport.local_id(), "Relaying only (no node)");
-
- let server = match auth_state {
- Some(auth_state) => {
- let app = api::relay_only_router(Arc::clone(&transport), auth_state);
- let stop = stop.clone();
- let served =
- api::listen::serve(&args.bind_addr, app, move || stopped(stop.clone())).await?;
- Some(tokio::spawn(served))
- }
- None => {
- info!("No htpasswd or user-header: no HTTP API");
- None
- }
- };
-
- tokio::select! {
- exit = transport.wait_for_exit() => error!(status = ?exit, "The libp2p transport stopped"),
- _ = stopped(stop.clone()) => {}
- }
- if let Some(server) = server {
- let _ = server.await;
- }
- info!("Relay stopped");
- Ok(())
-}
-
-/// Turns SIGINT and SIGTERM into a shutdown request. A second signal exits at once (the
-/// supervised Mycelium still gets its parent-death signal then).
-fn watch_for_shutdown() -> Result<watch::Receiver<bool>> {
- use tokio::signal::unix::{SignalKind, signal};
-
- let mut interrupt = signal(SignalKind::interrupt())?;
- let mut terminate = signal(SignalKind::terminate())?;
- let (stop_tx, stop_rx) = watch::channel(false);
-
- tokio::spawn(async move {
- let name = tokio::select! {
- _ = interrupt.recv() => "SIGINT",
- _ = terminate.recv() => "SIGTERM",
- };
- info!(
- signal = name,
- "Shutting down (send it again to exit immediately)"
- );
- let _ = stop_tx.send(true);
-
- tokio::select! {
- _ = interrupt.recv() => {}
- _ = terminate.recv() => {}
- }
- error!("Second signal; exiting immediately");
- std::process::exit(130);
- });
-
- Ok(stop_rx)
-}
-
-/// Resolves once a shutdown was requested.
-async fn stopped(mut stop: watch::Receiver<bool>) {
- let _ = stop.wait_for(|stop| *stop).await;
+async fn main() -> anyhow::Result<()> {
+ continuum::run().await
}