Ecosystem/gupaxx
1
0
Fork 0
mirror of https://github.com/Cyrix126/gupaxx.git synced 2024-11-16 15:27:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

connect functions with [State/state.rs]

Browse source
This commit is contained in:
hinto-janaiyo 2022-10-15 15:15:27 -04:00
parent dafb8fc18e
commit ed7ddeeda1
No known key found for this signature in database
GPG key ID: D7483F6CA27D1B1D
7 changed files with 273 additions and 361 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Cargo.lock generated
View file

@ -1085,6 +1085,7 @@ dependencies = [
"monero",
"num-format",
"num_cpus",
"rand",
"regex",
"reqwest",
"serde",

4
src/README.md
View file

@ -12,8 +12,8 @@
| `main.rs` | Struct/enum/impl for `App/Tab/State`, init functions, main function
| `node.rs` | Struct/impl for Community Nodes
| `p2pool.rs` | Struct/impl for `P2Pool` tab
| `state.rs` | Struct/impl for `gupax.toml`, the disk state
| `status.rs` | Struct/impl for `Status` tab
| `toml.rs` | Struct/impl for `gupax.toml`, the disk state
| `xmrig.rs` | Struct/impl for `XMRig` tab
## Bootstrap
@ -42,7 +42,7 @@ This is how Gupax works internally when starting up, divided into 3 sections.
- Kill processes, kill connections, exit
## State
Internal state is saved in the "OS data folder" as `gupax.toml`, using the [TOML](https://github.com/toml-lang/toml) format. If the version can't be parsed (not in the `vX.X.X` or `vX.X` format), the auto-updater will be skipped. [If not found, a default `gupax.toml` file will be created with `Toml::default`.](https://github.com/hinto-janaiyo/gupax/blob/main/src/toml.rs) Gupax will `panic!` if `gupax.toml` has IO or parsing issues.
Internal state is saved in the "OS data folder" as `gupax.toml`, using the [TOML](https://github.com/toml-lang/toml) format. If the version can't be parsed (not in the `vX.X.X` or `vX.X` format), the auto-updater will be skipped. [If not found, a default `gupax.toml` file will be created with `State::default`.](https://github.com/hinto-janaiyo/gupax/blob/main/src/state.rs) Gupax will `panic!` if `gupax.toml` has IO or parsing issues.
| OS | Data Folder | Example |
|----------|----------------------------------------- |-----------------------------------------------------------|

267
src/main.rs
View file

@ -16,135 +16,98 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
use eframe::{egui,NativeOptions};
use egui::{Vec2,Pos2};
use std::process::exit;
use std::thread;
use egui::color::Color32;
use egui::Stroke;
use egui::FontId;
use egui::FontFamily::Proportional;
use egui::TextStyle::{Body,Button,Heading,Monospace,Name,Small};
use egui::RichText;
use egui::Label;
use regex::Regex;
use egui_extras::RetainedImage;
use log::*;
use env_logger::Builder;
use env_logger::WriteStyle;
use std::io::Write;
use std::time::Instant;
use std::sync::{Arc,Mutex};
//---------------------------------------------------------------------------------------------------- Imports
// egui/eframe
use egui::TextStyle::*;
use egui::color::Color32;
use egui::FontFamily::Proportional;
use egui::{FontId,Label,RichText,Stroke,Vec2,Pos2};
use egui_extras::RetainedImage;
use eframe::{egui,NativeOptions};
// Logging
use log::*;
use env_logger::{Builder,WriteStyle};
// std
use std::io::Write;
use std::process::exit;
use std::sync::{Arc,Mutex};
use std::thread;
use std::time::Instant;
// Modules
mod constants;
mod node;
mod toml;
mod state;
mod about;
mod status;
mod gupax;
mod p2pool;
mod xmrig;
use {constants::*,node::*,crate::toml::*,about::*,status::*,gupax::*,p2pool::*,xmrig::*};
use {constants::*,node::*,state::*,about::*,status::*,gupax::*,p2pool::*,xmrig::*};
// The state of the outer [App].
// See the [State] struct for the
// actual inner state of the settings.
//---------------------------------------------------------------------------------------------------- Struct + Impl
// The state of the outer main [App].
// See the [State] struct in [state.rs] for the
// actual inner state of the tab settings.
pub struct App {
// Misc state
tab: Tab, // What tab are we on?
quit: bool, // Did user click quit button?
quit_confirm: bool, // Did user confirm to quit?
ping: bool, // Did user click the ping button?
ping_prog: Arc<Mutex<bool>>, // Are we in the progress of pinging?
node: Arc<Mutex<NodeStruct>>, // Data on community nodes
// State:
// og = Old state to compare against
// state = Working state (current settings)
// Instead of comparing [og == state] every frame,
// the [diff] bool will be the signal for [Reset/Save].
og: State,
state: State,
diff: bool,
// Static stuff
now: Instant,
resolution: Vec2,
os: &'static str,
version: String,
name_version: String,
tab: Tab,
changed: bool,
os: &'static str,
current_threads: u16,
max_threads: u16,
resolution: Vec2,
banner: RetainedImage,
// TEMPORARY FIXME
p2pool: bool,
xmrig: bool,
state: State,
og: State,
allowed_to_close: bool,
show_confirmation_dialog: bool,
now: Instant,
ping: bool,
ping_prog: Arc<Mutex<bool>>,
node: Arc<Mutex<NodeStruct>>,
}
impl App {
fn new(cc: &eframe::CreationContext<'_>) -> Self {
let version = String::from("v0.0.1");
let name_version = String::from("Gupax v0.0.1");
let tab = Tab::default();
let max_threads = num_cpus::get().try_into().unwrap();
let current_threads: u16;
let changed = false;
let os = OS;
if max_threads != 1 {
current_threads = max_threads / 2
} else {
current_threads = 1
}
let resolution = cc.integration_info.window_info.size;
init_text_styles(&cc.egui_ctx, resolution[0] as f32);
let banner = match RetainedImage::from_image_bytes("banner.png", BYTES_BANNER) {
Ok(banner) => { info!("Banner loading ... OK"); banner },
Err(err) => { error!("{}", err); panic!("{}", err); },
};
let mut state = State::new();
let mut og = State::new();
info!("Frame resolution ... {:#?}", resolution);
Self {
version,
name_version,
tab,
current_threads,
max_threads,
changed,
resolution,
os,
banner,
p2pool: false,
xmrig: false,
state,
og,
allowed_to_close: false,
show_confirmation_dialog: false,
now: Instant::now(),
node: Arc::new(Mutex::new(NodeStruct::default())),
tab: Tab::default(),
quit: false,
quit_confirm: false,
ping: false,
ping_prog: Arc::new(Mutex::new(false)),
node: Arc::new(Mutex::new(NodeStruct::default())),
og: State::default(),
state: State::default(),
diff: false,
now: Instant::now(),
resolution: cc.integration_info.window_info.size,
os: OS,
version: "v0.0.1".to_string(),
name_version: "Gupax v0.0.1".to_string(),
banner: RetainedImage::from_image_bytes("banner.png", BYTES_BANNER).expect("oops"),
// TEMPORARY FIXME
p2pool: false,
xmrig: false,
}
}
}
// Inner state holding all
// mutable tab structs.
#[derive(Clone, Debug, Eq, PartialEq)]
struct State {
gupax: Gupax,
p2pool: P2pool,
xmrig: Xmrig,
}
impl State {
fn new() -> Self {
Self {
gupax: Gupax::new(),
p2pool: P2pool::new(),
xmrig: Xmrig::new(),
}
}
fn save(new: State) -> Self {
Self {
gupax: new.gupax,
p2pool: new.p2pool,
xmrig: new.xmrig,
}
}
}
//---------------------------------------------------------------------------------------------------- Enum + Impl
// The tabs inside [App].
#[derive(Clone, Copy, Debug, PartialEq)]
enum Tab {
@ -154,12 +117,14 @@ enum Tab {
P2pool,
Xmrig,
}
impl Default for Tab {
fn default() -> Self {
Self::About
}
}
//---------------------------------------------------------------------------------------------------- Init functions
fn init_text_styles(ctx: &egui::Context, width: f32) {
let scale = width / 26.666;
let mut style = (*ctx.style()).clone();
@ -230,23 +195,7 @@ fn init_options() -> NativeOptions {
options
}
fn main() {
init_logger();
let toml = match Toml::get() {
Ok(toml) => toml,
Err(err) => {
error!("{}", err);
let error_msg = err.to_string();
let options = Panic::options();
eframe::run_native("Gupax", options, Box::new(|cc| Box::new(Panic::new(cc, error_msg))),);
exit(1);
},
};
let options = init_options();
eframe::run_native("Gupax", options, Box::new(|cc| Box::new(App::new(cc))),);
}
// [App] frame for Panic situations.
//---------------------------------------------------------------------------------------------------- [App] frame for [Panic] situations
struct Panic { error_msg: String, }
impl Panic {
fn options() -> NativeOptions {
@ -288,15 +237,35 @@ impl eframe::App for Panic {
}
}
//---------------------------------------------------------------------------------------------------- Main [App] frame
fn main() {
init_logger();
// let toml = match State::get() {
// Ok(toml) => toml,
// Err(err) => {
// error!("{}", err);
// let error_msg = err.to_string();
// let options = Panic::options();
// eframe::run_native("Gupax", options, Box::new(|cc| Box::new(Panic::new(cc, error_msg))),);
// exit(1);
// },
// };
let state = State::default();
let options = init_options();
eframe::run_native("Gupax", options, Box::new(|cc| Box::new(App::new(cc))),);
}
impl eframe::App for App {
fn on_close_event(&mut self) -> bool {
// self.show_confirmation_dialog = true;
self.ping = true;
self.allowed_to_close
self.quit = true;
self.quit_confirm
}
fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
init_text_styles(ctx, 1280.0);
// Close confirmation.
if self.show_confirmation_dialog {
if self.quit {
egui::CentralPanel::default().show(ctx, |ui| {
let width = ui.available_width();
let width = width - 10.0;
@ -306,10 +275,10 @@ impl eframe::App for App {
ui.group(|ui| {
if ui.add_sized([width, height/10.0], egui::Button::new("Yes")).clicked() {
info!("Quit confirmation = yes ... goodbye!");
exit(0);
self.quit_confirm = true;
frame.close();
} else if ui.add_sized([width, height/10.0], egui::Button::new("No")).clicked() {
info!("Quit confirmation = no ... returning!");
self.show_confirmation_dialog = false;
self.quit = false;
}
});
});
@ -329,25 +298,25 @@ impl eframe::App for App {
});
}
if *self.ping_prog.lock().unwrap() {
egui::CentralPanel::default().show(ctx, |ui| {
let width = ui.available_width();
let width = width - 10.0;
let height = ui.available_height();
init_text_styles(ctx, width);
ui.add_sized([width, height/2.0], Label::new(format!("In progress: {}", *self.ping_prog.lock().unwrap())));
ui.group(|ui| {
if ui.add_sized([width, height/10.0], egui::Button::new("Yes")).clicked() {
info!("Quit confirmation = yes ... goodbye!");
exit(0);
} else if ui.add_sized([width, height/10.0], egui::Button::new("No")).clicked() {
info!("Quit confirmation = no ... returning!");
self.show_confirmation_dialog = false;
}
});
});
return
}
// if *self.ping_prog.lock().unwrap() {
// egui::CentralPanel::default().show(ctx, |ui| {
// let width = ui.available_width();
// let width = width - 10.0;
// let height = ui.available_height();
// init_text_styles(ctx, width);
// ui.add_sized([width, height/2.0], Label::new(format!("In progress: {}", *self.ping_prog.lock().unwrap())));
// ui.group(|ui| {
// if ui.add_sized([width, height/10.0], egui::Button::new("Yes")).clicked() {
// info!("Quit confirmation = yes ... goodbye!");
// exit(0);
// } else if ui.add_sized([width, height/10.0], egui::Button::new("No")).clicked() {
// info!("Quit confirmation = no ... returning!");
// self.show_confirmation_dialog = false;
// }
// });
// });
// return
// }
// Top: Tabs
egui::CentralPanel::default().show(ctx, |ui| {
@ -390,6 +359,9 @@ impl eframe::App for App {
ui.add_sized([width, height], Label::new(self.os));
ui.separator();
ui.add_sized([width/1.5, height], Label::new("P2Pool"));
// TODO
// self.p2pool + self.xmrig
// This is for process online/offline status
if self.p2pool == true {
ui.add_sized([width/4.0, height], Label::new(RichText::new("⏺").color(Color32::from_rgb(100, 230, 100))));
} else {
@ -469,7 +441,8 @@ impl eframe::App for App {
Status::show(self, ctx, ui);
}
Tab::Gupax => {
Gupax::show(&mut self.state.gupax, ctx, ui);
// Gupax::show(self.state.gupax, ctx, ui);
exit(0);
}
Tab::P2pool => {
P2pool::show(&mut self.state.p2pool, ctx, ui);

12
src/node.rs
View file

@ -55,12 +55,18 @@ pub struct Data {
pub ip: String,
}
#[derive(Copy,Clone,Debug,Deserialize,Serialize)]
#[derive(Copy,Clone,Eq,PartialEq,Debug,Deserialize,Serialize)]
pub enum NodeEnum {
C3pool, Cake, CakeEu, CakeUk, CakeUs, Monerujo, Rino,
Selsta, Seth, SupportXmr, SupportXmrIr, XmrVsBeast,
}
impl std::fmt::Display for NodeEnum {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "{:#?}", self)
}
}
#[derive(Debug)]
pub struct PingResult {
pub node: NodeStruct,
@ -146,7 +152,7 @@ impl NodeStruct {
};
let mut timeout = false;
let mut mid = Duration::new(0, 0);
let max = rng::thread_rng().gen_range(1..5);
let max = rand::thread_rng().gen_range(1..5);
for i in 1..=max {
let client = reqwest::blocking::ClientBuilder::new();
let client = reqwest::blocking::ClientBuilder::timeout(client, timeout_sec);
@ -156,7 +162,7 @@ impl NodeStruct {
match client.post(http).json(&get_info).send() {
Ok(r) => mid += now.elapsed(),
Err(err) => {
error!("Timeout on [{}: {}] (over 5 seconds)", id, ip);
error!("Timeout on [{:#?}: {}] (over 5 seconds)", id, ip);
mid += timeout_sec;
timeout = true;
},

112
src/p2pool.rs
View file

@ -16,77 +16,25 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
use crate::App;
use monero::util::address::Address;
use std::str::FromStr;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use crate::constants::*;
use crate::state::P2pool;
use crate::node::NodeEnum;
use crate::node::{RINO,SETH,SELSTA};
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum Node {
Rino,
Seth,
Selsta,
}
impl Node {
pub fn ip(self) -> String {
match self {
Node::Rino => String::from("node.community.rino.io:18081"),
Node::Seth => String::from("node.sethforprivacy.com:18089"),
Node::Selsta => String::from("selsta1.featherwallet.net:18081"),
}
}
pub fn name(self) -> String {
match self {
Node::Rino => String::from("Rino"),
Node::Seth => String::from("Seth"),
Node::Selsta => String::from("Selsta"),
}
}
}
// Main data structure for the P2Pool tab
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct P2pool {
pub version: String,
pub sha256: String,
pub manual: bool,
pub mini: bool,
pub rpc: String,
pub zmq: String,
// pub simple: bool,
// pub mini: bool,
// pub out_peers: u8,
// pub in_peers: u8,
// pub log_level: u8,
// pub node: crate::node::NodeEnum,
// pub monerod: String,
// pub rpc: u16,
// pub zmq: u16,
pub out_peers: u16,
pub in_peers: u16,
pub log: u8,
pub monerod: String,
// pub monerod: std::net::SocketAddr,
pub community: Node,
pub address: String,
// pub address: monero::util::address::Address,
}
// pub address: String,
impl P2pool {
pub fn new() -> Self {
Self {
version: String::from("v2.4"),
sha256: String::from("asdf"),
manual: false,
mini: true,
rpc: String::from(""),
zmq: String::from(""),
out_peers: 10,
in_peers: 10,
log: 3,
// monerod: SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 18081),
monerod: String::from(""),
address: String::from(""),
community: Node::Rino,
// address: Address::from_str("44hintoFpuo3ugKfcqJvh5BmrsTRpnTasJmetKC4VXCt6QDtbHVuixdTtsm6Ptp7Y8haXnJ6j8Gj2dra8CKy5ewz7Vi9CYW").unwrap(),
}
}
pub fn show(state: &mut P2pool, ctx: &egui::Context, ui: &mut egui::Ui) {
pub fn show(&mut self, ctx: &egui::Context, ui: &mut egui::Ui) {
let height = ui.available_height() / 10.0;
let mut width = ui.available_width() - 50.0;
ui.group(|ui| {
@ -100,61 +48,61 @@ impl P2pool {
ui.horizontal(|ui| {
ui.group(|ui| { ui.vertical(|ui| {
ui.group(|ui| { ui.horizontal(|ui| {
if ui.add_sized([width/4.0, height/5.0], egui::SelectableLabel::new(state.mini == false, "P2Pool Main")).on_hover_text(P2POOL_MAIN).clicked() { state.mini = false; };
if ui.add_sized([width/4.0, height/5.0], egui::SelectableLabel::new(state.mini == true, "P2Pool Mini")).on_hover_text(P2POOL_MINI).clicked() { state.mini = true; };
if ui.add_sized([width/4.0, height/5.0], egui::SelectableLabel::new(self.mini == false, "P2Pool Main")).on_hover_text(P2POOL_MAIN).clicked() { self.mini = false; };
if ui.add_sized([width/4.0, height/5.0], egui::SelectableLabel::new(self.mini == true, "P2Pool Mini")).on_hover_text(P2POOL_MINI).clicked() { self.mini = true; };
})});
let width = (width/4.0);
let width = width/4.0;
style.spacing.slider_width = width*1.25;
ctx.set_style(style);
ui.horizontal(|ui| {
ui.add_sized([width/8.0, height/5.0], egui::Label::new("Out peers [10-450]:"));
ui.add_sized([width, height/5.0], egui::Slider::new(&mut state.out_peers, 10..=450)).on_hover_text(P2POOL_OUT);
ui.add_sized([width, height/5.0], egui::Slider::new(&mut self.out_peers, 10..=450)).on_hover_text(P2POOL_OUT);
});
ui.horizontal(|ui| {
ui.add_sized([width/8.0, height/5.0], egui::Label::new(" In peers [10-450]:"));
ui.add_sized([width, height/5.0], egui::Slider::new(&mut state.in_peers, 10..=450)).on_hover_text(P2POOL_IN);
ui.add_sized([width, height/5.0], egui::Slider::new(&mut self.in_peers, 10..=450)).on_hover_text(P2POOL_IN);
});
ui.horizontal(|ui| {
ui.add_sized([width/8.0, height/5.0], egui::Label::new(" Log level [0-6]:"));
ui.add_sized([width, height/5.0], egui::Slider::new(&mut state.log, 0..=6)).on_hover_text(P2POOL_LOG);
ui.add_sized([width, height/5.0], egui::Slider::new(&mut self.log_level, 0..=6)).on_hover_text(P2POOL_LOG);
});
})});
ui.group(|ui| { ui.vertical(|ui| {
ui.group(|ui| { ui.horizontal(|ui| {
if ui.add_sized([width/4.0, height/5.0], egui::SelectableLabel::new(state.manual == false, "Community Monero Node")).on_hover_text(P2POOL_COMMUNITY).clicked() { state.manual = false; };
if ui.add_sized([width/4.0, height/5.0], egui::SelectableLabel::new(state.manual == true, "Manual Monero Node")).on_hover_text(P2POOL_MANUAL).clicked() { state.manual = true; };
if ui.add_sized([width/4.0, height/5.0], egui::SelectableLabel::new(self.simple == false, "Community Monero Node")).on_hover_text(P2POOL_COMMUNITY).clicked() { self.simple = false; };
if ui.add_sized([width/4.0, height/5.0], egui::SelectableLabel::new(self.simple == true, "Manual Monero Node")).on_hover_text(P2POOL_MANUAL).clicked() { self.simple = true; };
})});
ui.add_space(8.0);
ui.horizontal(|ui| {
// ui.add_sized([width/8.0, height/5.0],
egui::ComboBox::from_label(Node::name(state.community.clone())).selected_text(Node::ip(state.community.clone())).show_ui(ui, |ui| {
ui.selectable_value(&mut state.community, Node::Rino, Node::ip(Node::Rino));
ui.selectable_value(&mut state.community, Node::Seth, Node::ip(Node::Seth));
ui.selectable_value(&mut state.community, Node::Selsta, Node::ip(Node::Selsta));
egui::ComboBox::from_label(self.node.to_string()).selected_text(RINO).show_ui(ui, |ui| {
ui.selectable_value(&mut self.node, NodeEnum::Rino, RINO);
ui.selectable_value(&mut self.node, NodeEnum::Seth, SETH);
ui.selectable_value(&mut self.node, NodeEnum::Selsta, SELSTA);
});
// );
});
if state.manual == false { ui.set_enabled(false); }
if self.simple == false { ui.set_enabled(false); }
let width = (width/4.0);
ui.horizontal(|ui| {
ui.add_sized([width/8.0, height/7.8], egui::Label::new("Monero Node IP:"));
ui.spacing_mut().text_edit_width = ui.available_width() - 35.0;
ui.text_edit_singleline(&mut state.monerod);
ui.text_edit_singleline(&mut self.monerod);
});
ui.horizontal(|ui| {
ui.add_sized([width/8.0, height/7.8], egui::Label::new("Monero Node RPC Port:"));
ui.spacing_mut().text_edit_width = ui.available_width() - 35.0;
ui.text_edit_singleline(&mut state.rpc);
ui.text_edit_singleline(&mut self.rpc.to_string());
});
ui.horizontal(|ui| {
ui.add_sized([width/8.0, height/7.8], egui::Label::new("Monero Node ZMQ Port:"));
ui.spacing_mut().text_edit_width = ui.available_width() - 35.0;
ui.text_edit_singleline(&mut state.zmq);
ui.text_edit_singleline(&mut self.zmq.to_string());
});
})});
@ -164,7 +112,7 @@ impl P2pool {
ui.horizontal(|ui| {
ui.spacing_mut().text_edit_width = ui.available_width();
ui.label("Address:");
ui.text_edit_singleline(&mut state.address);
ui.text_edit_singleline(&mut self.address);
})});
}
}

167
src/toml.rs → src/state.rs
View file

@ -18,7 +18,7 @@
// This handles reading/parsing the state file: [gupax.toml]
// The TOML format is used. This struct hierarchy directly
// translates into the TOML parser:
// Toml/
// State/
// ├─ Gupax/
// │ ├─ ...
// ├─ P2pool/
@ -31,13 +31,12 @@
use std::{fs,env};
use std::fmt::Display;
use std::path::{Path,PathBuf};
use std::result::Result;
use serde_derive::{Serialize,Deserialize};
use log::*;
//---------------------------------------------------------------------------------------------------- Impl
// Since [State] is already used in [main.rs] to represent
// working state, [Toml] is used to represent disk state.
impl Toml {
impl State {
pub fn default() -> Self {
use crate::constants::{P2POOL_VERSION,XMRIG_VERSION};
Self {
@ -64,7 +63,9 @@ impl Toml {
tls: false,
nicehash: false,
keepalive: false,
threads: 1,
hugepages_jit: true,
current_threads: 1,
max_threads: 1,
priority: 2,
pool: "localhost:3333".to_string(),
address: "".to_string(),
@ -76,7 +77,7 @@ impl Toml {
}
}
pub fn get() -> Result<Toml, TomlError> {
pub fn get_path() -> Result<PathBuf, TomlError> {
// Get OS data folder
// Linux | $XDG_DATA_HOME or $HOME/.local/share | /home/alice/.local/state
// macOS | $HOME/Library/Application Support | /Users/Alice/Library/Application Support
@ -89,36 +90,67 @@ impl Toml {
},
None => { error!("Couldn't get OS PATH for data"); return Err(TomlError::Path(PATH_ERROR.to_string())) },
};
// Create directory
fs::create_dir_all(&path)?;
// Attempt to read file, create default if not found
path.push(FILENAME);
let file = match fs::read_to_string(&path) {
Ok(file) => file,
info!("TOML path ... {}", path.display());
Ok(path)
}
// Attempts to read [gupax.toml] or
// attempts to create if not found.
pub fn read_or_create(path: PathBuf) -> Result<String, TomlError> {
// Attempt to read file, create default if not found
match fs::read_to_string(&path) {
Ok(string) => {
info!("TOML read ... OK");
Ok(string)
},
Err(err) => {
error!("TOML not found, attempting to create default");
let default = match toml::ser::to_string(&Toml::default()) {
let default = match toml::ser::to_string(&State::default()) {
Ok(o) => { info!("TOML serialization ... OK"); o },
Err(e) => { error!("Couldn't serialize default TOML file: {}", e); return Err(TomlError::Serialize(e)) },
};
fs::write(&path, default)?;
fs::write(&path, &default)?;
info!("TOML write ... OK");
fs::read_to_string(&path)?
Ok(fs::read_to_string(default)?)
},
};
info!("TOML path ... {}", path.display());
info!("TOML read ... OK");
}
}
// Attempt to parse, return Result
match toml::from_str(&file) {
// Attempt to parse from String
pub fn parse(string: String) -> Result<State, TomlError> {
match toml::de::from_str(&string) {
Ok(toml) => {
info!("TOML parse ... OK");
eprint!("{}", file);
info!("TOML parse ... OK");
eprint!("{}", string);
Ok(toml)
},
Err(err) => { error!("Couldn't parse TOML file"); Err(TomlError::Parse(err)) },
Err(err) => { error!("Couldn't parse TOML from string"); Err(TomlError::Deserialize(err)) },
}
}
// Last three functions combined
// get_path() -> read_or_create() -> parse()
// pub fn get() -> Result<State, TomlError> {
// let path = Self::path();
// }
// Overwrite disk Toml with memory State (save state)
pub fn overwrite(state: State, path: PathBuf) -> Result<(), TomlError> {
info!("Starting TOML overwrite...");
let string = match toml::ser::to_string(&state) {
Ok(string) => {
info!("TOML parse ... OK");
eprint!("{}", string);
string
},
Err(err) => { error!("Couldn't parse TOML into string"); return Err(TomlError::Serialize(err)) },
};
match fs::write(&path, string) {
Ok(_) => { info!("TOML overwrite ... OK"); Ok(()) },
Err(err) => { error!("Couldn't overwrite TOML file"); return Err(TomlError::Io(err)) },
}
}
}
@ -129,8 +161,8 @@ impl Display for TomlError {
match self {
Io(err) => write!(f, "{} | {}", ERROR, err),
Path(err) => write!(f, "{} | {}", ERROR, err),
Parse(err) => write!(f, "{} | {}", ERROR, err),
Serialize(err) => write!(f, "{} | {}", ERROR, err),
Deserialize(err) => write!(f, "{} | {}", ERROR, err),
}
}
}
@ -141,17 +173,10 @@ impl From<std::io::Error> for TomlError {
}
}
fn main() {
let state = match Toml::get() {
Ok(state) => { println!("OK"); state },
Err(err) => panic!(),
};
}
//---------------------------------------------------------------------------------------------------- Const
const FILENAME: &'static str = "gupax.toml";
const ERROR: &'static str = "TOML Error";
const PATH_ERROR: &'static str = "PATH for state directory could not be not found";
const PATH_ERROR: &'static str = "PATH for state directory could not be not found";
#[cfg(target_os = "windows")]
const DIRECTORY: &'static str = "Gupax";
#[cfg(target_os = "macos")]
@ -176,55 +201,57 @@ const DEFAULT_XMRIG_PATH: &'static str = "xmrig/xmrig";
pub enum TomlError {
Io(std::io::Error),
Path(String),
Parse(toml::de::Error),
Serialize(toml::ser::Error),
Deserialize(toml::de::Error),
}
//---------------------------------------------------------------------------------------------------- Structs
#[derive(Debug,Deserialize,Serialize)]
pub struct Toml {
gupax: Gupax,
p2pool: P2pool,
xmrig: Xmrig,
version: Version,
#[derive(Clone,Eq,PartialEq,Debug,Deserialize,Serialize)]
pub struct State {
pub gupax: Gupax,
pub p2pool: P2pool,
pub xmrig: Xmrig,
pub version: Version,
}
#[derive(Debug,Deserialize,Serialize)]
struct Gupax {
auto_update: bool,
ask_before_quit: bool,
p2pool_path: String,
xmrig_path: String,
#[derive(Clone,Eq,PartialEq,Debug,Deserialize,Serialize)]
pub struct Gupax {
pub auto_update: bool,
pub ask_before_quit: bool,
pub p2pool_path: String,
pub xmrig_path: String,
}
#[derive(Debug,Deserialize,Serialize)]
struct P2pool {
simple: bool,
mini: bool,
out_peers: u8,
in_peers: u8,
log_level: u8,
node: crate::node::NodeEnum,
monerod: String,
rpc: u16,
zmq: u16,
address: String,
#[derive(Clone,Eq,PartialEq,Debug,Deserialize,Serialize)]
pub struct P2pool {
pub simple: bool,
pub mini: bool,
pub out_peers: u16,
pub in_peers: u16,
pub log_level: u8,
pub node: crate::node::NodeEnum,
pub monerod: String,
pub rpc: u16,
pub zmq: u16,
pub address: String,
}
#[derive(Debug,Deserialize,Serialize)]
struct Xmrig {
simple: bool,
tls: bool,
nicehash: bool,
keepalive: bool,
threads: u16,
priority: u8,
pool: String,
address: String,
#[derive(Clone,Eq,PartialEq,Debug,Deserialize,Serialize)]
pub struct Xmrig {
pub simple: bool,
pub tls: bool,
pub nicehash: bool,
pub keepalive: bool,
pub hugepages_jit: bool,
pub max_threads: u16,
pub current_threads: u16,
pub priority: u8,
pub pool: String,
pub address: String,
}
#[derive(Debug,Deserialize,Serialize)]
struct Version {
p2pool: String,
xmrig: String,
#[derive(Clone,Eq,PartialEq,Debug,Deserialize,Serialize)]
pub struct Version {
pub p2pool: String,
pub xmrig: String,
}

71
src/xmrig.rs
View file

@ -20,54 +20,11 @@ use monero::util::address::Address;
use std::str::FromStr;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use num_cpus;
use crate::State;
use crate::constants::*;
// Main data structure for the XMRig tab
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Xmrig {
pub version: String,
pub sha256: String,
pub manual: bool,
pub tls: bool,
pub nicehash: bool,
pub keepalive: bool,
pub hugepages_jit: bool,
pub threads: u16,
pub priority: u8,
pub pool: String,
pub address: String,
// pub pool: std::net::SocketAddr,
// pub address: monero::util::address::Address,
pub max_threads: u16,
pub current_threads: u16,
}
use crate::state::Xmrig;
impl Xmrig {
pub fn new() -> Self {
let max_threads = num_cpus::get().try_into().unwrap();
let current_threads: u16;
if max_threads == 1 { current_threads = 1 } else { current_threads = max_threads/2 }
Self {
version: String::from("v6.18.0"),
sha256: String::from("asdf"),
manual: false,
tls: false,
nicehash: false,
keepalive: false,
hugepages_jit: true,
threads: 16,
priority: 2,
pool: String::from(""),
address: String::from(""),
// pool: SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 3333),
// address: Address::from_str("44hintoFpuo3ugKfcqJvh5BmrsTRpnTasJmetKC4VXCt6QDtbHVuixdTtsm6Ptp7Y8haXnJ6j8Gj2dra8CKy5ewz7Vi9CYW").unwrap(),
max_threads,
current_threads,
}
}
pub fn show(state: &mut Xmrig, ctx: &egui::Context, ui: &mut egui::Ui) {
pub fn show(&mut self, ctx: &egui::Context, ui: &mut egui::Ui) {
let height = ui.available_height() / 10.0;
let mut width = ui.available_width() - 10.0;
ui.group(|ui| {
@ -81,18 +38,18 @@ impl Xmrig {
ui.horizontal(|ui| {
ui.group(|ui| { ui.vertical(|ui| {
ui.group(|ui| { ui.horizontal(|ui| {
if ui.add_sized([width/2.0, height/6.0], egui::SelectableLabel::new(state.manual == false, "P2Pool Mode")).on_hover_text(XMRIG_P2POOL).clicked() { state.manual = false; };
if ui.add_sized([width/2.0, height/6.0], egui::SelectableLabel::new(state.manual == true, "Manual Mode")).on_hover_text(XMRIG_MANUAL).clicked() { state.manual = true; };
if ui.add_sized([width/2.0, height/6.0], egui::SelectableLabel::new(self.simple == false, "P2Pool Mode")).on_hover_text(XMRIG_P2POOL).clicked() { self.simple = false; };
if ui.add_sized([width/2.0, height/6.0], egui::SelectableLabel::new(self.simple == true, "Manual Mode")).on_hover_text(XMRIG_MANUAL).clicked() { self.simple = true; };
})});
ui.group(|ui| { ui.horizontal(|ui| {
let width = width - 58.0;
ui.add_sized([width/4.0, height/6.0], egui::Checkbox::new(&mut state.tls, "TLS Connection")).on_hover_text(XMRIG_TLS);
ui.add_sized([width/4.0, height/6.0], egui::Checkbox::new(&mut self.tls, "TLS Connection")).on_hover_text(XMRIG_TLS);
ui.separator();
ui.add_sized([width/4.0, height/6.0], egui::Checkbox::new(&mut state.hugepages_jit, "Hugepages JIT")).on_hover_text(XMRIG_HUGEPAGES_JIT);
ui.add_sized([width/4.0, height/6.0], egui::Checkbox::new(&mut self.hugepages_jit, "Hugepages JIT")).on_hover_text(XMRIG_HUGEPAGES_JIT);
ui.separator();
ui.add_sized([width/4.0, height/6.0], egui::Checkbox::new(&mut state.nicehash, "Nicehash")).on_hover_text(XMRIG_NICEHASH);
ui.add_sized([width/4.0, height/6.0], egui::Checkbox::new(&mut self.nicehash, "Nicehash")).on_hover_text(XMRIG_NICEHASH);
ui.separator();
ui.add_sized([width/4.0, height/6.0], egui::Checkbox::new(&mut state.keepalive, "Keepalive")).on_hover_text(XMRIG_KEEPALIVE);
ui.add_sized([width/4.0, height/6.0], egui::Checkbox::new(&mut self.keepalive, "Keepalive")).on_hover_text(XMRIG_KEEPALIVE);
})});
})});
});
@ -101,28 +58,28 @@ impl Xmrig {
style.spacing.slider_width = ui.available_width()/1.25;
ctx.set_style(style);
ui.horizontal(|ui| {
ui.add_sized([width/8.0, height/8.0], egui::Label::new(format!("Threads [1-{}]:", state.max_threads)));
ui.add_sized([width, height/8.0], egui::Slider::new(&mut state.current_threads, 1..=state.max_threads)).on_hover_text(XMRIG_THREADS);
ui.add_sized([width/8.0, height/8.0], egui::Label::new(format!("Threads [1-{}]:", self.max_threads)));
ui.add_sized([width, height/8.0], egui::Slider::new(&mut self.current_threads, 1..=self.max_threads)).on_hover_text(XMRIG_THREADS);
});
ui.horizontal(|ui| {
ui.add_sized([width/8.0, height/8.0], egui::Label::new("CPU Priority [0-5]:"));
ui.add_sized([width, height/8.0], egui::Slider::new(&mut state.priority, 0..=5)).on_hover_text(XMRIG_PRIORITY);
ui.add_sized([width, height/8.0], egui::Slider::new(&mut self.priority, 0..=5)).on_hover_text(XMRIG_PRIORITY);
});
// });
// ui.group(|ui| {
if state.manual == false { ui.set_enabled(false); }
if self.simple == false { ui.set_enabled(false); }
let width = (width/4.0);
ui.horizontal(|ui| {
ui.add_sized([width/8.0, height/8.0], egui::Label::new("Pool IP:"));
ui.spacing_mut().text_edit_width = ui.available_width() - 35.0;
ui.text_edit_singleline(&mut state.pool);
ui.text_edit_singleline(&mut self.pool);
});
ui.horizontal(|ui| {
ui.add_sized([width/8.0, height/8.0], egui::Label::new("Address:"));
ui.spacing_mut().text_edit_width = ui.available_width() - 35.0;
ui.text_edit_singleline(&mut state.address);
ui.text_edit_singleline(&mut self.address);
});
// });
}