GRIN/grim
1
0
Fork 1
mirror of https://code.gri.mw/GUI/grim.git synced 2026-07-10 17:04:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

config + ui: add p2p config and ui, fix input fields size, update translations

Browse Source
This commit is contained in:
ardocrat
2023-07-11 03:02:44 +03:00
parent 6cfc6ae0b5
commit bab8c49f26
14 changed files with 1431 additions and 298 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/node/config.rs
+386 -167
View File
@@ -14,9 +14,10 @@
use std::fs::File;
use std::io::{BufRead, BufReader, Write};
use std::net::{IpAddr, Ipv4Addr, SocketAddrV4, TcpListener};
use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4, TcpListener, ToSocketAddrs};
use std::path::PathBuf;
use std::str::FromStr;
use egui::Key::P;
use grin_config::{config, ConfigError, ConfigMembers, GlobalConfig};
use grin_config::config::{API_SECRET_FILE_NAME, FOREIGN_API_SECRET_FILE_NAME, SERVER_CONFIG_FILE_NAME};
@@ -29,39 +30,171 @@ use crate::node::Node;
use crate::{AppConfig, Settings};
/// Wrapped node config to be used by [`grin_servers::Server`].
#[derive(Serialize, Deserialize)]
pub struct NodeConfig {
pub members: ConfigMembers
/// Peers config to save peers DNS names into the file.
#[derive(Serialize, Deserialize, Default)]
pub struct PeersConfig {
seeds: Vec<String>,
allowed: Vec<String>,
denied: Vec<String>,
preferred: Vec<String>
}
impl NodeConfig {
/// Initialize integrated node config.
pub fn init(chain_type: &ChainTypes) -> Self {
let config_members = Self::for_chain_type(chain_type);
Self {
members: config_members
impl PeersConfig {
/// File name for peers config.
pub const FILE_NAME: &'static str = "peers.toml";
/// Save peers config to the file.
pub fn save(&self) {
let chain_type = AppConfig::chain_type();
let config_path = Settings::get_config_path(Self::FILE_NAME, Some(&chain_type));
Settings::write_to_file(self, config_path);
}
/// Save seed peer.
pub fn save_seed(&mut self, peer: String) {
self.seeds.insert(self.seeds.len(), peer);
self.save();
}
/// Save allowed peer.
pub fn save_allowed(&mut self, peer: String) {
self.allowed.insert(self.allowed.len(), peer);
self.save();
}
/// Save denied peer.
pub fn save_denied(&mut self, peer: String) {
self.denied.insert(self.denied.len(), peer);
self.save();
}
/// Save preferred peer.
pub fn save_preferred(&mut self, peer: String) {
self.preferred.insert(self.preferred.len(), peer);
self.save();
}
/// Convert string to [`PeerAddr`] if address is in correct format (`host:port`) and available.
pub fn peer_to_addr(peer: String) -> Option<PeerAddr> {
match SocketAddr::from_str(peer.as_str()) {
// Try to parse IP address first.
Ok(ip) => Some(PeerAddr(ip)),
// If that fails it's probably a DNS record.
Err(_) => {
if let Ok(mut socket_addr_list) = peer.to_socket_addrs() {
if let Some(addr) = socket_addr_list.next() {
return Some(PeerAddr(addr));
}
}
None
}
}
}
/// Initialize config with provided [`ChainTypes`].
pub fn for_chain_type(chain_type: &ChainTypes) -> ConfigMembers {
/// Load saved peers to node server [`ConfigMembers`] config.
fn load_to_server_config() {
let mut w_node_config = Settings::node_config_to_update();
// Load seeds.
for seed in w_node_config.peers.seeds.clone() {
if let Some(p) = Self::peer_to_addr(seed.to_string()) {
let mut seeds = w_node_config
.node
.server
.p2p_config
.seeds
.clone()
.unwrap_or(PeerAddrs::default());
seeds.peers.insert(seeds.peers.len(), p);
w_node_config.node.server.p2p_config.seeds = Some(seeds);
}
}
// Load allowed peers.
for peer in w_node_config.peers.allowed.clone() {
if let Some(p) = Self::peer_to_addr(peer.clone()) {
let mut allowed = w_node_config
.node
.server
.p2p_config
.peers_allow
.clone()
.unwrap_or(PeerAddrs::default());
allowed.peers.insert(allowed.peers.len(), p);
w_node_config.node.server.p2p_config.peers_allow = Some(allowed);
}
}
// Load denied peers.
for peer in w_node_config.peers.denied.clone() {
if let Some(p) = Self::peer_to_addr(peer.clone()) {
let mut denied = w_node_config
.node
.server
.p2p_config
.peers_deny
.clone()
.unwrap_or(PeerAddrs::default());
denied.peers.insert(denied.peers.len(), p);
w_node_config.node.server.p2p_config.peers_deny = Some(denied);
}
}
// Load preferred peers.
for peer in &w_node_config.peers.preferred.clone() {
if let Some(p) = Self::peer_to_addr(peer.clone()) {
let mut preferred = w_node_config
.node
.server
.p2p_config
.peers_preferred
.clone()
.unwrap_or(PeerAddrs::default());
preferred.peers.insert(preferred.peers.len(), p);
w_node_config.node.server.p2p_config.peers_preferred = Some(preferred);
}
}
}
}
/// Wrapped node config to be used by [`grin_servers::Server`].
#[derive(Serialize, Deserialize)]
pub struct NodeConfig {
pub(crate) node: ConfigMembers,
pub(crate) peers: PeersConfig
}
impl NodeConfig {
/// Initialize config fields from provided [`ChainTypes`].
pub fn for_chain_type(chain_type: &ChainTypes) -> Self {
// Check secret files for current chain type.
let _ = Self::check_api_secret_files(chain_type, API_SECRET_FILE_NAME);
let _ = Self::check_api_secret_files(chain_type, FOREIGN_API_SECRET_FILE_NAME);
// Create config.
let path = Settings::get_config_path(SERVER_CONFIG_FILE_NAME, Some(chain_type));
let parsed = Settings::read_from_file::<ConfigMembers>(path.clone());
if !path.exists() || parsed.is_err() {
Self::save_default_config(chain_type)
} else {
parsed.unwrap()
}
// Initialize peers config.
let peers_config = {
let path = Settings::get_config_path(PeersConfig::FILE_NAME, Some(chain_type));
let config = Settings::read_from_file::<PeersConfig>(path.clone());
if !path.exists() || config.is_err() {
Self::save_default_peers_config(chain_type)
} else {
config.unwrap()
}
};
// Initialize node config.
let node_config = {
let path = Settings::get_config_path(SERVER_CONFIG_FILE_NAME, Some(chain_type));
let config = Settings::read_from_file::<ConfigMembers>(path.clone());
if !path.exists() || config.is_err() {
Self::save_default_node_server_config(chain_type)
} else {
config.unwrap()
}
};
Self { node: node_config, peers: peers_config }
}
/// Generate and save default node config for specified [`ChainTypes`].
fn save_default_config(chain_type: &ChainTypes) -> ConfigMembers {
/// Save default node config for specified [`ChainTypes`].
fn save_default_node_server_config(chain_type: &ChainTypes) -> ConfigMembers {
let path = Settings::get_config_path(SERVER_CONFIG_FILE_NAME, Some(chain_type));
let mut default_config = GlobalConfig::for_chain(chain_type);
default_config.update_paths(&Settings::get_working_path(Some(chain_type)));
@@ -70,32 +203,42 @@ impl NodeConfig {
config
}
/// Save node config to disk.
pub fn save(&mut self) {
let config_path = Settings::get_config_path(
SERVER_CONFIG_FILE_NAME,
Some(&self.members.server.chain_type)
);
Settings::write_to_file(&self.members, config_path);
/// Save default peers config for specified [`ChainTypes`].
fn save_default_peers_config(chain_type: &ChainTypes) -> PeersConfig {
let path = Settings::get_config_path(PeersConfig::FILE_NAME, Some(chain_type));
let config = PeersConfig::default();
Settings::write_to_file(&config, path);
config
}
/// Get node config values.
pub fn get_members() -> ConfigMembers {
/// Save node config to the file.
pub fn save(&self) {
let config_path = Settings::get_config_path(
SERVER_CONFIG_FILE_NAME,
Some(&self.node.server.chain_type)
);
Settings::write_to_file(&self.node, config_path);
}
/// Get server config to use for node server before start.
pub fn node_server_config() -> ConfigMembers {
PeersConfig::load_to_server_config();
let r_config = Settings::node_config_to_read();
r_config.members.clone()
r_config.node.clone()
}
/// Reset node config to default values.
pub fn reset_to_default() {
let chain_type = {
let r_config = Settings::node_config_to_read();
r_config.members.server.chain_type
r_config.node.server.chain_type
};
let members = Self::save_default_config(&chain_type);
let node_server_config = Self::save_default_node_server_config(&chain_type);
let peers_config = Self::save_default_peers_config(&chain_type);
{
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members = members;
w_node_config.save();
w_node_config.node = node_server_config;
w_node_config.peers = peers_config;
}
}
@@ -134,7 +277,7 @@ impl NodeConfig {
}
/// Check whether a port is available on the provided host.
fn is_port_available(host: &String, port: &String) -> bool {
fn is_host_port_available(host: &String, port: &String) -> bool {
if let Ok(p) = port.parse::<u16>() {
let ip_addr = Ipv4Addr::from_str(host.as_str()).unwrap();
let ipv4 = SocketAddrV4::new(ip_addr, p);
@@ -143,11 +286,27 @@ impl NodeConfig {
false
}
/// Check whether a port is available across the system at all hosts.
fn is_port_available(port: &String) -> bool {
if let Ok(p) = port.parse::<u16>() {
for ip in Self::get_ip_addrs() {
let ip_addr = Ipv4Addr::from_str(ip.as_str()).unwrap();
let ipv4 = SocketAddrV4::new(ip_addr, p);
if TcpListener::bind(ipv4).is_err() {
return false;
}
}
} else {
return false;
}
true
}
/// Get stratum server IP address and port.
pub fn get_stratum_address() -> (String, String) {
let r_config = Settings::node_config_to_read();
let saved_stratum_addr = r_config
.members
.node
.server
.stratum_mining_config
.as_ref()
@@ -164,7 +323,7 @@ impl NodeConfig {
let addr_to_save = format!("{}:{}", addr, port);
let mut w_node_config = Settings::node_config_to_update();
w_node_config
.members
.node
.server
.stratum_mining_config
.as_mut()
@@ -186,14 +345,14 @@ impl NodeConfig {
/// Check if stratum port is available when server is not running.
fn is_not_running_stratum_port_available(ip: &String, port: &String) -> bool {
if Self::is_port_available(&ip, &port) {
if &Self::get_p2p_port().to_string() != port {
if Self::is_host_port_available(&ip, &port) {
if &Self::get_p2p_port() != port {
let (api_ip, api_port) = Self::get_api_address();
return if &api_ip == ip {
&api_port != port
} else {
true
}
};
}
}
false
@@ -202,13 +361,13 @@ impl NodeConfig {
/// Get stratum mining server wallet address to get rewards.
pub fn get_stratum_wallet_addr() -> String {
let r_config = Settings::node_config_to_read();
r_config.members.clone().server.stratum_mining_config.unwrap().wallet_listener_url
r_config.node.clone().server.stratum_mining_config.unwrap().wallet_listener_url
}
/// Get the amount of time in seconds to attempt to mine on a particular header.
pub fn get_stratum_attempt_time() -> String {
let r_config = Settings::node_config_to_read();
r_config.members
r_config.node
.clone()
.server
.stratum_mining_config
@@ -219,8 +378,8 @@ impl NodeConfig {
/// Save stratum attempt time value in seconds.
pub fn save_stratum_attempt_time(time: u32) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members
let w_node_config = Settings::node_config_to_update();
w_node_config.node
.clone()
.server
.stratum_mining_config
@@ -232,7 +391,7 @@ impl NodeConfig {
/// Get minimum acceptable share difficulty to request from miners.
pub fn get_stratum_min_share_diff() -> String {
let r_config = Settings::node_config_to_read();
r_config.members
r_config.node
.clone()
.server
.stratum_mining_config
@@ -243,8 +402,8 @@ impl NodeConfig {
/// Save minimum acceptable share difficulty.
pub fn save_stratum_min_share_diff(diff: u64) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members
let w_node_config = Settings::node_config_to_update();
w_node_config.node
.clone()
.server
.stratum_mining_config
@@ -256,7 +415,7 @@ impl NodeConfig {
/// Check if stratum mining server autorun is enabled.
pub fn is_stratum_autorun_enabled() -> bool {
let stratum_config = Settings::node_config_to_read()
.members
.node
.clone()
.server
.stratum_mining_config
@@ -271,7 +430,7 @@ impl NodeConfig {
pub fn toggle_stratum_autorun() {
let autorun = Self::is_stratum_autorun_enabled();
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members
w_node_config.node
.server
.stratum_mining_config
.as_mut()
@@ -284,7 +443,7 @@ impl NodeConfig {
pub fn get_api_address() -> (String, String) {
let r_config = Settings::node_config_to_read();
let saved_api_addr = r_config
.members
.node
.server
.api_http_addr
.as_str();
@@ -296,7 +455,7 @@ impl NodeConfig {
pub fn save_api_address(addr: &String, port: &String) {
let addr_to_save = format!("{}:{}", addr, port);
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.api_http_addr = addr_to_save;
w_node_config.node.server.api_http_addr = addr_to_save;
w_node_config.save();
}
@@ -309,12 +468,12 @@ impl NodeConfig {
} else {
false
};
if same_running || Self::is_port_available(&ip, &port) {
return &Self::get_p2p_port().to_string() != port;
if same_running || Self::is_host_port_available(ip, port) {
return &Self::get_p2p_port() != port;
}
return false;
} else if Self::is_port_available(&ip, &port) {
return &Self::get_p2p_port().to_string() != port;
} else if Self::is_host_port_available(ip, port) {
return &Self::get_p2p_port() != port;
}
false
}
@@ -323,7 +482,7 @@ impl NodeConfig {
pub fn get_api_secret() -> Option<String> {
let r_config = Settings::node_config_to_read();
let api_secret_path = r_config
.members
.node
.server
.api_secret_path
.clone();
@@ -335,7 +494,7 @@ impl NodeConfig {
Some(first_line.unwrap())
} else {
None
}
};
}
/// Save API secret text.
@@ -347,7 +506,7 @@ impl NodeConfig {
pub fn get_foreign_api_secret() -> Option<String> {
let r_config = Settings::node_config_to_read();
let foreign_secret_path = r_config
.members
.node
.server
.foreign_api_secret_path
.clone();
@@ -359,7 +518,7 @@ impl NodeConfig {
Some(first_line.unwrap())
} else {
None
}
};
}
/// Update Foreign API secret.
@@ -373,8 +532,8 @@ impl NodeConfig {
if value.is_empty() {
let mut w_config = Settings::node_config_to_update();
match file_name {
API_SECRET_FILE_NAME => w_config.members.server.api_secret_path = None,
_ => w_config.members.server.foreign_api_secret_path = None
API_SECRET_FILE_NAME => w_config.node.server.api_secret_path = None,
_ => w_config.node.server.foreign_api_secret_path = None
}
w_config.save();
return;
@@ -385,8 +544,8 @@ impl NodeConfig {
let secret_path = {
let r_config = Settings::node_config_to_read();
let path = match file_name {
API_SECRET_FILE_NAME => r_config.members.server.api_secret_path.clone(),
_ => r_config.members.server.foreign_api_secret_path.clone()
API_SECRET_FILE_NAME => r_config.node.server.api_secret_path.clone(),
_ => r_config.node.server.foreign_api_secret_path.clone()
};
path.unwrap_or_else(|| {
secret_enabled = false;
@@ -400,10 +559,10 @@ impl NodeConfig {
let mut w_config = Settings::node_config_to_update();
match file_name {
API_SECRET_FILE_NAME => w_config
.members
.node
.server
.api_secret_path = Some(secret_path.clone()),
_ => w_config.members.server.foreign_api_secret_path = Some(secret_path.clone())
_ => w_config.node.server.foreign_api_secret_path = Some(secret_path.clone())
};
w_config.save();
@@ -415,19 +574,19 @@ impl NodeConfig {
/// Get Future Time Limit.
pub fn get_ftl() -> String {
Settings::node_config_to_read().members.server.future_time_limit.to_string()
Settings::node_config_to_read().node.server.future_time_limit.to_string()
}
/// Save Future Time Limit.
pub fn save_ftl(ftl: u64) {
let mut w_config = Settings::node_config_to_update();
w_config.members.server.future_time_limit = ftl;
w_config.node.server.future_time_limit = ftl;
w_config.save();
}
/// Check if full chain validation mode is enabled.
pub fn is_full_chain_validation() -> bool {
let mode = Settings::node_config_to_read().members.clone().server.chain_validation_mode;
let mode = Settings::node_config_to_read().node.clone().server.chain_validation_mode;
mode == ChainValidationMode::EveryBlock
}
@@ -440,13 +599,13 @@ impl NodeConfig {
ChainValidationMode::EveryBlock
};
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.chain_validation_mode = new_mode;
w_node_config.node.server.chain_validation_mode = new_mode;
w_node_config.save();
}
/// Check if node is running in archive mode.
pub fn is_archive_mode() -> bool {
let archive_mode = Settings::node_config_to_read().members.clone().server.archive_mode;
let archive_mode = Settings::node_config_to_read().node.clone().server.archive_mode;
archive_mode.is_some() && archive_mode.unwrap()
}
@@ -454,159 +613,219 @@ impl NodeConfig {
pub fn toggle_archive_mode() {
let archive_mode = Self::is_archive_mode();
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.archive_mode = Some(!archive_mode);
w_node_config.node.server.archive_mode = Some(!archive_mode);
w_node_config.save();
}
// P2P settings
/// Get P2P server port.
pub fn get_p2p_port() -> u16 {
Settings::node_config_to_read().members.server.p2p_config.port
pub fn get_p2p_port() -> String {
Settings::node_config_to_read().node.server.p2p_config.port.to_string()
}
/// Get P2P server port.
/// Check if P2P server port is available across the system and config.
pub fn is_p2p_port_available(port: &String) -> bool {
if port.parse::<u16>().is_err() {
return false;
}
let (_, api_port) = Self::get_api_address();
if Node::is_running() {
// Check if P2P server with same port is running.
let same_running = if let Some(running_port) = Node::get_p2p_port() {
&running_port.to_string() == port
} else {
false
};
if same_running || Self::is_port_available(port) {
return &api_port != port;
}
return false;
} else if Self::is_port_available(port) {
return &api_port != port;
}
false
}
/// Save P2P server port.
pub fn save_p2p_port(port: u16) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.p2p_config.port = port;
w_node_config.node.server.p2p_config.port = port;
w_node_config.save();
}
/// Get peers seeding type.
pub fn get_peers_seeding_type() -> Seeding {
Settings::node_config_to_read().members.server.p2p_config.seeding_type
/// Check if default seed list is used.
pub fn is_default_seeding_type() -> bool {
Settings::node_config_to_read().node.server.p2p_config.seeding_type == Seeding::DNSSeed
}
/// Get seeds for [`Seeding::List`] type.
pub fn get_seeds() -> PeerAddrs {
let r_config = Settings::node_config_to_read();
r_config.members.server.p2p_config.seeds.clone().unwrap_or(PeerAddrs::default())
}
/// Save peers seeding type, with list of peers for [`Seeding::List`] type.
pub fn save_peers_seeding_type(seeding_type: Seeding, peers: Option<PeerAddrs>) {
/// Toggle seeding type to use default or custom seed list.
pub fn toggle_seeding_type() {
let seeding_type = if Self::is_default_seeding_type() {
Seeding::List
} else {
Seeding::DNSSeed
};
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.p2p_config.seeding_type = seeding_type;
if seeding_type == Seeding::List {
w_node_config.members.server.p2p_config.seeds = peers;
}
w_node_config.node.server.p2p_config.seeding_type = seeding_type;
w_node_config.save();
}
/// Get custom seed peers.
pub fn get_custom_seeds() -> Vec<String> {
Settings::node_config_to_read().peers.seeds.clone()
}
/// Save custom seed peer.
pub fn save_custom_seed(peer: String) {
let mut w_node_config = Settings::node_config_to_update();
let size = w_node_config.peers.seeds.len();
w_node_config.peers.seeds.insert(size, peer);
w_node_config.peers.save();
}
/// Remove custom seed peer.
pub fn remove_custom_seed(peer: &String) {
let mut w_node_config = Settings::node_config_to_update();
let mut seeds = w_node_config.peers.seeds.clone();
if let Some(index) = seeds.iter().position(|x| x == peer) {
seeds.remove(index);
}
w_node_config.peers.seeds = seeds;
w_node_config.peers.save();
}
/// Get denied peer list.
pub fn get_denied_peers() -> PeerAddrs {
let r_config = Settings::node_config_to_read();
r_config.members.server.p2p_config.peers_deny.clone().unwrap_or(PeerAddrs::default())
pub fn get_denied_peers() -> Vec<String> {
Settings::node_config_to_read().peers.denied.clone()
}
/// Add peer at denied list.
/// Save peer to denied list.
pub fn deny_peer(peer: String) {
let ip_addr = IpAddr::from_str(peer.as_str()).unwrap();
let peer_addr = PeerAddr::from_ip(ip_addr);
let mut deny_peers = Self::get_denied_peers();
deny_peers.peers.insert(0, peer_addr);
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.p2p_config.peers_deny = Some(deny_peers);
w_node_config.save();
let size = w_node_config.peers.denied.len();
w_node_config.peers.denied.insert(size, peer);
w_node_config.peers.save();
}
/// Save denied peer list.
pub fn save_denied_peers(peers: Option<PeerAddrs>) {
/// Remove denied peer.
pub fn remove_denied_peer(peer: &String) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.p2p_config.peers_deny = peers;
w_node_config.save();
let mut denied = w_node_config.peers.denied.clone();
if let Some(index) = denied.iter().position(|x| x == peer) {
denied.remove(index);
}
w_node_config.peers.denied = denied;
w_node_config.peers.save();
}
/// Get allowed peer list.
pub fn get_allowed_peers() -> PeerAddrs {
let r_config = Settings::node_config_to_read();
r_config.members.server.p2p_config.peers_allow.clone().unwrap_or(PeerAddrs::default())
pub fn get_allowed_peers() -> Vec<String> {
Settings::node_config_to_read().peers.allowed.clone()
}
/// Save allowed peer list.
pub fn save_allowed_peers(peers: Option<PeerAddrs>) {
/// Save peer to allowed list.
pub fn allow_peer(peer: String) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.p2p_config.peers_allow = peers;
w_node_config.save();
let size = w_node_config.peers.allowed.len();
w_node_config.peers.allowed.insert(size, peer);
w_node_config.peers.save();
}
/// Remove allowed peer.
pub fn remove_allowed_peer(peer: &String) {
let mut w_node_config = Settings::node_config_to_update();
let mut allowed = w_node_config.peers.allowed.clone();
if let Some(index) = allowed.iter().position(|x| x == peer) {
allowed.remove(index);
}
w_node_config.peers.allowed = allowed;
w_node_config.peers.save();
}
/// Get preferred peer list.
pub fn get_preferred_peers() -> PeerAddrs {
let r_config = Settings::node_config_to_read();
r_config.members.server.p2p_config.peers_preferred.clone().unwrap_or(PeerAddrs::default())
pub fn get_preferred_peers() -> Vec<String> {
Settings::node_config_to_read().peers.preferred.clone()
}
/// Add peer at preferred list.
pub fn prefer_peer(peer: String) {
let ip_addr = IpAddr::from_str(peer.as_str()).unwrap();
let peer_addr = PeerAddr::from_ip(ip_addr);
let mut prefer_peers = Self::get_preferred_peers();
prefer_peers.peers.insert(0, peer_addr);
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.p2p_config.peers_preferred = Some(prefer_peers);
w_node_config.save();
let size = w_node_config.peers.preferred.len();
w_node_config.peers.preferred.insert(size, peer);
w_node_config.peers.save();
}
/// Save preferred peer list.
pub fn save_preferred_peers(peers: Option<PeerAddrs>) {
/// Remove preferred peer.
pub fn remove_preferred_peer(peer: &String) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.p2p_config.peers_preferred = peers;
w_node_config.save();
let mut preferred = w_node_config.peers.preferred.clone();
if let Some(index) = preferred.iter().position(|x| x == peer) {
preferred.remove(index);
}
w_node_config.peers.preferred = preferred;
w_node_config.peers.save();
}
/// How long a banned peer should stay banned in ms.
pub fn get_ban_window() -> i64 {
Settings::node_config_to_read().members.server.p2p_config.ban_window()
pub fn get_p2p_ban_window() -> String {
Settings::node_config_to_read().node.server.p2p_config.ban_window().to_string()
}
/// Save for how long a banned peer should stay banned in ms.
pub fn save_ban_window(time: i64) {
pub fn save_p2p_ban_window(time: i64) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.p2p_config.ban_window = Some(time);
w_node_config.node.server.p2p_config.ban_window = Some(time);
w_node_config.save();
}
/// Maximum number of inbound peer connections.
pub fn get_max_inbound_count() -> u32 {
Settings::node_config_to_read().members.server.p2p_config.peer_max_inbound_count()
pub fn get_max_inbound_peers() -> String {
Settings::node_config_to_read()
.node.server
.p2p_config
.peer_max_inbound_count()
.to_string()
}
/// Save maximum number of inbound peer connections.
pub fn save_max_inbound_count(count: u32) {
pub fn save_max_inbound_peers(count: u32) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.p2p_config.peer_max_inbound_count = Some(count);
w_node_config.node.server.p2p_config.peer_max_inbound_count = Some(count);
w_node_config.save();
}
/// Maximum number of outbound peer connections.
pub fn get_max_outbound_count() -> u32 {
Settings::node_config_to_read().members.server.p2p_config.peer_max_outbound_count()
pub fn get_max_outbound_peers() -> String {
Settings::node_config_to_read()
.node
.server
.p2p_config
.peer_max_outbound_count()
.to_string()
}
/// Save maximum number of outbound peer connections.
pub fn save_max_outbound_count(count: u32) {
pub fn save_max_outbound_peers(count: u32) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.p2p_config.peer_max_outbound_count = Some(count);
w_node_config.node.server.p2p_config.peer_max_outbound_count = Some(count);
w_node_config.save();
}
/// Minimum number of outbound peer connections.
pub fn get_min_outbound_count() -> u32 {
pub fn get_min_outbound_peers() -> String {
Settings::node_config_to_read()
.members
.node
.server
.p2p_config
.peer_min_preferred_outbound_count()
.to_string()
}
/// Save minimum number of outbound peer connections.
pub fn save_min_outbound_count(count: u32) {
pub fn save_min_outbound_peers(count: u32) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.p2p_config.peer_min_preferred_outbound_count = Some(count);
w_node_config.node.server.p2p_config.peer_min_preferred_outbound_count = Some(count);
w_node_config.save();
}
@@ -614,61 +833,61 @@ impl NodeConfig {
/// Base fee that's accepted into the pool.
pub fn get_base_fee() -> String {
Settings::node_config_to_read().members.server.pool_config.accept_fee_base.to_string()
Settings::node_config_to_read().node.server.pool_config.accept_fee_base.to_string()
}
/// Save base fee that's accepted into the pool.
pub fn save_base_fee(fee: u64) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.pool_config.accept_fee_base = fee;
w_node_config.node.server.pool_config.accept_fee_base = fee;
w_node_config.save();
}
/// Reorg cache retention period in minutes.
pub fn get_reorg_cache_period() -> String {
Settings::node_config_to_read().members.server.pool_config.reorg_cache_period.to_string()
Settings::node_config_to_read().node.server.pool_config.reorg_cache_period.to_string()
}
/// Save reorg cache retention period in minutes.
pub fn save_reorg_cache_period(period: u32) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.pool_config.reorg_cache_period = period;
w_node_config.node.server.pool_config.reorg_cache_period = period;
w_node_config.save();
}
/// Max amount of transactions at pool.
pub fn get_max_pool_size() -> String {
Settings::node_config_to_read().members.server.pool_config.max_pool_size.to_string()
Settings::node_config_to_read().node.server.pool_config.max_pool_size.to_string()
}
/// Save max amount of transactions at pool.
pub fn save_max_pool_size(amount: usize) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.pool_config.max_pool_size = amount;
w_node_config.node.server.pool_config.max_pool_size = amount;
w_node_config.save();
}
/// Max amount of transactions at stem pool.
pub fn get_max_stempool_size() -> String {
Settings::node_config_to_read().members.server.pool_config.max_stempool_size.to_string()
Settings::node_config_to_read().node.server.pool_config.max_stempool_size.to_string()
}
/// Save max amount of transactions at stem pool.
pub fn save_max_stempool_size(amount: usize) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.pool_config.max_stempool_size = amount;
w_node_config.node.server.pool_config.max_stempool_size = amount;
w_node_config.save();
}
/// Max total weight of transactions that can get selected to build a block.
pub fn get_mineable_max_weight() -> String {
Settings::node_config_to_read().members.server.pool_config.mineable_max_weight.to_string()
Settings::node_config_to_read().node.server.pool_config.mineable_max_weight.to_string()
}
/// Set max total weight of transactions that can get selected to build a block.
pub fn save_mineable_max_weight(weight: u64) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.pool_config.mineable_max_weight = weight;
w_node_config.node.server.pool_config.mineable_max_weight = weight;
w_node_config.save();
}
@@ -676,63 +895,63 @@ impl NodeConfig {
/// Dandelion epoch duration in seconds.
pub fn get_dandelion_epoch() -> String {
Settings::node_config_to_read().members.server.dandelion_config.epoch_secs.to_string()
Settings::node_config_to_read().node.server.dandelion_config.epoch_secs.to_string()
}
/// Save Dandelion epoch duration in seconds.
pub fn save_dandelion_epoch(secs: u16) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.dandelion_config.epoch_secs = secs;
w_node_config.node.server.dandelion_config.epoch_secs = secs;
w_node_config.save();
}
/// Dandelion embargo timer in seconds.
/// Fluff and broadcast after embargo expires if tx not seen on network.
pub fn get_dandelion_embargo() -> String {
Settings::node_config_to_read().members.server.dandelion_config.embargo_secs.to_string()
Settings::node_config_to_read().node.server.dandelion_config.embargo_secs.to_string()
}
/// Save Dandelion embargo timer in seconds.
pub fn save_dandelion_embargo(secs: u16) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.dandelion_config.embargo_secs = secs;
w_node_config.node.server.dandelion_config.embargo_secs = secs;
w_node_config.save();
}
/// Dandelion aggregation period in seconds.
pub fn get_dandelion_aggregation() -> String {
Settings::node_config_to_read().members.server.dandelion_config.aggregation_secs.to_string()
Settings::node_config_to_read().node.server.dandelion_config.aggregation_secs.to_string()
}
/// Save Dandelion aggregation period in seconds.
pub fn save_dandelion_aggregation(secs: u16) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.dandelion_config.aggregation_secs = secs;
w_node_config.node.server.dandelion_config.aggregation_secs = secs;
w_node_config.save();
}
/// Dandelion stem probability (default: stem 90% of the time, fluff 10% of the time).
pub fn get_stem_probability() -> String {
Settings::node_config_to_read().members.server.dandelion_config.stem_probability.to_string()
Settings::node_config_to_read().node.server.dandelion_config.stem_probability.to_string()
}
/// Save Dandelion stem probability.
pub fn save_stem_probability(percent: u8) {
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.dandelion_config.stem_probability = percent;
w_node_config.node.server.dandelion_config.stem_probability = percent;
w_node_config.save();
}
/// Default to always stem our txs as described in Dandelion++ paper.
pub fn always_stem_our_txs() -> bool {
Settings::node_config_to_read().members.server.dandelion_config.always_stem_our_txs
Settings::node_config_to_read().node.server.dandelion_config.always_stem_our_txs
}
/// Toggle stem of our txs.
pub fn toggle_always_stem_our_txs() {
let stem_txs = Self::always_stem_our_txs();
let mut w_node_config = Settings::node_config_to_update();
w_node_config.members.server.dandelion_config.always_stem_our_txs = !stem_txs;
w_node_config.node.server.dandelion_config.always_stem_our_txs = !stem_txs;
w_node_config.save();
}
}
src/node/mod.rs
+1 -1
View File
@@ -20,4 +20,4 @@ mod config;
mod stratum;
mod mine_block;
pub use config::NodeConfig;
pub use config::{NodeConfig, PeersConfig};
src/node/node.rs
+11 -11
View File
@@ -79,6 +79,9 @@ impl Default for Node {
}
impl Node {
/// Delay for server thread to update the stats.
pub const STATS_UPDATE_DELAY: Duration = Duration::from_millis(250);
/// Stop the [`Server`] and setup exit flag after if needed.
pub fn stop(exit_after_stop: bool) {
NODE_STATE.stop_needed.store(true, Ordering::Relaxed);
@@ -262,7 +265,7 @@ impl Node {
NODE_STATE.start_stratum_needed.store(false, Ordering::Relaxed);
}
thread::sleep(Duration::from_millis(250));
thread::sleep(Self::STATS_UPDATE_DELAY);
}
}
Err(e) => {
@@ -495,11 +498,11 @@ impl Node {
/// Start the node [`Server`].
fn start_node_server() -> Result<Server, Error> {
// Get current global config
let config = NodeConfig::get_members();
// Get saved server config.
let config = NodeConfig::node_server_config();
let server_config = config.server.clone();
// Remove temporary file dir
// Remove temporary file dir.
{
let mut tmp_dir = PathBuf::from(&server_config.db_root);
tmp_dir = tmp_dir.parent().unwrap().to_path_buf();
@@ -511,6 +514,7 @@ fn start_node_server() -> Result<Server, Error> {
}
}
}
// Initialize our global chain_type, feature flags (NRD kernel support currently),
// accept_fee_base, and future_time_limit.
// These are read via global and not read from config beyond this point.
@@ -524,22 +528,18 @@ fn start_node_server() -> Result<Server, Error> {
if !global::GLOBAL_NRD_FEATURE_ENABLED.is_init() {
match global::get_chain_type() {
ChainTypes::Mainnet => {
// Set various mainnet specific feature flags.
global::init_global_nrd_enabled(false);
}
_ => {
// Set various non-mainnet feature flags.
global::init_global_nrd_enabled(true);
}
}
} else {
match global::get_chain_type() {
ChainTypes::Mainnet => {
// Set various mainnet specific feature flags.
global::set_global_nrd_enabled(false);
}
_ => {
// Set various non-mainnet feature flags.
global::set_global_nrd_enabled(true);
}
}
@@ -562,13 +562,13 @@ fn start_node_server() -> Result<Server, Error> {
let api_chan: &'static mut (oneshot::Sender<()>, oneshot::Receiver<()>) =
Box::leak(Box::new(oneshot::channel::<()>()));
// Write launching API server address.
// Set launching API server address from config to state.
{
let mut w_api_addr = NODE_STATE.api_addr.write().unwrap();
*w_api_addr = Some(config.server.api_http_addr);
}
// Write launching P2P server port.
// Set launching P2P server port from config to state.
{
let mut w_p2p_port = NODE_STATE.p2p_port.write().unwrap();
*w_p2p_port = Some(config.server.p2p_config.port);
@@ -579,7 +579,7 @@ fn start_node_server() -> Result<Server, Error> {
NODE_STATE.start_stratum_needed.store(true, Ordering::Relaxed);
}
let server_result = Server::new(server_config.clone(), None, api_chan);
let server_result = Server::new(server_config, None, api_chan);
server_result
}