finish initial config.

Author: Boog900

Cargo.lock

@@ -13,20 +13,20 @@ cuprate-consensus        = { path = "../../consensus" }
 cuprate-fast-sync        = { path = "../../consensus/fast-sync" }
 cuprate-consensus-rules  = { path = "../../consensus/rules" }
 cuprate-cryptonight      = { path = "../../cryptonight" }
-cuprate-helper           = { path = "../../helper" }
+cuprate-helper           = { path = "../../helper", features = ["serde"] }
 cuprate-epee-encoding    = { path = "../../net/epee-encoding" }
 cuprate-fixed-bytes      = { path = "../../net/fixed-bytes" }
 cuprate-levin            = { path = "../../net/levin" }
 cuprate-wire             = { path = "../../net/wire" }
-cuprate-p2p              = { path = "../../p2p/p2p" }
+cuprate-p2p              = { path = "../../p2p/p2p", features = ["serde"] }
 cuprate-p2p-core         = { path = "../../p2p/p2p-core", features = ["serde"] }
 cuprate-dandelion-tower  = { path = "../../p2p/dandelion-tower" }
 cuprate-async-buffer     = { path = "../../p2p/async-buffer" }
 cuprate-address-book     = { path = "../../p2p/address-book", features = ["serde_config"] }
 cuprate-blockchain       = { path = "../../storage/blockchain", features = ["service"] }
-cuprate-database-service = { path = "../../storage/service" }
+cuprate-database-service = { path = "../../storage/service", features = ["serde"] }
 cuprate-txpool           = { path = "../../storage/txpool" }
-cuprate-database         = { path = "../../storage/database" }
+cuprate-database         = { path = "../../storage/database", features = ["serde"] }
 cuprate-pruning          = { path = "../../pruning" }
 cuprate-test-utils       = { path = "../../test-utils" }
 cuprate-types            = { path = "../../types" }
@@ -71,7 +71,8 @@ tokio-stream          = { workspace = true }
 tokio                 = { workspace = true }
 tower                 = { workspace = true }
 tracing-subscriber    = { workspace = true, features = ["std", "fmt", "default"] }
-tracing               = { workspace = true }
+tracing               = { workspace = true, features = ["default"] }
+toml = "0.8"
 
 [lints]
 workspace = true

binaries/cuprated/Cargo.toml

@@ -1,70 +1,145 @@
 //! cuprated config
+use std::{
+    fs::{read_to_string, File},
+    io,
+    path::Path,
+    time::Duration,
+};
+
+use clap::Parser;
+use serde::{Deserialize, Serialize};
 
 use cuprate_consensus::ContextConfig;
-use cuprate_helper::network::Network;
+use cuprate_helper::{fs::CUPRATE_CONFIG_DIR, network::Network};
 use cuprate_p2p::block_downloader::BlockDownloaderConfig;
 use cuprate_p2p_core::ClearNet;
-use serde::{Deserialize, Serialize};
-use std::time::Duration;
 
+mod args;
+mod default;
 mod p2p;
 mod storage;
+mod tracing_config;
 
 use p2p::P2PConfig;
 use storage::StorageConfig;
