refactor: Refactor and split-up settings

docker/Dockerfile

@@ -91,8 +91,8 @@ ARG rpc_port=3030
 ARG ws_port=1337
 
 ENV DATABASE_URL=${database_url} \
-    HOMESTAR__NODE__NETWORK__RPC_HOST=${rpc_host} \
-    HOMESTAR__NODE__NETWORK__RPC_PORT=${rpc_port} \
+    HOMESTAR__NODE__NETWORK__RPC__HOST=${rpc_host} \
+    HOMESTAR__NODE__NETWORK__RPC__PORT=${rpc_port} \
     HOMESTAR__NODE__NETWORK__WS_PORT=${ws_port}
 
 EXPOSE ${rpc_port} ${ws_port}

examples/websocket-relay/src/main.rs

@@ -10,7 +10,7 @@ use tracing::info;
 
 fn main() -> Result<()> {
     let settings = Settings::load().expect("runtime settings to be loaded");
-    let _guard = Logger::init(settings.monitoring());
+    let _guard = Logger::init(settings.node().monitoring());
 
     // Just for example purposes, we're going to start the ipfs
     // daemon. Typically, these would be started separately.

homestar-runtime/config/settings.toml

@@ -1,6 +1,8 @@
-[monitoring]
+[node]
+
+[node.monitoring]
 process_collector_interval = 5000
-metrics_port = 4000
-console_subscriber_port = 5555
+console_subscriber_port = 6669
 
-[node]
+[node.network.metrics]
+port = 4000

homestar-runtime/fixtures/defaults.toml

@@ -0,0 +1,74 @@
+[node]
+gc_interval = 1800
+shutdown_timeout = 20
+
+[node.database]
+url = "homestar.db"
+max_pool_size = 100
+
+[node.monitoring]
+process_collector_interval = 5000
+console_subscriber_port = 6669
+
+[node.network]
+events_buffer_len = 1024
+poll_cache_interval = 1000
+
+[node.network.ipfs]
+host = "127.0.0.1"
+port = 5001
+
+[node.network.libp2p]
+listen_address = "/ip4/0.0.0.0/tcp/0"
+node_addresses = []
+announce_addresses = []
+transport_connection_timeout = 60
+max_connected_peers = 32
+max_announce_addresses = 10
+
+[node.network.libp2p.mdns]
+enable = true
+enable_ipv6 = false
+query_interval = 300
+ttl = 540
+
+[node.network.libp2p.rendezvous]
+enable_client = true
+enable_server = false
+registration_ttl = 7200
+discovery_interval = 600
+
+[node.network.libp2p.pubsub]
+enable = true
+duplication_cache_time = 1
+heartbeat = 60
+idle_timeout = 86400
+max_transmit_size = 10485760
+mesh_n_low = 1
+mesh_n_high = 10
+mesh_n = 2
+mesh_outbound_min = 1
+
+[node.network.libp2p.dht]
+p2p_provider_timeout = 30
+receipt_quorum = 2
+workflow_quorum = 3
+
+[node.network.keypair_config]
+random = {}
+
+[node.network.metrics]
+port = 4000
+
+[node.network.rpc]
+host = "::1"
+port = 3030
+max_connections = 10
+server_timeout = 120
+
+[node.network.webserver]
+host = "127.0.0.1"
+port = 1337
+timeout = 120
+websocket_capacity = 2048
+websocket_receiver_timeout = 30000

homestar-runtime/fixtures/settings.toml

@@ -2,5 +2,9 @@
 
 [node.network]
 events_buffer_len = 1000
-webserver_port = 9999
+
+[node.network.webserver]
+port = 9999
+
+[node.network.libp2p]
 node_addresses = ["/ip4/127.0.0.1/tcp/9998/ws"]

homestar-runtime/src/event_handler.rs

@@ -114,29 +114,29 @@ where
     DB: Database,
 {
     fn setup_channel(
-        settings: &settings::Node,
+        settings: &settings::Network,
     ) -> (
         channel::AsyncChannelSender<Event>,
         channel::AsyncChannelReceiver<Event>,
     ) {
-        channel::AsyncChannel::with(settings.network.events_buffer_len)
+        channel::AsyncChannel::with(settings.events_buffer_len)
     }
 
     /// Create an [EventHandler] with channel sender/receiver defaults.
     #[cfg(feature = "websocket-notify")]
     pub(crate) fn new(
         swarm: Swarm<ComposedBehaviour>,
         db: DB,
-        settings: &settings::Node,
+        settings: &settings::Network,
         ws_evt_sender: webserver::Notifier<notifier::Message>,
         ws_workflow_sender: webserver::Notifier<notifier::Message>,
     ) -> Self {
         let (sender, receiver) = Self::setup_channel(settings);
         let sender = Arc::new(sender);
         Self {
-            receipt_quorum: settings.network.receipt_quorum,
-            workflow_quorum: settings.network.workflow_quorum,
-            p2p_provider_timeout: settings.network.p2p_provider_timeout,
+            receipt_quorum: settings.libp2p.dht.receipt_quorum,
+            workflow_quorum: settings.libp2p.dht.workflow_quorum,
+            p2p_provider_timeout: settings.libp2p.dht.p2p_provider_timeout,
             db,
             swarm,
             cache: Arc::new(setup_cache(sender.clone())),
@@ -146,33 +146,37 @@ where
             request_response_senders: FnvHashMap::default(),
             connections: Connections {
                 peers: FnvHashMap::default(),
-                max_peers: settings.network.max_connected_peers,
+                max_peers: settings.libp2p.max_connected_peers,
             },
             rendezvous: Rendezvous {
-                registration_ttl: settings.network.rendezvous_registration_ttl,
-                discovery_interval: settings.network.rendezvous_discovery_interval,
+                registration_ttl: settings.libp2p.rendezvous.registration_ttl,
+                discovery_interval: settings.libp2p.rendezvous.discovery_interval,
                 discovered_peers: FnvHashMap::default(),
                 cookies: FnvHashMap::default(),
             },
-            pubsub_enabled: settings.network.enable_pubsub,
+            pubsub_enabled: settings.libp2p.pubsub.enable,
             ws_evt_sender,
             ws_workflow_sender,
-            node_addresses: settings.network.node_addresses.clone(),
-            announce_addresses: settings.network.announce_addresses.clone(),
-            external_address_limit: settings.network.max_announce_addresses,
-            poll_cache_interval: settings.network.poll_cache_interval,
+            node_addresses: settings.libp2p.node_addresses.clone(),
+            announce_addresses: settings.libp2p.announce_addresses.clone(),
+            external_address_limit: settings.libp2p.max_announce_addresses,
+            poll_cache_interval: settings.poll_cache_interval,
         }
     }
 
     /// Create an [EventHandler] with channel sender/receiver defaults.
     #[cfg(not(feature = "websocket-notify"))]
-    pub(crate) fn new(swarm: Swarm<ComposedBehaviour>, db: DB, settings: &settings::Node) -> Self {
+    pub(crate) fn new(
+        swarm: Swarm<ComposedBehaviour>,
+        db: DB,
+        settings: &settings::Network,
+    ) -> Self {
         let (sender, receiver) = Self::setup_channel(settings);
         let sender = Arc::new(sender);
         Self {
-            receipt_quorum: settings.network.receipt_quorum,
-            workflow_quorum: settings.network.workflow_quorum,
-            p2p_provider_timeout: settings.network.p2p_provider_timeout,
+            receipt_quorum: settings.libp2p.dht.receipt_quorum,
+            workflow_quorum: settings.libp2p.dht.workflow_quorum,
+            p2p_provider_timeout: settings.libp2p.dht.p2p_provider_timeout,
             db,
             swarm,
             cache: Arc::new(setup_cache(sender.clone())),
@@ -182,19 +186,19 @@ where
             request_response_senders: FnvHashMap::default(),
             connections: Connections {
                 peers: FnvHashMap::default(),
-                max_peers: settings.network.max_connected_peers,
+                max_peers: settings.libp2p.max_connected_peers,
             },
             rendezvous: Rendezvous {
-                registration_ttl: settings.network.rendezvous_registration_ttl,
-                discovery_interval: settings.network.rendezvous_discovery_interval,
+                registration_ttl: settings.libp2p.rendezvous.registration_ttl,
+                discovery_interval: settings.libp2p.rendezvous.discovery_interval,
                 discovered_peers: FnvHashMap::default(),
                 cookies: FnvHashMap::default(),
             },
-            pubsub_enabled: settings.network.enable_pubsub,
-            node_addresses: settings.network.node_addresses.clone(),
-            announce_addresses: settings.network.announce_addresses.clone(),
-            external_address_limit: settings.network.max_announce_addresses,
-            poll_cache_interval: settings.network.poll_cache_interval,
+            pubsub_enabled: settings.libp2p.pubsub.enable,
+            node_addresses: settings.libp2p.node_addresses.clone(),
+            announce_addresses: settings.libp2p.announce_addresses.clone(),
+            external_address_limit: settings.libp2p.max_announce_addresses,
+            poll_cache_interval: settings.poll_cache_interval,
         }
     }
 

homestar-runtime/src/main.rs

@@ -30,9 +30,9 @@ fn main() -> Result<()> {
             let _guard = if daemonize {
                 daemon::start(daemon_dir.clone())
                     .expect("runner to be started as a daemon process");
-                FileLogger::init(daemon_dir, settings.monitoring())
+                FileLogger::init(daemon_dir, settings.node().monitoring())
             } else {
-                Logger::init(settings.monitoring())
+                Logger::init(settings.node().monitoring())
             };
 
             info!(

homestar-runtime/src/metrics/exporter.rs

@@ -16,7 +16,7 @@ pub(crate) fn setup_metrics_recorder(
         0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0,
     ];
 
-    let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), settings.metrics_port);
+    let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), settings.metrics.port);
 
     let (recorder, exporter) = PrometheusBuilder::new()
         .set_buckets_for_metric(

homestar-runtime/src/network/pubsub.rs

@@ -24,7 +24,7 @@ pub(crate) const RECEIPTS_TOPIC: &str = "receipts";
 /// Setup [gossipsub] mesh protocol with default configuration.
 ///
 /// [gossipsub]: libp2p::gossipsub
-pub(crate) fn new(keypair: Keypair, settings: &settings::Node) -> Result<gossipsub::Behaviour> {
+pub(crate) fn new(keypair: Keypair, settings: &settings::Pubsub) -> Result<gossipsub::Behaviour> {
     // To content-address message, we can take the hash of message and use it as an ID.
     let message_id_fn = |message: &gossipsub::Message| {
         let mut s = DefaultHasher::new();
@@ -33,18 +33,18 @@ pub(crate) fn new(keypair: Keypair, settings: &settings::Node) -> Result<gossips
     };
 
     let gossipsub_config = ConfigBuilder::default()
-        .heartbeat_interval(settings.network.pubsub_heartbeat)
-        .idle_timeout(settings.network.pubsub_idle_timeout)
+        .heartbeat_interval(settings.heartbeat)
+        .idle_timeout(settings.idle_timeout)
         // This sets the kind of message validation. The default is Strict (enforce message signing).
         .validation_mode(ValidationMode::Strict)
-        .max_transmit_size(settings.network.pubsub_max_transmit_size)
-        .mesh_n_low(settings.network.pubsub_mesh_n_low)
-        .mesh_outbound_min(settings.network.pubsub_mesh_outbound_min)
-        .mesh_n(settings.network.pubsub_mesh_n)
-        .mesh_n_high(settings.network.pubsub_mesh_n_high)
+        .max_transmit_size(settings.max_transmit_size)
+        .mesh_n_low(settings.mesh_n_low)
+        .mesh_outbound_min(settings.mesh_outbound_min)
+        .mesh_n(settings.mesh_n)
+        .mesh_n_high(settings.mesh_n_high)
         // Content-address messages. No two messages of the same content will be propagated.
         .message_id_fn(message_id_fn)
-        .duplicate_cache_time(settings.network.pubsub_duplication_cache_time)
+        .duplicate_cache_time(settings.duplication_cache_time)
         .support_floodsub()
         .build()
         .map_err(anyhow::Error::msg)?;

homestar-runtime/src/network/rpc.rs

@@ -160,12 +160,12 @@ impl Server {
     pub(crate) fn new(settings: &settings::Network, runner_sender: Arc<RpcSender>) -> Self {
         let (tx, rx) = AsyncChannel::oneshot();
         Self {
-            addr: SocketAddr::new(settings.rpc_host, settings.rpc_port),
+            addr: SocketAddr::new(settings.rpc.host, settings.rpc.port),
             sender: tx.into(),
             receiver: rx,
             runner_sender,
-            max_connections: settings.rpc_max_connections,
-            timeout: settings.rpc_server_timeout,
+            max_connections: settings.rpc.max_connections,
+            timeout: settings.rpc.server_timeout,
         }
     }