From 7f8b1b20898f863fd5642e3e10ae8468d23a5113 Mon Sep 17 00:00:00 2001 From: Louis-Marie Baer Date: Mon, 4 Mar 2024 12:03:14 +0100 Subject: [PATCH] feat: show XvB stats to Status Tab --- Cargo.lock | 11 ++ Cargo.toml | 3 +- src/app/mod.rs | 5 + src/app/panels/middle/mod.rs | 2 +- src/app/panels/middle/status/mod.rs | 5 +- src/app/panels/middle/status/processes.rs | 146 ++++++++++++++++++- src/helper/mod.rs | 53 ++++--- src/helper/xvb.rs | 162 ++++++++++++++++++++++ src/inits.rs | 3 + src/utils/constants.rs | 13 ++ 10 files changed, 381 insertions(+), 22 deletions(-) create mode 100644 src/helper/xvb.rs diff --git a/Cargo.lock b/Cargo.lock index 463cb0b..79d0ea0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2327,6 +2327,7 @@ dependencies = [ "arti-hyper", "benri", "bytes", + "derive_more", "dirs", "eframe", "egui", @@ -2348,6 +2349,7 @@ dependencies = [ "regex", "rfd", "serde", + "serde-this-or-that", "serde_json", "static_vcruntime", "strip-ansi-escapes", @@ -4165,6 +4167,15 @@ dependencies = [ "serde_derive", ] +[[package]] +name = "serde-this-or-that" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "634c5a3cb041e56cc2964386151c67d520f845445789da3bd46bfb1c94f5e3bb" +dependencies = [ + "serde", +] + [[package]] name = "serde-value" version = "0.7.0" diff --git a/Cargo.toml b/Cargo.toml index 3c18d52..2634ea4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -75,7 +75,8 @@ walkdir = "2.4.0" zeroize = "1.7.0" strsim = "0.11.0" strip-ansi-escapes = "0.2.0" - +derive_more = {version="0.99.17", default-features=false, features=["display"]} +serde-this-or-that = "0.4.2" # Unix dependencies [target.'cfg(unix)'.dependencies] tar = "0.4.40" diff --git a/src/app/mod.rs b/src/app/mod.rs index 3756069..128f5e2 100644 --- a/src/app/mod.rs +++ b/src/app/mod.rs @@ -18,6 +18,7 @@ use crate::helper::p2pool::ImgP2pool; use crate::helper::p2pool::PubP2poolApi; use crate::helper::xmrig::ImgXmrig; use crate::helper::xmrig::PubXmrigApi; +use crate::helper::xvb::PubXvbApi; use crate::helper::Helper; use crate::helper::Process; use crate::helper::ProcessName; @@ -103,6 +104,7 @@ pub struct App { pub xmrig: Arc>, // [XMRig] process state pub p2pool_api: Arc>, // Public ready-to-print P2Pool API made by the "helper" thread pub xmrig_api: Arc>, // Public ready-to-print XMRig API made by the "helper" thread + pub xvb_api: Arc>, // Public XvB API pub p2pool_img: Arc>, // A one-time snapshot of what data P2Pool started with pub xmrig_img: Arc>, // A one-time snapshot of what data XMRig started with // STDIN Buffer @@ -181,6 +183,7 @@ impl App { )); let p2pool_api = arc_mut!(PubP2poolApi::new()); let xmrig_api = arc_mut!(PubXmrigApi::new()); + let xvb_api = arc_mut!(PubXvbApi::new()); let p2pool_img = arc_mut!(ImgP2pool::new()); let xmrig_img = arc_mut!(ImgXmrig::new()); @@ -243,6 +246,7 @@ impl App { xmrig.clone(), p2pool_api.clone(), xmrig_api.clone(), + xvb_api.clone(), p2pool_img.clone(), xmrig_img.clone(), arc_mut!(GupaxP2poolApi::new()) @@ -250,6 +254,7 @@ impl App { p2pool, xmrig, p2pool_api, + xvb_api, xmrig_api, p2pool_img, xmrig_img, diff --git a/src/app/panels/middle/mod.rs b/src/app/panels/middle/mod.rs index 6a40ea1..f881d11 100644 --- a/src/app/panels/middle/mod.rs +++ b/src/app/panels/middle/mod.rs @@ -143,7 +143,7 @@ path_xmr: {:#?}\n } Tab::Status => { debug!("App | Entering [Status] Tab"); - crate::disk::state::Status::show(&mut self.state.status, &self.pub_sys, &self.p2pool_api, &self.xmrig_api, &self.p2pool_img, &self.xmrig_img, p2pool_is_alive, xmrig_is_alive, self.max_threads, &self.gupax_p2pool_api, &self.benchmarks, self.width, self.height, ctx, ui); + crate::disk::state::Status::show(&mut self.state.status, &self.pub_sys, &self.p2pool_api, &self.xmrig_api, &self.xvb_api,&self.p2pool_img, &self.xmrig_img, p2pool_is_alive, xmrig_is_alive, self.max_threads, &self.gupax_p2pool_api, &self.benchmarks, self.width, self.height, ctx, ui); } Tab::Gupax => { debug!("App | Entering [Gupax] Tab"); diff --git a/src/app/panels/middle/status/mod.rs b/src/app/panels/middle/status/mod.rs index 8c4c02b..e499f2c 100644 --- a/src/app/panels/middle/status/mod.rs +++ b/src/app/panels/middle/status/mod.rs @@ -21,6 +21,7 @@ use crate::{ helper::{ p2pool::{ImgP2pool, PubP2poolApi}, xmrig::{ImgXmrig, PubXmrigApi}, + xvb::PubXvbApi, Sys, }, }; @@ -38,6 +39,7 @@ impl Status { sys: &Arc>, p2pool_api: &Arc>, xmrig_api: &Arc>, + xvb_api: &Arc>, p2pool_img: &Arc>, xmrig_img: &Arc>, p2pool_alive: bool, @@ -59,10 +61,11 @@ impl Status { ui, p2pool_alive, p2pool_api, + p2pool_img, xmrig_alive, xmrig_api, - p2pool_img, xmrig_img, + xvb_api, max_threads, ); //---------------------------------------------------------------------------------------------------- [P2Pool] diff --git a/src/app/panels/middle/status/processes.rs b/src/app/panels/middle/status/processes.rs index fe0da3c..d679da6 100644 --- a/src/app/panels/middle/status/processes.rs +++ b/src/app/panels/middle/status/processes.rs @@ -1,9 +1,10 @@ -use egui::Ui; +use egui::{ScrollArea, Ui}; use std::sync::{Arc, Mutex}; use crate::disk::state::Status; use crate::helper::p2pool::{ImgP2pool, PubP2poolApi}; use crate::helper::xmrig::{ImgXmrig, PubXmrigApi}; +use crate::helper::xvb::{PubXvbApi, XvbRound}; use crate::helper::Sys; use crate::utils::macros::lock; use egui::TextStyle; @@ -21,13 +22,14 @@ impl Status { ui: &mut egui::Ui, p2pool_alive: bool, p2pool_api: &Arc>, + p2pool_img: &Arc>, xmrig_alive: bool, xmrig_api: &Arc>, - p2pool_img: &Arc>, xmrig_img: &Arc>, + xvb_api: &Arc>, max_threads: usize, ) { - let width = (width / 3.0) - (SPACE * 1.666); + let width = (width / 4.0) - (SPACE * 1.7500); let min_height = height - SPACE; let height = height / 25.0; ui.horizontal(|ui| { @@ -54,6 +56,8 @@ impl Status { xmrig_img, max_threads, ); + // [XvB] + xvb(ui, min_height, width, height, xvb_api); }); } } @@ -346,3 +350,139 @@ fn xmrig( }) }); } + +fn xvb(ui: &mut Ui, min_height: f32, width: f32, height: f32, xvb_api: &Arc>) { + // + let api = lock!(xvb_api); + // if this field is empty, it means nothing was received from the API. + let enabled = !api.reward_yearly.is_empty(); + ScrollArea::vertical().show(ui, |ui| { + ui.group(|ui| { + ui.vertical(|ui| { + debug!("Status Tab | Rendering [XvB]"); + ui.set_enabled(enabled); // for now there is no API ping or /health, so we verify if the field reward_yearly is empty or not. + ui.set_min_height(min_height); + ui.add_sized( + [width, height], + Label::new( + RichText::new("[XvB]") + .color(LIGHT_GRAY) + .text_style(TextStyle::Name("MonospaceLarge".into())), + ), + ) + .on_hover_text("XvB API stats") + .on_disabled_hover_text("No data received from XvB API"); + // [Round Type] + ui.add_sized( + [width, height], + Label::new(RichText::new("Round Type").underline().color(BONE)), + ) + .on_hover_text(STATUS_XVB_ROUND_TYPE); + ui.add_sized([width, height], Label::new(api.round_type.to_string())); + // [Time Remaining] + ui.add_sized( + [width, height], + Label::new( + RichText::new("Raffle Round Time Remaining") + .underline() + .color(BONE), + ), + ) + .on_hover_text(STATUS_XVB_TIME_REMAIN); + ui.add_sized( + [width, height], + Label::new(format!("{} minutes left", api.time_remain)), + ); + // Donated Hashrate + ui.add_sized( + [width, height], + Label::new(RichText::new("Donated Hashrate").underline().color(BONE)), + ) + .on_hover_text(STATUS_XVB_DONATED_HR); + ui.add_sized( + [width, height], + Label::new(format!( + "Bonus HR\n{}kH/s\n+\n{}kH/s\ndonated by\n{} donors\n with\n{} miners", + api.bonus_hr, api.donate_hr, api.donate_miners, api.donate_workers + )), + ); + // Players + ui.add_sized( + [width, height], + Label::new(RichText::new("Players").underline().color(BONE)), + ) + .on_hover_text(STATUS_XVB_PLAYERS); + ui.add_sized( + [width, height], + Label::new(format!( + "[Registered: {}]\n[Playing: {}]", + api.players, api.players_round + )), + ); + // Winner + ui.add_sized( + [width, height], + Label::new(RichText::new("Winner").underline().color(BONE)), + ) + .on_hover_text(STATUS_XVB_WINNER); + ui.add_sized([width, height], Label::new(&api.winner)); + // Share effort + ui.add_sized( + [width, height], + Label::new(RichText::new("Share Effort").underline().color(BONE)), + ) + .on_hover_text(STATUS_XVB_SHARE); + ui.add_sized([width, height], Label::new(format!("{}", api.share_effort))); + // Block reward + ui.add_sized( + [width, height], + Label::new(RichText::new("Block Reward").underline().color(BONE)), + ) + .on_hover_text(STATUS_XVB_BLOCK_REWARD); + ui.add_sized([width, height], Label::new(format!("{}", api.block_reward))); + //block height + ui.add_sized( + [width, height], + Label::new(RichText::new("Block Height").underline().color(BONE)), + ) + .on_hover_text(STATUS_XVB_BLOCK_HEIGHT); + ui.add_sized([width, height], Label::new(format!("{}", api.block_height))); + // block hash + ui.add_sized( + [width, height], + Label::new(RichText::new("Block Hash").underline().color(BONE)), + ) + .on_hover_text(STATUS_XVB_BLOCK_HASH); + ui.add_sized([width, height], Label::new(format!("{}", api.block_hash))); + // reward yearly + ui.add_sized( + [width, height], + Label::new(RichText::new("Reward Yearly").underline().color(BONE)), + ) + .on_hover_text(STATUS_XVB_YEARLY); + if api.reward_yearly.is_empty() { + ui.add_sized([width, height], Label::new("No information".to_string())); + } else { + ui.add_sized( + [width, height], + Label::new(format!( + "{}: {} XMR\n{}: {} XMR\n{}: {} XMR\n{}: {} XMR\n{}: {} XMR", + XvbRound::Vip, + api.reward_yearly[0], + XvbRound::Donor, + api.reward_yearly[1], + XvbRound::DonorVip, + api.reward_yearly[2], + XvbRound::DonorWhale, + api.reward_yearly[3], + XvbRound::DonorMega, + api.reward_yearly[4] + )), + ); + } + drop(api); + }); + // by round + }); + }); +} diff --git a/src/helper/mod.rs b/src/helper/mod.rs index 798c063..078fc07 100644 --- a/src/helper/mod.rs +++ b/src/helper/mod.rs @@ -47,8 +47,11 @@ use std::{ thread, time::*, }; + +use self::xvb::PubXvbApi; pub mod p2pool; pub mod xmrig; +pub mod xvb; //---------------------------------------------------------------------------------------------------- Constants // The max amount of bytes of process output we are willing to @@ -71,10 +74,12 @@ pub struct Helper { pub xmrig: Arc>, // XMRig process state pub gui_api_p2pool: Arc>, // P2Pool API state (for GUI thread) pub gui_api_xmrig: Arc>, // XMRig API state (for GUI thread) + pub gui_api_xvb: Arc>, // XMRig API state (for GUI thread) pub img_p2pool: Arc>, // A static "image" of the data P2Pool started with pub img_xmrig: Arc>, // A static "image" of the data XMRig started with pub_api_p2pool: Arc>, // P2Pool API state (for Helper/P2Pool thread) pub_api_xmrig: Arc>, // XMRig API state (for Helper/XMRig thread) + pub_api_xvb: Arc>, // XvB API state (for Helper/XvB thread) pub gupax_p2pool_api: Arc>, // } @@ -273,6 +278,7 @@ impl Helper { xmrig: Arc>, gui_api_p2pool: Arc>, gui_api_xmrig: Arc>, + gui_api_xvb: Arc>, img_p2pool: Arc>, img_xmrig: Arc>, gupax_p2pool_api: Arc>, @@ -283,11 +289,13 @@ impl Helper { uptime: HumanTime::into_human(instant.elapsed()), pub_api_p2pool: arc_mut!(PubP2poolApi::new()), pub_api_xmrig: arc_mut!(PubXmrigApi::new()), + pub_api_xvb: arc_mut!(PubXvbApi::new()), // These are created when initializing [App], since it needs a handle to it as well p2pool, xmrig, gui_api_p2pool, gui_api_xmrig, + gui_api_xvb, img_p2pool, img_xmrig, gupax_p2pool_api, @@ -402,8 +410,10 @@ impl Helper { let pub_sys = Arc::clone(&lock.pub_sys); let gui_api_p2pool = Arc::clone(&lock.gui_api_p2pool); let gui_api_xmrig = Arc::clone(&lock.gui_api_xmrig); + let gui_api_xvb = Arc::clone(&lock.gui_api_xvb); let pub_api_p2pool = Arc::clone(&lock.pub_api_p2pool); let pub_api_xmrig = Arc::clone(&lock.pub_api_xmrig); + let pub_api_xvb = Arc::clone(&lock.pub_api_xvb); drop(lock); let sysinfo_cpu = sysinfo::CpuRefreshKind::everything(); @@ -423,21 +433,25 @@ impl Helper { // 2. Lock... EVERYTHING! let mut lock = lock!(helper); - debug!("Helper | Locking (1/9) ... [helper]"); + debug!("Helper | Locking (1/10) ... [helper]"); let p2pool = lock!(p2pool); - debug!("Helper | Locking (2/9) ... [p2pool]"); + debug!("Helper | Locking (2/10) ... [p2pool]"); let xmrig = lock!(xmrig); - debug!("Helper | Locking (3/9) ... [xmrig]"); + debug!("Helper | Locking (3/10) ... [xmrig]"); let mut lock_pub_sys = lock!(pub_sys); - debug!("Helper | Locking (5/9) ... [pub_sys]"); + debug!("Helper | Locking (4/10) ... [pub_sys]"); let mut gui_api_p2pool = lock!(gui_api_p2pool); - debug!("Helper | Locking (6/9) ... [gui_api_p2pool]"); + debug!("Helper | Locking (5/10) ... [gui_api_p2pool]"); let mut gui_api_xmrig = lock!(gui_api_xmrig); - debug!("Helper | Locking (7/9) ... [gui_api_xmrig]"); + debug!("Helper | Locking (6/10) ... [gui_api_xmrig]"); + let mut gui_api_xvb = lock!(gui_api_xvb); + debug!("Helper | Locking (7/10) ... [gui_api_xvb]"); let mut pub_api_p2pool = lock!(pub_api_p2pool); - debug!("Helper | Locking (8/9) ... [pub_api_p2pool]"); + debug!("Helper | Locking (8/10) ... [pub_api_p2pool]"); let mut pub_api_xmrig = lock!(pub_api_xmrig); - debug!("Helper | Locking (9/9) ... [pub_api_xmrig]"); + debug!("Helper | Locking (9/10) ... [pub_api_xmrig]"); + let mut pub_api_xvb = lock!(pub_api_xvb); + debug!("Helper | Locking (10/10) ... [pub_api_xvb]"); // Calculate Gupax's uptime always. lock.uptime = HumanTime::into_human(lock.instant.elapsed()); // If [P2Pool] is alive... @@ -454,6 +468,9 @@ impl Helper { } else { debug!("Helper | XMRig is dead! Skipping..."); } + // XvB API is considered always available + debug!("Helper | XvB is alive! Running [combine_gui_pub_api()]"); + PubXvbApi::combine_gui_pub_api(&mut gui_api_xvb, &mut pub_api_xvb); // 2. Selectively refresh [sysinfo] for only what we need (better performance). sysinfo.refresh_cpu_specifics(sysinfo_cpu); @@ -473,21 +490,25 @@ impl Helper { // 3. Drop... (almost) EVERYTHING... IN REVERSE! drop(lock_pub_sys); - debug!("Helper | Unlocking (1/9) ... [pub_sys]"); + debug!("Helper | Unlocking (1/10) ... [pub_sys]"); drop(xmrig); - debug!("Helper | Unlocking (2/9) ... [xmrig]"); + debug!("Helper | Unlocking (2/10) ... [xmrig]"); drop(p2pool); - debug!("Helper | Unlocking (3/9) ... [p2pool]"); + debug!("Helper | Unlocking (3/10) ... [p2pool]"); + drop(pub_api_xvb); + debug!("Helper | Unlocking (4/10) ... [pub_api_xvb]"); drop(pub_api_xmrig); - debug!("Helper | Unlocking (4/9) ... [pub_api_xmrig]"); + debug!("Helper | Unlocking (5/10) ... [pub_api_xmrig]"); drop(pub_api_p2pool); - debug!("Helper | Unlocking (5/9) ... [pub_api_p2pool]"); + debug!("Helper | Unlocking (6/10) ... [pub_api_p2pool]"); + drop(gui_api_xvb); + debug!("Helper | Unlocking (7/10) ... [gui_api_xvb]"); drop(gui_api_xmrig); - debug!("Helper | Unlocking (6/9) ... [gui_api_xmrig]"); + debug!("Helper | Unlocking (8/10) ... [gui_api_xmrig]"); drop(gui_api_p2pool); - debug!("Helper | Unlocking (7/9) ... [gui_api_p2pool]"); + debug!("Helper | Unlocking (9/10) ... [gui_api_p2pool]"); drop(lock); - debug!("Helper | Unlocking (8/9) ... [helper]"); + debug!("Helper | Unlocking (10/10) ... [helper]"); // 4. Calculate if we should sleep or not. // If we should sleep, how long? diff --git a/src/helper/xvb.rs b/src/helper/xvb.rs new file mode 100644 index 0000000..9c0c956 --- /dev/null +++ b/src/helper/xvb.rs @@ -0,0 +1,162 @@ +use derive_more::Display; +use hyper::client::HttpConnector; +use hyper_tls::HttpsConnector; +use log::{debug, info, warn}; +use serde::Deserialize; +use std::{ + sync::{Arc, Mutex}, + thread, + time::Instant, +}; + +use crate::utils::{constants::XVB_URL_PUBLIC_API, macros::lock}; + +use super::Helper; + +impl Helper { + pub fn start_xvb(helper: &Arc>) { + let https = HttpsConnector::new(); + let client = hyper::Client::builder().build(https); + let gui_api = Arc::clone(&lock!(helper).gui_api_xvb); + let pub_api = Arc::clone(&lock!(helper).pub_api_xvb); + thread::spawn(move || { + Self::spawn_xvb_watchdog(client, gui_api, pub_api); + }); + } + #[tokio::main] + async fn spawn_xvb_watchdog( + client: hyper::Client>, + gui_api: Arc>, + pub_api: Arc>, + ) { + info!("XvB started"); + // Reset stats before loop + *lock!(pub_api) = PubXvbApi::new(); + *lock!(gui_api) = PubXvbApi::new(); + + info!("XvB | Entering watchdog mode... woof!"); + loop { + // Set timer + let now = Instant::now(); + debug!("XvB Watchdog | ----------- Start of loop -----------"); + // Send an HTTP API request + debug!("XvB Watchdog | Attempting HTTP API request..."); + match PubXvbApi::request_xvb_public_api(client.clone(), XVB_URL_PUBLIC_API).await { + Ok(new_data) => { + debug!("XvB Watchdog | HTTP API request OK"); + let mut data = lock!(&pub_api); + *data = new_data; + } + Err(err) => { + warn!( + "XvB Watchdog | Could not send HTTP API request to: {}\n:{}", + XVB_URL_PUBLIC_API, err + ); + } + } + // XvB Status do not need to be refreshed like others because combine_with_gui do not refresh if no data is changed. + let elapsed = now.elapsed().as_secs(); + if elapsed < 59 { + let sleep = (60 - elapsed) as u64; + debug!("XvB Watchdog | END OF LOOP - Sleeping for [{}]s...", sleep); + std::thread::sleep(std::time::Duration::from_secs(sleep)) + } else { + debug!("XMRig Watchdog | END OF LOOP - Not sleeping!"); + } + } + } +} +//---------------------------------------------------------------------------------------------------- Public XvB API +use serde_this_or_that::as_u64; +#[derive(Debug, Clone, Default, Deserialize)] +pub struct PubXvbApi { + pub time_remain: u32, // remaining time of round in minutes + pub bonus_hr: f64, + pub donate_hr: f64, // donated hr from all donors + pub donate_miners: u32, // numbers of donors + pub donate_workers: u32, // numbers of workers from donors + pub players: u32, + pub players_round: u32, + pub winner: String, + pub share_effort: String, + pub block_reward: String, + pub round_type: XvbRound, + #[serde(deserialize_with = "as_u64")] + pub block_height: u64, + pub block_hash: String, + #[serde(deserialize_with = "as_u64")] + pub roll_winner: u64, + #[serde(deserialize_with = "as_u64")] + pub roll_round: u64, + pub reward_yearly: Vec, +} + +#[derive(Debug, Clone, Default, Display, Deserialize)] +pub enum XvbRound { + #[default] + #[serde(alias = "vip")] + Vip, + #[serde(alias = "donor")] + Donor, + #[serde(alias = "donor_vip")] + DonorVip, + #[serde(alias = "donor_whale")] + DonorWhale, + #[serde(alias = "donor_mega")] + DonorMega, +} + +impl PubXvbApi { + pub fn new() -> Self { + Self::default() + } + pub(super) fn combine_gui_pub_api(gui_api: &mut Self, pub_api: &mut Self) { + // update only if there is data, if no new data, pub_api fields are on default value. + if !pub_api.reward_yearly.is_empty() { + *gui_api = std::mem::take(pub_api) + } + } + #[inline] + // Send an HTTP request to XvB's API, serialize it into [Self] and return it + async fn request_xvb_public_api( + client: hyper::Client>, + api_uri: &str, + ) -> std::result::Result { + let request = hyper::Request::builder() + .method("GET") + .uri(api_uri) + .body(hyper::Body::empty())?; + let response = + tokio::time::timeout(std::time::Duration::from_secs(8), client.request(request)) + .await?; + // let response = client.request(request).await; + + let body = hyper::body::to_bytes(response?.body_mut()).await?; + Ok(serde_json::from_slice::(&body)?) + } +} +//---------------------------------------------------------------------------------------------------- TEST +#[cfg(test)] +mod test { + use std::thread; + + use super::PubXvbApi; + use crate::utils::constants::XVB_URL_PUBLIC_API; + use hyper::Client; + use hyper_tls::HttpsConnector; + + #[test] + fn public_api_deserialize() { + let https = HttpsConnector::new(); + let client = hyper::Client::builder().build(https); + let new_data = thread::spawn(move || corr(client)).join().unwrap(); + assert!(!new_data.reward_yearly.is_empty()); + dbg!(new_data); + } + #[tokio::main] + async fn corr(client: Client>) -> PubXvbApi { + PubXvbApi::request_xvb_public_api(client, XVB_URL_PUBLIC_API) + .await + .unwrap() + } +} diff --git a/src/inits.rs b/src/inits.rs index 0548b6b..45c020d 100644 --- a/src/inits.rs +++ b/src/inits.rs @@ -206,4 +206,7 @@ pub fn init_auto(app: &mut App) { } else { info!("Skipping auto-xmrig..."); } + // [XvB] + // For now, the XvB client of the API for receiving public informations is always enabled. + Helper::start_xvb(&app.helper); } diff --git a/src/utils/constants.rs b/src/utils/constants.rs index c987bce..d70cbfc 100644 --- a/src/utils/constants.rs +++ b/src/utils/constants.rs @@ -181,6 +181,18 @@ pub const STATUS_XMRIG_DIFFICULTY: &str = "The current difficulty of the job XMR pub const STATUS_XMRIG_SHARES: &str = "The amount of accepted and rejected shares"; pub const STATUS_XMRIG_POOL: &str = "The pool XMRig is currently mining to"; pub const STATUS_XMRIG_THREADS: &str = "The amount of threads XMRig is currently using"; +//-- +pub const STATUS_XVB_TIME_REMAIN: &str = "Minutes left before end of round"; +pub const STATUS_XVB_ROUND_TYPE: &str = "The current round type"; +pub const STATUS_XVB_PLAYERS: &str = + "Numbers of registred players and currently playing in the round"; +pub const STATUS_XVB_DONATED_HR: &str = "Hashrate donated to the raffle"; +pub const STATUS_XVB_WINNER: &str = "Current Raffle Winner"; +pub const STATUS_XVB_SHARE: &str = "Share effort"; +pub const STATUS_XVB_BLOCK_REWARD: &str = "Block reward"; +pub const STATUS_XVB_BLOCK_HEIGHT: &str = "height of the current block"; +pub const STATUS_XVB_BLOCK_HASH: &str = "hash of the block that is being worked on"; +pub const STATUS_XVB_YEARLY: &str = "Average yearly reward per round type"; // Status Submenus pub const STATUS_SUBMENU_PROCESSES: &str = "View the status of process related data for [Gupax|P2Pool|XMRig]"; @@ -390,6 +402,7 @@ pub const XMRIG_PATH_EMPTY: &str = "XMRig PATH is empty! To fix: goto the [G // XvB pub const XVB_HELP: &str = "You need to register an account by clicking on the link above to get your token with the same p2pool XMR address you use for payment."; pub const XVB_URL: &str = "https://xmrvsbeast.com"; +pub const XVB_URL_PUBLIC_API: &str = "https://xmrvsbeast.com/p2pool/stats"; // CLI argument messages pub const ARG_HELP: &str = r#"USAGE: ./gupax [--flag]