diff --git a/src/app/panels/middle/status/mod.rs b/src/app/panels/middle/status/mod.rs
index 633e82e..7357d72 100644
--- a/src/app/panels/middle/status/mod.rs
+++ b/src/app/panels/middle/status/mod.rs
@@ -19,7 +19,7 @@ use crate::{
app::{Benchmark, eframe_impl::ProcessStatesGui},
disk::{gupax_p2pool_api::GupaxP2poolApi, state::Status, status::*},
helper::{
- ProcessName, Sys,
+ ProcessName, ProcessState, Sys,
node::PubNodeApi,
p2pool::{ImgP2pool, PubP2poolApi},
xrig::{
@@ -75,7 +75,7 @@ impl Status {
self.p2pool(
ui,
gupax_p2pool_api,
- states.is_alive(ProcessName::P2pool),
+ states.find(ProcessName::P2pool).state == ProcessState::Alive,
p2pool_api,
);
//---------------------------------------------------------------------------------------------------- [Benchmarks]
diff --git a/src/app/panels/middle/status/p2pool.rs b/src/app/panels/middle/status/p2pool.rs
index 1abfd78..8604e60 100644
--- a/src/app/panels/middle/status/p2pool.rs
+++ b/src/app/panels/middle/status/p2pool.rs
@@ -366,11 +366,6 @@ impl Status {
});
});
});
- // Tick bar
- ui.vertical_centered(|ui| {
- ui.label(api.calculate_tick_bar())
- .on_hover_text(STATUS_SUBMENU_PROGRESS_BAR);
- });
drop(api);
});
});
diff --git a/src/helper/p2pool.rs b/src/helper/p2pool.rs
index abe21fa..72547ab 100644
--- a/src/helper/p2pool.rs
+++ b/src/helper/p2pool.rs
@@ -30,7 +30,6 @@ use crate::helper::signal_end;
use crate::helper::sleep_end_loop;
use crate::regex::P2POOL_REGEX;
use crate::regex::contains_end_status;
-use crate::regex::contains_newchain_tip;
use crate::regex::contains_statuscommand;
use crate::regex::contains_yourhashrate;
use crate::regex::contains_yourshare;
@@ -691,30 +690,21 @@ impl Helper {
// check if state must be changed based on local and p2p API
pub_api_lock.update_state(&mut process_lock);
- // If more than 1 minute has passed, read the other API files.
- let last_p2pool_request_expired =
- last_p2pool_request.elapsed() >= Duration::from_secs(60);
- // need to reload fast to get the first right values after syncing.
- // check if value is 100k or under and request immediately if that's the case. fixed in release of p2pool including commit https://github.com/SChernykh/p2pool/commit/64a199be6dec7924b41f857a401086f25e1ec9be
- if (last_p2pool_request_expired || pub_api_lock.p2pool_difficulty_u64 <= 100000)
- && process_lock.state == ProcessState::Alive
- {
- debug!("P2Pool Watchdog | Attempting [network] & [pool] API file read");
+ debug!("P2Pool Watchdog | Attempting [network] & [pool] API file read");
+ if let (Ok(network_api), Ok(pool_api)) = (
+ Self::path_to_string(&api_path_network, ProcessName::P2pool),
+ Self::path_to_string(&api_path_pool, ProcessName::P2pool),
+ ) {
if let (Ok(network_api), Ok(pool_api)) = (
- Self::path_to_string(&api_path_network, ProcessName::P2pool),
- Self::path_to_string(&api_path_pool, ProcessName::P2pool),
+ PrivP2poolNetworkApi::from_str(&network_api),
+ PrivP2poolPoolApi::from_str(&pool_api),
) {
- if let (Ok(network_api), Ok(pool_api)) = (
- PrivP2poolNetworkApi::from_str(&network_api),
- PrivP2poolPoolApi::from_str(&pool_api),
- ) {
- PubP2poolApi::update_from_network_pool(
- &mut pub_api_lock,
- network_api,
- pool_api,
- );
- last_p2pool_request = tokio::time::Instant::now();
- }
+ PubP2poolApi::update_from_network_pool(
+ &mut pub_api_lock,
+ network_api,
+ pool_api,
+ );
+ last_p2pool_request = tokio::time::Instant::now();
}
}
@@ -883,8 +873,7 @@ pub struct PubP2poolApi {
// from status
pub sidechain_shares: u32,
pub sidechain_ehr: f32,
- // from height
- pub synchronised: bool,
+ pub sidechain_height: u32,
// from local/p2p
pub p2p_connected: u32,
pub node_connected: bool,
@@ -940,8 +929,8 @@ impl PubP2poolApi {
user_monero_percent: HumanNumber::unknown(),
sidechain_shares: 0,
sidechain_ehr: 0.0,
+ sidechain_height: 0,
p2p_connected: 0,
- synchronised: false,
node_connected: false,
prefer_local_node: true,
}
@@ -1007,33 +996,6 @@ impl PubP2poolApi {
// 2. Parse the full STDOUT
let mut output_parse = output_parse.lock().unwrap();
let (payouts_new, xmr_new) = Self::calc_payouts_and_xmr(&output_parse);
- // Check for "SYNCHRONIZED" only if we aren't already. Works at level 0 and above.
- if process.state == ProcessState::Syncing {
- // How many times the word was captured.
- let synchronized_captures = P2POOL_REGEX.synchronized.find_iter(&output_parse).count();
-
- // If P2Pool receives shares before syncing, it will start mining on its own sidechain.
- // In this instance, we technically are "synced" on block 1 and P2Pool will print "SYNCHRONIZED"
- // although, that doesn't necessarily mean we're synced on main/mini-chain.
- //
- // So, if we find a `next block = 1`, that means we
- // must look for at least 2 instances of "SYNCHRONIZED",
- // one for the sidechain, one for main/mini.
- if P2POOL_REGEX.next_height_1.is_match(&output_parse) {
- if synchronized_captures > 1 {
- process.state = ProcessState::Alive;
- }
- } else if synchronized_captures > 0 {
- // if there is no `next block = 1`, fallback to
- // just finding 1 instance of "SYNCHRONIZED".
- process.state = ProcessState::Alive;
- }
- // if the p2pool node was synced but is not anymore due to faulty monero node and is synced again, the status must be alive again
- // required log level 2 minimum
- if contains_newchain_tip(&output_parse) {
- process.state = ProcessState::Alive;
- }
- }
// if the node is offline, p2pool can not function properly. Requires at least p2pool log level 1
if process.state == ProcessState::Alive && contains_zmq_failure(&output_parse) {
process.state = ProcessState::Syncing;
@@ -1120,8 +1082,8 @@ impl PubP2poolApi {
pub(super) fn update_from_p2p(public: &mut Self, p2p: PrivP2PoolP2PApi) {
*public = Self {
p2p_connected: p2p.connections,
- // 30 seconds before concluding the monero node connection is lost
- node_connected: p2p.zmq_last_active.is_some_and(|x| x < 30),
+ // 10 seconds before concluding the monero node connection is lost
+ node_connected: p2p.zmq_last_active.is_some_and(|x| x < 10),
..std::mem::take(&mut *public)
};
}
@@ -1187,6 +1149,7 @@ impl PubP2poolApi {
p2pool_difficulty: HumanNumber::from_u64(p2pool_difficulty),
p2pool_hashrate: HumanNumber::from_u64_to_megahash_3_point(p2pool_hashrate),
miners: HumanNumber::from_u32(pool.pool_statistics.miners),
+ sidechain_height: pool.pool_statistics.sidechainHeight,
solo_block_mean,
p2pool_block_mean,
p2pool_share_mean,
@@ -1196,16 +1159,19 @@ impl PubP2poolApi {
..std::mem::take(&mut *public)
};
}
- /// Check if all conditions are met to be alive or if something is wrong
fn update_state(&self, process: &mut Process) {
if process.state == ProcessState::Syncing
- && self.synchronised
&& self.node_connected
&& self.p2p_connected > 1
- && self.height > 10
+ && self.sidechain_height > 1000
{
process.state = ProcessState::Alive;
}
+ if process.state == ProcessState::Alive
+ && (self.sidechain_height < 1000 || !self.node_connected || self.p2p_connected == 0)
+ {
+ process.state = ProcessState::Syncing;
+ }
}
#[inline]
@@ -1226,77 +1192,6 @@ impl PubP2poolApi {
HumanNumber::from_f64_to_percent_6_point(f)
}
}
-
- pub const fn calculate_tick_bar(&self) -> &'static str {
- // The stars are reduced by one because it takes a frame to render the stats.
- // We want 0 stars at the same time stats are rendered, so it looks a little off here.
- // let stars = "*".repeat(self.tick - 1);
- // let blanks = " ".repeat(60 - (self.tick - 1));
- // [use crate::PubP2poolApi;use crate::PubP2poolApi;"[", &stars, &blanks, "]"].concat().as_str()
- match self.tick {
- 0 => "[ ]",
- 1 => "[* ]",
- 2 => "[** ]",
- 3 => "[*** ]",
- 4 => "[**** ]",
- 5 => "[***** ]",
- 6 => "[****** ]",
- 7 => "[******* ]",
- 8 => "[******** ]",
- 9 => "[********* ]",
- 10 => "[********** ]",
- 11 => "[*********** ]",
- 12 => "[************ ]",
- 13 => "[************* ]",
- 14 => "[************** ]",
- 15 => "[*************** ]",
- 16 => "[**************** ]",
- 17 => "[***************** ]",
- 18 => "[****************** ]",
- 19 => "[******************* ]",
- 20 => "[******************** ]",
- 21 => "[********************* ]",
- 22 => "[********************** ]",
- 23 => "[*********************** ]",
- 24 => "[************************ ]",
- 25 => "[************************* ]",
- 26 => "[************************** ]",
- 27 => "[*************************** ]",
- 28 => "[**************************** ]",
- 29 => "[***************************** ]",
- 30 => "[****************************** ]",
- 31 => "[******************************* ]",
- 32 => "[******************************** ]",
- 33 => "[********************************* ]",
- 34 => "[********************************** ]",
- 35 => "[*********************************** ]",
- 36 => "[************************************ ]",
- 37 => "[************************************* ]",
- 38 => "[************************************** ]",
- 39 => "[*************************************** ]",
- 40 => "[**************************************** ]",
- 41 => "[***************************************** ]",
- 42 => "[****************************************** ]",
- 43 => "[******************************************* ]",
- 44 => "[******************************************** ]",
- 45 => "[********************************************* ]",
- 46 => "[********************************************** ]",
- 47 => "[*********************************************** ]",
- 48 => "[************************************************ ]",
- 49 => "[************************************************* ]",
- 50 => "[************************************************** ]",
- 51 => "[*************************************************** ]",
- 52 => "[**************************************************** ]",
- 53 => "[***************************************************** ]",
- 54 => "[****************************************************** ]",
- 55 => "[******************************************************* ]",
- 56 => "[******************************************************** ]",
- 57 => "[********************************************************* ]",
- 58 => "[********************************************************** ]",
- 59 => "[*********************************************************** ]",
- _ => "[************************************************************]",
- }
- }
}
//---------------------------------------------------------------------------------------------------- Private P2Pool "Local" Api
@@ -1419,6 +1314,7 @@ impl PrivP2poolPoolApi {
pub(super) struct PoolStatistics {
pub hashRate: u64,
pub miners: u32,
+ pub sidechainHeight: u32,
}
impl Default for PoolStatistics {
fn default() -> Self {
@@ -1430,6 +1326,7 @@ impl PoolStatistics {
Self {
hashRate: 0,
miners: 0,
+ sidechainHeight: 0,
}
}
}
diff --git a/src/helper/tests.rs b/src/helper/tests.rs
index 3ce59e8..7d66a5f 100644
--- a/src/helper/tests.rs
+++ b/src/helper/tests.rs
@@ -155,37 +155,6 @@ Uptime = 0h 2m 4s
assert_eq!(public.xmr_month, 648000.0000001296);
}
- #[test]
- fn set_p2pool_synchronized() {
- use crate::helper::PubP2poolApi;
- use std::sync::{Arc, Mutex};
- let public = Arc::new(Mutex::new(PubP2poolApi::new()));
- let output_parse = Arc::new(Mutex::new(String::from(
- r#"payout of 5.000000000001 XMR in block 1111
- NOTICE 2021-12-27 21:42:17.2008 SideChain SYNCHRONIZED
- payout of 5.000000000001 XMR in block 1113"#,
- )));
- let output_pub = Arc::new(Mutex::new(String::new()));
- let elapsed = std::time::Duration::from_secs(60);
- let process = Arc::new(Mutex::new(Process::new(
- ProcessName::P2pool,
- "".to_string(),
- PathBuf::new(),
- )));
-
- // It only gets checked if we're `Syncing`.
- process.lock().unwrap().state = ProcessState::Syncing;
- PubP2poolApi::update_from_output(
- &mut public.lock().unwrap(),
- &output_parse,
- &output_pub,
- elapsed,
- &mut process.lock().unwrap(),
- );
- println!("{:#?}", process);
- assert!(process.lock().unwrap().state == ProcessState::Alive);
- }
-
#[test]
fn p2pool_synchronized_false_positive() {
use crate::helper::PubP2poolApi;
@@ -221,43 +190,6 @@ Uptime = 0h 2m 4s
assert!(process.lock().unwrap().state == ProcessState::Syncing); // still syncing
}
- #[test]
- fn p2pool_synchronized_double_synchronized() {
- use crate::helper::PubP2poolApi;
- use std::sync::{Arc, Mutex};
- let public = Arc::new(Mutex::new(PubP2poolApi::new()));
-
- // The 1st SideChain that is "SYNCHRONIZED" in this output is
- // the sidechain started on height 1, but there is another one
- // which means the real main/mini is probably synced,
- // so this _should_ trigger alive state.
- let output_parse = Arc::new(Mutex::new(String::from(
- r#"2024-11-02 17:39:02.6241 SideChain SYNCHRONIZED
- 2024-11-02 17:39:02.6242 StratumServer SHARE FOUND: mainchain height 3272685, sidechain height 0, diff 100000, client 127.0.0.1:40874, effort 100.001%
- 2024-11-02 17:39:02.6559 StratumServer SHARE FOUND: mainchain height 3272685, sidechain height 0, diff 100000, client 127.0.0.1:40874, effort 200.002%
- 2024-11-02 17:40:06.8562 SideChain SYNCHRONIZED"#,
- )));
- let output_pub = Arc::new(Mutex::new(String::new()));
- let elapsed = std::time::Duration::from_secs(60);
- let process = Arc::new(Mutex::new(Process::new(
- ProcessName::P2pool,
- "".to_string(),
- PathBuf::new(),
- )));
-
- // It only gets checked if we're `Syncing`.
- process.lock().unwrap().state = ProcessState::Syncing;
- PubP2poolApi::update_from_output(
- &mut public.lock().unwrap(),
- &output_parse,
- &output_pub,
- elapsed,
- &mut process.lock().unwrap(),
- );
- println!("{:#?}", process);
- assert!(process.lock().unwrap().state == ProcessState::Alive);
- }
-
#[test]
fn update_pub_p2pool_from_local_network_pool() {
use crate::helper::PubP2poolApi;
@@ -287,6 +219,7 @@ Uptime = 0h 2m 4s
pool_statistics: PoolStatistics {
hashRate: 1_000_000, // 1 MH/s
miners: 1_000,
+ sidechainHeight: 10_000_000,
},
};
// Update Local
@@ -430,7 +363,8 @@ Uptime = 0h 2m 4s
"totalHashes": 487463929193948,
"lastBlockFoundTime": 1670453228,
"lastBlockFound": 2756570,
- "totalBlocksFound": 4
+ "totalBlocksFound": 4,
+ "sidechainHeight": 9000000
}
}"#;
let priv_api = crate::helper::p2pool::PrivP2poolPoolApi::from_str(data).unwrap();
@@ -439,7 +373,8 @@ Uptime = 0h 2m 4s
let data_after_ser = r#"{
"pool_statistics": {
"hashRate": 10225772,
- "miners": 713
+ "miners": 713,
+ "sidechainHeight": 9000000
}
}"#;
assert_eq!(data_after_ser, json)
diff --git a/src/utils/constants.rs b/src/utils/constants.rs
index de84a8d..31066c2 100644
--- a/src/utils/constants.rs
+++ b/src/utils/constants.rs
@@ -308,7 +308,6 @@ pub const STATUS_SUBMENU_YOUR_P2POOL_DOMINANCE: &str =
"The percent of hashrate you account for in P2Pool";
pub const STATUS_SUBMENU_YOUR_MONERO_DOMINANCE: &str =
"The percent of hashrate you account for in the entire Monero network";
-pub const STATUS_SUBMENU_PROGRESS_BAR: &str = "The next time Gupaxx will update P2Pool stats.";
//-- Benchmarks
pub const STATUS_SUBMENU_YOUR_CPU: &str = "The CPU detected by Gupaxx";
pub const STATUS_SUBMENU_YOUR_BENCHMARKS: &str =
diff --git a/src/utils/regex.rs b/src/utils/regex.rs
index e25801b..0d7f167 100644
--- a/src/utils/regex.rs
+++ b/src/utils/regex.rs
@@ -90,8 +90,6 @@ pub struct P2poolRegex {
pub block: Regex,
pub block_int: Regex,
pub block_comma: Regex,
- pub synchronized: Regex,
- pub next_height_1: Regex,
}
impl P2poolRegex {
@@ -105,8 +103,6 @@ impl P2poolRegex {
block: Regex::new("block [0-9]{7}").unwrap(), // Monero blocks will be 7 digits for... the next 10,379 years
block_int: Regex::new("[0-9]{7}").unwrap(),
block_comma: Regex::new("[0-9],[0-9]{3},[0-9]{3}").unwrap(),
- synchronized: Regex::new("SYNCHRONIZED").unwrap(),
- next_height_1: Regex::new("sidechain height 0").unwrap(),
}
}
}
@@ -286,11 +282,6 @@ pub fn contains_zmq_failure(l: &str) -> bool {
});
LINE_SHARE.is_match(l)
}
-/// a way to detect that p2pool is alive
-pub fn contains_newchain_tip(l: &str) -> bool {
- static LINE_SHARE: Lazy<Regex> = Lazy::new(|| Regex::new(r"new chain tip").unwrap());
- LINE_SHARE.is_match(l)
-}
//---------------------------------------------------------------------------------------------------- TEST
#[cfg(test)]
@@ -329,7 +320,6 @@ mod test {
let r = P2poolRegex::new();
let text = "NOTICE 2022-11-11 11:11:11.1111 P2Pool You received a payout of 0.111111111111 XMR in block 1111111";
let text2 = "2022-11-11 11:11:11.1111 | 0.111111111111 XMR | Block 1,111,111";
- let text3 = "NOTICE 2020-12-11 12:35:41.3150 SideChain SYNCHRONIZED";
assert_eq!(
r.payout.find(text).unwrap().as_str(),
"payout of 0.111111111111 XMR"
@@ -345,7 +335,6 @@ mod test {
assert_eq!(r.block.find(text).unwrap().as_str(), "block 1111111");
assert_eq!(r.block_int.find(text).unwrap().as_str(), "1111111");
assert_eq!(r.block_comma.find(text2).unwrap().as_str(), "1,111,111");
- assert_eq!(r.synchronized.find(text3).unwrap().as_str(), "SYNCHRONIZED");
}
#[test]