soil_service/

config.rs

// This file is part of Soil.

// Copyright (C) Soil contributors.
// Copyright (C) Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0

//! Service configuration.

pub use jsonrpsee::server::BatchRequestConfig as RpcBatchRequestConfig;
use soil_prometheus::Registry;
use soil_chain_spec::ChainSpec;
pub use soil_client::db::{BlocksPruning, Database, DatabaseSource, PruningMode};
pub use soil_client::executor::{WasmExecutionMethod, WasmtimeInstantiationStrategy};
pub use soil_network::{
	config::{
		MultiaddrWithPeerId, NetworkConfiguration, NodeKeyConfig, NonDefaultSetConfig, ProtocolId,
		Role, SetConfig, SyncMode, TransportConfig,
	},
	request_responses::{
		IncomingRequest, OutgoingResponse, ProtocolConfig as RequestResponseConfig,
	},
	Multiaddr,
};
pub use soil_rpc::server::{
	IpNetwork, RpcEndpoint, RpcMethods, SubscriptionIdProvider as RpcSubscriptionIdProvider,
};
pub use soil_telemetry::TelemetryEndpoints;
pub use soil_txpool::TransactionPoolOptions;
use std::{
	io, iter,
	net::SocketAddr,
	num::NonZeroU32,
	path::{Path, PathBuf},
};
use subsoil::core::crypto::SecretString;
use tempfile::TempDir;

/// Service configuration.
#[derive(Debug)]
pub struct Configuration {
	/// Implementation name
	pub impl_name: String,
	/// Implementation version (see soil-cli to see an example of format)
	pub impl_version: String,
	/// Node role.
	pub role: Role,
	/// Handle to the tokio runtime. Will be used to spawn futures by the task manager.
	pub tokio_handle: tokio::runtime::Handle,
	/// Extrinsic pool configuration.
	pub transaction_pool: TransactionPoolOptions,
	/// Network configuration.
	pub network: NetworkConfiguration,
	/// Configuration for the keystore.
	pub keystore: KeystoreConfig,
	/// Configuration for the database.
	pub database: DatabaseSource,
	/// Maximum size of internal trie cache in bytes.
	///
	/// If `None` is given the cache is disabled.
	pub trie_cache_maximum_size: Option<usize>,
	/// Force the trie cache to be in memory.
	pub warm_up_trie_cache: Option<TrieCacheWarmUpStrategy>,
	/// State pruning settings.
	pub state_pruning: Option<PruningMode>,
	/// Number of blocks to keep in the db.
	///
	/// NOTE: only finalized blocks are subject for removal!
	pub blocks_pruning: BlocksPruning,
	/// Chain configuration.
	pub chain_spec: Box<dyn ChainSpec>,
	/// Runtime executor configuration.
	pub executor: ExecutorConfiguration,
	/// Directory where local WASM runtimes live. These runtimes take precedence
	/// over on-chain runtimes when the spec version matches. Set to `None` to
	/// disable overrides (default).
	pub wasm_runtime_overrides: Option<PathBuf>,
	/// RPC configuration.
	pub rpc: RpcConfiguration,
	/// Prometheus endpoint configuration. `None` if disabled.
	pub prometheus_config: Option<PrometheusConfig>,
	/// Telemetry service URL. `None` if disabled.
	pub telemetry_endpoints: Option<TelemetryEndpoints>,
	/// Should offchain workers be executed.
	pub offchain_worker: OffchainWorkerConfig,
	/// Enable authoring even when offline.
	pub force_authoring: bool,
	/// Disable GRANDPA when running in validator mode
	pub disable_grandpa: bool,
	/// Development key seed.
	///
	/// When running in development mode, the seed will be used to generate authority keys by the
	/// keystore.
	///
	/// Should only be set when `node` is running development mode.
	pub dev_key_seed: Option<String>,
	/// Tracing targets
	pub tracing_targets: Option<String>,
	/// Tracing receiver
	pub tracing_receiver: soil_client::tracing::TracingReceiver,
	/// Announce block automatically after they have been imported
	pub announce_block: bool,
	/// Data path root for the configured chain.
	pub data_path: PathBuf,
	/// Base path of the configuration. This is shared between chains.
	pub base_path: BasePath,
}

