mosaik 0.3.17

A Rust runtime for building self-organizing, leaderless distributed systems.
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

use {
	crate::cli::CliOpts,
	core::convert::Infallible,
	iroh::SecretKey,
	itertools::Itertools,
	mosaik::{Digest, NetworkId, PeerId, Tag, *},
};

#[derive(Debug, clap::Parser)]
pub struct BeaconCommand {
	/// Network ID to query
	#[clap(short, long)]
	pub network: NetworkId,

	/// The secret key to use for the bootstrap node. Ensures stable peer id.
	#[clap(
		short,
		long,
		value_parser = parse_secret_key,
	)]
	secret: Option<SecretKey>,

	/// Other bootstrap nodes to connect to on startup.
	#[clap(short, long)]
	peers: Vec<PeerId>,

	/// Tags to associate with the bootstrap node.
	#[clap(short, long, default_value = "beacon-node")]
	tags: Vec<Tag>,

	/// Do not use relay servers for this node.
	///
	/// Disables listening or dialing relays. Make sure that this node is
	/// directly reachable by other nodes without any NAT if you set this option.
	#[clap(long, default_value_t = false)]
	no_relay: bool,
}

impl BeaconCommand {
	pub async fn run(&self, _: &CliOpts) -> anyhow::Result<()> {
		println!("Starting beacon node with the following configuration:");
		println!("  network: {:?}", self.network);

		let secret = self
			.secret
			.clone()
			.unwrap_or_else(|| SecretKey::generate(&mut rand::rng()));

		let mut builder = Network::builder(self.network)
			.with_secret_key(secret)
			.with_discovery(
				discovery::Config::builder()
					.with_tags(self.tags.clone())
					.with_bootstrap(self.peers.clone()),
			);

		if self.no_relay {
			builder = builder.with_relay_mode(iroh::RelayMode::Disabled);
		}

		let network = builder.build().await?;

		println!("  peer id: {}", network.local().id());
		println!(
			"  tags   : {}",
			if self.tags.is_empty() {
				"none".to_string()
			} else {
				self.tags.iter().map(|t| format!("{t:?}")).join(", ")
			}
		);
		println!(
			"  peers  : {}",
			if self.peers.is_empty() {
				"none".to_string()
			} else {
				self.peers.iter().map(|p| p.to_string()).join(", ")
			}
		);
		println!(
			"  ips    : {}",
			network.local().addr().ip_addrs().join(", ")
		);
		println!(
			"  relays : {}",
			if self.no_relay {
				"disabled".to_string()
			} else {
				network.local().addr().relay_urls().join(", ")
			}
		);
		println!();
		println!("Hit Ctrl+C to stop the node.");

		// Keep the node running indefinitely.
		futures::future::pending::<()>().await;
		Ok(())
	}
}

#[expect(
	clippy::unnecessary_wraps,
	reason = "clap parser requires this signature"
)]
fn parse_secret_key(s: &str) -> Result<SecretKey, Infallible> {
	let bytes = Digest::from(s);
	Ok(SecretKey::from_bytes(bytes.as_bytes()))
}