Retropex/knots-startos
1
0
Fork 0
mirror of https://github.com/Retropex/knots-startos.git synced 2025-05-12 19:30:45 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update main.rs to fix issue

Browse Source
This commit is contained in:
copy2018 2025-03-07 13:53:59 +00:00 committed by GitHub
parent c5bed35b85
commit fa44a2d75d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 54 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

223
manager/src/main.rs
View File

@ -33,11 +33,8 @@ pub struct ChainInfo {
#[derive(Clone, Debug, serde::Deserialize)]
pub struct NetworkInfo {
#[allow(dead_code)]
connections: usize,
#[allow(dead_code)]
connections_in: usize,
#[allow(dead_code)]
connections_out: usize,
}
@ -115,50 +112,6 @@ pub struct Stat {
fn sidecar(config: &Mapping, addr: &str) -> Result<(), Box<dyn Error>> {
let mut stats = LinearMap::new();
// Node uptime with years included
let uptime_info = std::process::Command::new("bitcoin-cli")
.arg("-conf=/root/.bitcoin/bitcoin.conf")
.arg("uptime")
.output()?;
if uptime_info.status.success() {
let uptime_seconds = String::from_utf8_lossy(&uptime_info.stdout)
.trim()
.parse::<u64>()
.unwrap_or(0);
let years = uptime_seconds / 31_536_000;
let days = (uptime_seconds % 31_536_000) / 86400;
let hours = (uptime_seconds % 86400) / 3600;
let minutes = (uptime_seconds % 3600) / 60;
let uptime_formatted = if years > 0 {
format!("{} years, {} days, {} hours, {} minutes", years, days, hours, minutes)
} else if days > 0 {
format!("{} days, {} hours, {} minutes", days, hours, minutes)
} else if hours > 0 {
format!("{} hours, {} minutes", hours, minutes)
} else {
format!("{} minutes", minutes)
};
stats.insert(
Cow::from("Node Uptime"),
Stat {
value_type: "string",
value: uptime_formatted,
description: Some(Cow::from("Total time the Bitcoin node has been running")),
copyable: false,
qr: false,
masked: false,
},
);
} else {
eprintln!(
"Error retrieving uptime info: {}",
std::str::from_utf8(&uptime_info.stderr).unwrap_or("UNKNOWN ERROR")
);
}
if let (Some(user), Some(pass)) = (
config
.get(&Value::String("rpc".to_owned()))
@ -215,132 +168,60 @@ fn sidecar(config: &Mapping, addr: &str) -> Result<(), Box<dyn Error>> {
},
);
}
// Calculate total supply and progress to the next halving
let blockchain_info = std::process::Command::new("bitcoin-cli")
.arg("-conf=/root/.bitcoin/bitcoin.conf")
.arg("getblockchaininfo")
.output()?;
if blockchain_info.status.success() {
let blockchain_data: serde_json::Value = serde_json::from_slice(&blockchain_info.stdout)?;
let current_height = blockchain_data["blocks"].as_u64().unwrap_or(0);
// Calculate total supply based on height and halving intervals
let halving_interval = 210_000;
let mut subsidy = 50.0; // Initial subsidy in BTC
let mut total_supply = 0.0;
let mut remaining_height = current_height;
while remaining_height > 0 {
let blocks_in_this_epoch = remaining_height.min(halving_interval);
total_supply += blocks_in_this_epoch as f64 * subsidy;
remaining_height = remaining_height.saturating_sub(halving_interval);
subsidy /= 2.0;
}
stats.insert(
Cow::from("Total Bitcoin Supply"),
Stat {
value_type: "string",
value: format!("{:.8} BTC", total_supply),
description: Some(Cow::from("Current total supply of Bitcoin based on issuance schedule")),
copyable: false,
qr: false,
masked: false,
},
);
// Progress to Next Halving calculation
let last_halving_block = (current_height / halving_interval) * halving_interval;
let blocks_since_last_halving = current_height - last_halving_block;
let progress_to_next_halving = (blocks_since_last_halving as f64 / halving_interval as f64) * 100.0;
stats.insert(
Cow::from("Progress to Next Halving"),
Stat {
value_type: "string",
value: format!("{:.2}%", progress_to_next_halving),
description: Some(Cow::from("Percentage of blocks completed until the next Bitcoin halving")),
copyable: false,
qr: false,
masked: false,
},
);
}
// New section to fetch and display a simplified mempool summary
let mempool_info = std::process::Command::new("bitcoin-cli")
.arg("-conf=/root/.bitcoin/bitcoin.conf")
.arg("getmempoolinfo")
.output()?;
if mempool_info.status.success() {
let mempool_data: serde_json::Value = serde_json::from_slice(&mempool_info.stdout)?;
let max_mempool = mempool_data["maxmempool"].as_u64().unwrap_or(0) as f64 / 1024_f64.powf(2.0); // Convert to MB
let mempool_usage = mempool_data["usage"].as_u64().unwrap_or(0) as f64 / 1024_f64.powf(2.0); // Convert to MB
let mempool_percent = if max_mempool > 0.0 {
(mempool_usage / max_mempool) * 100.0
} else {
0.0
};
let tx_count = mempool_data["size"].as_u64().unwrap_or(0); // Number of transactions
// Insert the simplified mempool summary
stats.insert(
Cow::from("Mempool Summary"),
Stat {
value_type: "string",
value: format!(
"{:.2}/{:.2} MB ({:.2}%), {} Transactions",
mempool_usage, max_mempool, mempool_percent, tx_count
),
description: Some(Cow::from("Summary of current mempool usage and transaction count")),
copyable: false,
qr: false,
masked: false,
},
);
} else {
eprintln!(
"Error retrieving mempool info: {}",
std::str::from_utf8(&mempool_info.stderr).unwrap_or("UNKNOWN ERROR")
);
}
// Existing code for blockchain and network info retrieval continues here...
let info_res = std::process::Command::new("bitcoin-cli")
.arg("-conf=/root/.bitcoin/bitcoin.conf")
.arg("getblockchaininfo")
.output()?;
if info_res.status.success() {
let info: ChainInfo = serde_json::from_slice(&info_res.stdout)?;
// Consolidated block height and sync progress information
// Extract values for current synced blocks, total headers, and sync progress percentage
let current_blocks = info.blocks;
let total_headers = info.headers;
let sync_progress = if current_blocks < total_headers {
100.0 * info.verificationprogress
} else {
100.0
};
// Insert the simplified blockchain sync summary
// Define the next halving block height
let next_halving = ((info.headers / 210000) * 210000) + 210000;
let progress_to_halving = 100.0 * (info.headers as f64 / next_halving as f64);
stats.insert(
Cow::from("Blockchain Sync Summary"),
Cow::from("Progress to Next Halving"),
Stat {
value_type: "string",
value: format!(
"{}/{} ({:.2}%)",
current_blocks, total_headers, sync_progress
),
description: Some(Cow::from("Current synced block height out of total headers and sync progress")),
value: format!("{:.2}%", progress_to_halving),
description: Some(Cow::from("Percentage progress towards the next Bitcoin halving event")),
copyable: false,
qr: false,
masked: false,
},
);
);
stats.insert(
Cow::from("Blockchain Sync Summary"),
Stat {
value_type: "string",
value: format!("{} / {} ({:.2}%)", info.blocks, info.headers, 100.0 * info.verificationprogress),
description: Some(Cow::from("Current synced block height / actual network block height and sync percentage")),
copyable: false,
qr: false,
masked: false,
},
);
} else {
eprintln!(
"Error updating blockchain info: {}",
std::str::from_utf8(&info_res.stderr).unwrap_or("UNKNOWN ERROR")
);
}
serde_yaml::to_writer(
std::fs::File::create("/root/.bitcoin/start9/.stats.yaml.tmp")?,
&Stats {
version: 2,
data: stats,
},
)?;
std::fs::rename(
"/root/.bitcoin/start9/.stats.yaml.tmp",
"/root/.bitcoin/start9/stats.yaml",
)?;
Ok(())
}
for (sf_name, sf_data) in info.softforks {
let sf_name_pretty = sf_name.to_title_case();
let status_desc = Some(Cow::from(format!(
@ -545,7 +426,6 @@ if mempool_info.status.success() {
)?;
Ok(())
}
fn inner_main(reindex: bool, reindex_chainstate: bool) -> Result<(), Box<dyn Error>> {
while !Path::new("/root/.bitcoin/start9/config.yaml").exists() {
@ -598,16 +478,24 @@ fn inner_main(reindex: bool, reindex_chainstate: bool) -> Result<(), Box<dyn Err
a => a?,
}
}
std::io::copy(
&mut TemplatingReader::new(
std::fs::File::open("/mnt/assets/bitcoin.conf.template")?,
&config,
&"{{var}}".parse()?,
b'%',
),
&mut std::fs::File::create("/root/.bitcoin/bitcoin.conf")?,
)?;
let mut child = std::process::Command::new("bitcoind")
.args(btc_args)
.spawn()?;
let raw_child = child.id();
*CHILD_PID.lock().unwrap() = Some(raw_child);
let pruned = {
config[&Value::from("advanced")][&Value::from("pruning")][&Value::from("mode")] == "automatic"
config[&Value::from("advanced")][&Value::from("pruning")][&Value::from("mode")]
== "automatic"
};
let _proxy = if pruned {
let state = Arc::new(btc_rpc_proxy::State {
@ -653,13 +541,10 @@ fn inner_main(reindex: bool, reindex_chainstate: bool) -> Result<(), Box<dyn Err
} else {
1
};
std::process::exit(code)
}
fn main() -> Result<(), Box<dyn Error>> {
env_logger::Builder::from_env(Env::default().default_filter_or("warn")).init();
let reindex = Path::new("/root/.bitcoin/requires.reindex").exists();