/// Warmup strategy for the trie cache.
#[derive(Debug, Clone, Copy)]
pub enum TrieCacheWarmUpStrategy {
	/// Warm up the cache in a non-blocking way.
	NonBlocking,
	/// Warm up the cache in a blocking way.
	Blocking,
}

impl TrieCacheWarmUpStrategy {
	/// Returns true if the warmup strategy is blocking.
	pub(crate) fn is_blocking(&self) -> bool {
		matches!(self, Self::Blocking)
	}
}

/// Type for tasks spawned by the executor.
#[derive(PartialEq)]
pub enum TaskType {
	/// Regular non-blocking futures. Polling the task is expected to be a lightweight operation.
	Async,
	/// The task might perform a lot of expensive CPU operations and/or call `thread::sleep`.
	Blocking,
}

/// Configuration of the client keystore.
#[derive(Debug, Clone)]
pub enum KeystoreConfig {
	/// Keystore at a path on-disk. Recommended for native nodes.
	Path {
		/// The path of the keystore.
		path: PathBuf,
		/// Node keystore's password.
		password: Option<SecretString>,
	},
	/// In-memory keystore. Recommended for in-browser nodes.
	InMemory,
}

impl KeystoreConfig {
	/// Returns the path for the keystore.
	pub fn path(&self) -> Option<&Path> {
		match self {
			Self::Path { path, .. } => Some(path),
			Self::InMemory => None,
		}
	}
}
/// Configuration of the database of the client.
#[derive(Debug, Clone, Default)]
pub struct OffchainWorkerConfig {
	/// If this is allowed.
	pub enabled: bool,
	/// allow writes from the runtime to the offchain worker database.
	pub indexing_enabled: bool,
}

/// Configuration of the Prometheus endpoint.
#[derive(Debug, Clone)]
pub struct PrometheusConfig {
	/// Port to use.
	pub port: SocketAddr,
	/// A metrics registry to use. Useful for setting the metric prefix.
	pub registry: Registry,
}

impl PrometheusConfig {
	/// Create a new config using the default registry.
	pub fn new_with_default_registry(port: SocketAddr, chain_id: String) -> Self {
		let param = iter::once((String::from("chain"), chain_id)).collect();
		Self {
			port,
			registry: Registry::new_custom(None, Some(param))
				.expect("this can only fail if the prefix is empty"),
		}
	}
}

impl Configuration {
	/// Returns a string displaying the node role.
	pub fn display_role(&self) -> String {
		self.role.to_string()
	}

	/// Returns the prometheus metrics registry, if available.
	pub fn prometheus_registry(&self) -> Option<&Registry> {
		self.prometheus_config.as_ref().map(|config| &config.registry)
	}

	/// Returns the network protocol id from the chain spec, or the default.
	pub fn protocol_id(&self) -> ProtocolId {
		let protocol_id_full = match self.chain_spec.protocol_id() {
			Some(pid) => pid,
			None => {
				log::warn!(
					"Using default protocol ID {:?} because none is configured in the \
					chain specs",
					crate::DEFAULT_PROTOCOL_ID
				);
				crate::DEFAULT_PROTOCOL_ID
			},
		};
		ProtocolId::from(protocol_id_full)
	}

	/// Returns true if the genesis state writing will be skipped while initializing the genesis
	/// block.
	pub fn no_genesis(&self) -> bool {
		matches!(self.network.sync_mode, SyncMode::LightState { .. } | SyncMode::Warp { .. })
	}

	/// Returns the database config for creating the backend.
	pub fn db_config(&self) -> soil_client::db::DatabaseSettings {
		soil_client::db::DatabaseSettings {
			trie_cache_maximum_size: self.trie_cache_maximum_size,
			state_pruning: self.state_pruning.clone(),
			source: self.database.clone(),
			blocks_pruning: self.blocks_pruning,
			pruning_filters: Default::default(),
			metrics_registry: self.prometheus_registry().cloned(),
		}
	}
}

#[static_init::dynamic(drop, lazy)]
static mut BASE_PATH_TEMP: Option<TempDir> = None;

/// The base path that is used for everything that needs to be written on disk to run a node.
#[derive(Clone, Debug)]
pub struct BasePath {
	path: PathBuf,
}