+use tracing_config::TracingConfig;
+
+/// The default name of Cuprate's config file.
+const DEFAULT_CONFIG_FILE_NAME: &str = "Cuprate.toml";
+
+/// Reads the args & config file, returning a [`Config`].
+pub fn read_config_and_args() -> Config {
+    let args = args::Args::parse();
+
+    let config: Config = if let Some(config_file) = &args.config_file {
+        // If a config file was set in the args try read it and exit if we can't.
+        match Config::read_from_file(config_file) {
+            Ok(config) => config,
+            Err(e) => {
+                tracing::error!("Failed to read config from file: {}", e);
+                std::process::exit(1);
+            }
+        }
+    } else {
+        // First attempt to read the config file from the current directory.
+        std::env::current_dir()
+            .map_err(Into::into)
+            .and_then(Config::read_from_file)
+            .inspect_err(|e| tracing::debug!("Failed to read config from current dir: {e}"))
+            // otherwise try the main config directory.
+            .or_else(|_| {
+                let file = CUPRATE_CONFIG_DIR.join(DEFAULT_CONFIG_FILE_NAME);
+                Config::read_from_file(file)
+            })
+            .inspect_err(|e| {
+                tracing::debug!("Failed to read config from config dir: {e}");
+                tracing::warn!("Failed to find/read config file, using default config.");
+            })
+            .unwrap_or_default()
+    };
 
-pub fn config() -> Config {
-    Config::default()
+    args.apply_args(config)
 }
 
+/// The config for all of Cuprate.
 #[derive(Default, Deserialize, Serialize)]
 #[serde(deny_unknown_fields, default)]
 pub struct Config {
+    /// The network we should run on.
     network: Network,
 
+    /// [`tracing`] config.
+    tracing: TracingConfig,
+
+    /// The P2P network config.
     p2p: P2PConfig,
 
+    /// The Storage config
     storage: StorageConfig,
 }
 
 impl Config {
-    pub fn network(&self) -> Network {
+    /// Attempts to read a config file in [`toml`] format from the given [`Path`.
+    ///
+    /// # Errors
+    ///
+    /// Will return an [`Err`] if the file cannot be read or if the file is not a valid [`toml`] config.
+    fn read_from_file(file: impl AsRef<Path>) -> Result<Self, anyhow::Error> {
+        let file_text = read_to_string(file.as_ref())?;
+
+        Ok(toml::from_str(&file_text).inspect_err(|_| {
+            tracing::warn!(
+                "Failed to parse config file at: {}",
+                file.as_ref().to_string_lossy()
+            );
+        })?)
+    }
+
+    /// Returns the current [`Network`] we are running on.
+    pub const fn network(&self) -> Network {
         self.network
     }
 
+    /// The [`ClearNet`], [`cuprate_p2p::P2PConfig`].
     pub fn clearnet_p2p_config(&self) -> cuprate_p2p::P2PConfig<ClearNet> {
         cuprate_p2p::P2PConfig {
             network: self.network,
+            seeds: p2p::clear_net_seed_nodes(self.network),
             outbound_connections: self.p2p.clear_net.general.outbound_connections,
             extra_outbound_connections: self.p2p.clear_net.general.extra_outbound_connections,
             max_inbound_connections: self.p2p.clear_net.general.max_inbound_connections,
             gray_peers_percent: self.p2p.clear_net.general.gray_peers_percent,
             server_config: Some(self.p2p.clear_net.server.clone()),
             p2p_port: self.p2p.clear_net.general.p2p_port,
+            // TODO: set this if a public RPC server is set.
             rpc_port: 0,
             address_book_config: self.p2p.clear_net.general.address_book_config.clone(),
         }
     }
 
-    pub fn context_config(&self) -> ContextConfig {
+    /// The [`ContextConfig`].
+    pub const fn context_config(&self) -> ContextConfig {
         match self.network {
             Network::Mainnet => ContextConfig::main_net(),
             Network::Stagenet => ContextConfig::stage_net(),
             Network::Testnet => ContextConfig::test_net(),
         }
     }
 
+    /// The [`cuprate_blockchain`] config.
     pub fn blockchain_config(&self) -> cuprate_blockchain::config::Config {
-        self.storage.blockchain.clone()
+        let blockchain = &self.storage.blockchain;
+
+        // We don't set reader threads as we manually make the reader threadpool.
+        cuprate_blockchain::config::ConfigBuilder::default()
+            .network(self.network)
+            .db_directory(blockchain.shared.path.clone())
+            .sync_mode(blockchain.shared.sync_mode)
+            .build()
     }
 
-    pub fn block_downloader_config(&self) -> BlockDownloaderConfig {
-        BlockDownloaderConfig {
-            buffer_size: 50_000_000,
-            in_progress_queue_size: 50_000_000,
-            check_client_pool_interval: Duration::from_secs(30),
-            target_batch_size: 5_000_000,
-            initial_batch_size: 1,
-        }
+    /// The [`BlockDownloaderConfig`].
+    pub const fn block_downloader_config(&self) -> BlockDownloaderConfig {
+        self.p2p.block_downloader
     }
 }

binaries/cuprated/src/config.rs

@@ -0,0 +1,75 @@
+#     ____                      _
+#    / ___|   _ _ __  _ __ __ _| |_ ___
+#   | |  | | | | '_ \| '__/ _` | __/ _ \
+#   | |__| |_| | |_) | | | (_| | ||  __/
+#    \____\__,_| .__/|_|  \__,_|\__\___|
+#              |_|
+#
+
+## The network to run on, valid values: "Mainnet", "Testnet", "Stagenet".
+network = "Mainnet"
+
+## Tracing config.
+[tracing]
+## The minimum level for log events to be displayed.
+level = "info"
+
+## Clear-net config.
+[p2p.clear_net]
+## The number of outbound connections we should make and maintain.
+outbound_connections = 64
+## The number of extra connections we should make under load from the rest of Cuprate, i.e. when syncing.
+extra_outbound_connections = 8
+## The maximum number of incoming we should allow.
+max_inbound_connections = 128
+## The percent of outbound connections that should be to nodes we have not connected to before.
+gray_peers_percent = 0.7
+## The port to accept connections on, if left `0` no connections will be accepted.
+p2p_port = 0
+## The IP address to listen to connections on.
+server.ip = "0.0.0.0"
+
+## The Clear-net addressbook config.
+[p2p.clear_net.address_book_config]
+## The size of the white peer list, which contains peers we have made a connection to before.
+max_white_list_length = 1_000
+## The size of the gray peer list, which contains peers we have not made a connection to before.
+max_gray_list_length = 5_000
+## The folder to store the address book.
+peer_store_folder = "{cache}"
+## The amount of time between address book saves.
+peer_save_period = {{ secs = 90, nanos = 0 }}
+
+## The block downloader config.
+[p2p.block_downloader]
+## The size of the buffer of sequential blocks waiting to be verified and added to the chain (bytes).
+buffer_size = 50_000_000
+## The size of the queue of blocks which are waiting for a parent block to be downloaded (bytes).
+in_progress_queue_size = 50_000_000
+## The target size of a batch of blocks (bytes), must not exceed 100MB.
+target_batch_size = 5_000_000
+## The number of blocks in the first bacth (you probably shouldn't change this).
+initial_batch_len = 1
+## The amount of time between checking the pool of connected peers for free peers to download blocks.
+check_client_pool_interval = {{ secs = 30, nanos = 0 }}
+
+## Storage config
+[storage]
+## The amount of reader threads to spawn.
+reader_threads = "OnePerThread"
+
+## Txpool storage config.
+[storage.txpool]
+## The txpool storage location.
+path = "{txpool}"
+## The database sync mode for the txpool.
+sync_mode = "Async"
+## The maximum size of all the txs in the pool (bytes).
+max_txpool_size = 100_000_000
+
+## Blockchain storage config.
+[storage.blockchain]
+## The blockchain storage location.
+path = "{blockchain}"
+## The database sync mode for the blockchain.
+sync_mode = "Async"

binaries/cuprated/src/config/Cuprate.toml

@@ -0,0 +1,45 @@
+use std::{io::Write, path::PathBuf};
+
+use clap::builder::TypedValueParser;
+
+use cuprate_helper::network::Network;
+
+use crate::config::{default::create_default_config_file, Config, DEFAULT_CONFIG_FILE_NAME};
+
+#[derive(clap::Parser, Debug)]
+pub struct Args {
+    /// The network we should run on.
+    #[arg(
+        long,
+        default_value_t = Network::Mainnet,
+        value_parser = clap::builder::PossibleValuesParser::new(["mainnet", "testnet", "stagenet"])
+            .map(|s| s.parse::<Network>().unwrap()),
+    )]
+    pub network: Network,
+    /// The amount of outbound clear-net connections to maintain.
+    pub outbound_connections: Option<usize>,
+    /// The location of the Cuprate config file.
+    pub config_file: Option<PathBuf>,
+    /// Generate a config file and place it in the given folder.
+    pub generate_config: Option<PathBuf>,
+}
+
+impl Args {
+    /// Apply the [`Args`] to the given [`Config`].
+    ///
+    /// This may exit the program if a config value was set that requires an early exit.
+    pub fn apply_args(&self, mut config: Config) -> Config {
+        if let Some(config_folder) = self.generate_config.as_ref() {
+            // This will create the config file and exit.
+            create_default_config_file(config_folder)
+        };
+
+        config.network = self.network;
+
+        if let Some(outbound_connections) = self.outbound_connections {
+            config.p2p.clear_net.general.outbound_connections = outbound_connections;
+        }
+
+        config
+    }
+}