impl BasePath {
	/// Create a `BasePath` instance using a temporary directory prefixed with "substrate" and use
	/// it as base path.
	///
	/// Note: The temporary directory will be created automatically and deleted when the program
	/// exits. Every call to this function will return the same path for the lifetime of the
	/// program.
	pub fn new_temp_dir() -> io::Result<BasePath> {
		let mut temp = BASE_PATH_TEMP.write();

		match &*temp {
			Some(p) => Ok(Self::new(p.path())),
			None => {
				let temp_dir = tempfile::Builder::new().prefix("substrate").tempdir()?;
				let path = PathBuf::from(temp_dir.path());

				*temp = Some(temp_dir);
				Ok(Self::new(path))
			},
		}
	}

	/// Create a `BasePath` instance based on an existing path on disk.
	///
	/// Note: this function will not ensure that the directory exist nor create the directory. It
	/// will also not delete the directory when the instance is dropped.
	pub fn new<P: Into<PathBuf>>(path: P) -> BasePath {
		Self { path: path.into() }
	}

	/// Create a base path from values describing the project.
	pub fn from_project(qualifier: &str, organization: &str, application: &str) -> BasePath {
		BasePath::new(
			directories::ProjectDirs::from(qualifier, organization, application)
				.expect("app directories exist on all supported platforms; qed")
				.data_local_dir(),
		)
	}

	/// Retrieve the base path.
	pub fn path(&self) -> &Path {
		&self.path
	}

	/// Returns the configuration directory inside this base path.
	///
	/// The path looks like `$base_path/chains/$chain_id`
	pub fn config_dir(&self, chain_id: &str) -> PathBuf {
		self.path().join("chains").join(chain_id)
	}
}

impl From<PathBuf> for BasePath {
	fn from(path: PathBuf) -> Self {
		BasePath::new(path)
	}
}

/// RPC configuration.
#[derive(Debug)]
pub struct RpcConfiguration {
	/// JSON-RPC server endpoints.
	pub addr: Option<Vec<RpcEndpoint>>,
	/// Maximum number of connections for JSON-RPC server.
	pub max_connections: u32,
	/// CORS settings for HTTP & WS servers. `None` if all origins are allowed.
	pub cors: Option<Vec<String>>,
	/// RPC methods to expose (by default only a safe subset or all of them).
	pub methods: RpcMethods,
	/// Maximum payload of a rpc request
	pub max_request_size: u32,
	/// Maximum payload of a rpc response.
	pub max_response_size: u32,
	/// Custom JSON-RPC subscription ID provider.
	///
	/// Default: [`crate::RandomStringSubscriptionId`].
	pub id_provider: Option<Box<dyn RpcSubscriptionIdProvider>>,
	/// Maximum allowed subscriptions per rpc connection
	pub max_subs_per_conn: u32,
	/// JSON-RPC server default port.
	pub port: u16,
	/// The number of messages the JSON-RPC server is allowed to keep in memory.
	pub message_buffer_capacity: u32,
	/// JSON-RPC server batch config.
	pub batch_config: RpcBatchRequestConfig,
	/// RPC rate limit per minute.
	pub rate_limit: Option<NonZeroU32>,
	/// RPC rate limit whitelisted ip addresses.
	pub rate_limit_whitelisted_ips: Vec<IpNetwork>,
	/// RPC rate limit trust proxy headers.
	pub rate_limit_trust_proxy_headers: bool,
	/// RPC logger capacity (default: 1024).
	pub request_logger_limit: u32,
}

/// Runtime executor configuration.
#[derive(Debug, Clone)]
pub struct ExecutorConfiguration {
	/// Wasm execution method.
	pub wasm_method: WasmExecutionMethod,
	/// The size of the instances cache.
	///
	/// The default value is 8.
	pub max_runtime_instances: usize,
	/// The default number of 64KB pages to allocate for Wasm execution
	pub default_heap_pages: Option<u64>,
	/// Maximum number of different runtime versions that can be cached.
	pub runtime_cache_size: u8,
}

impl Default for ExecutorConfiguration {
	fn default() -> Self {
		Self {
			wasm_method: WasmExecutionMethod::default(),
			max_runtime_instances: 8,
			default_heap_pages: None,
			runtime_cache_size: 2,
		}
	}
}