2023-05-23 01:46:42 +03:00
|
|
|
// Copyright 2023 The Grim Developers
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
2023-06-02 21:19:34 +03:00
|
|
|
|
2023-06-20 00:38:25 +03:00
|
|
|
use chrono::{DateTime, NaiveDateTime, Utc};
|
2023-06-23 22:12:30 +03:00
|
|
|
use egui::{Response, RichText, Rounding, ScrollArea, Stroke, TextStyle, Widget};
|
2023-06-19 01:29:15 +03:00
|
|
|
use grin_chain::SyncStatus;
|
2023-06-20 00:38:25 +03:00
|
|
|
use grin_servers::WorkerStats;
|
2023-06-19 01:29:15 +03:00
|
|
|
|
2023-06-23 22:12:30 +03:00
|
|
|
use crate::gui::{Colors, Navigator};
|
|
|
|
use crate::gui::icons::{BARBELL, CLOCK_AFTERNOON, COMPUTER_TOWER, CPU, CUBE, FADERS, FOLDER_DASHED, FOLDER_NOTCH_MINUS, FOLDER_NOTCH_PLUS, PLUGS, PLUGS_CONNECTED, POLYGON};
|
2023-06-21 02:13:47 +03:00
|
|
|
use crate::gui::platform::PlatformCallbacks;
|
2023-06-23 22:12:30 +03:00
|
|
|
use crate::gui::views::{Modal, Network, NetworkTab, NetworkTabType, View};
|
|
|
|
use crate::gui::views::settings_stratum::StratumServerSetup;
|
|
|
|
use crate::node::{Node, NodeConfig};
|
2023-06-19 01:29:15 +03:00
|
|
|
use crate::Settings;
|
2023-06-02 21:19:34 +03:00
|
|
|
|
2023-06-03 11:22:51 +03:00
|
|
|
#[derive(Default)]
|
2023-06-23 22:12:30 +03:00
|
|
|
pub struct NetworkMining {
|
|
|
|
stratum_server_setup: StratumServerSetup
|
|
|
|
}
|
2023-06-02 21:19:34 +03:00
|
|
|
|
|
|
|
impl NetworkTab for NetworkMining {
|
2023-06-17 13:23:31 +03:00
|
|
|
fn get_type(&self) -> NetworkTabType {
|
|
|
|
NetworkTabType::Mining
|
|
|
|
}
|
|
|
|
|
2023-06-21 02:13:47 +03:00
|
|
|
fn ui(&mut self, ui: &mut egui::Ui, cb: &dyn PlatformCallbacks) {
|
2023-06-17 13:23:31 +03:00
|
|
|
let server_stats = Node::get_stats();
|
2023-06-21 02:13:47 +03:00
|
|
|
|
2023-06-19 01:29:15 +03:00
|
|
|
// Show message when node is not running or loading spinner when mining are not available.
|
|
|
|
if !server_stats.is_some() || Node::get_sync_status().unwrap() != SyncStatus::NoSync {
|
2023-06-17 13:23:31 +03:00
|
|
|
if !Node::is_running() {
|
2023-06-23 22:12:30 +03:00
|
|
|
Network::disabled_node_ui(ui);
|
2023-06-17 13:23:31 +03:00
|
|
|
} else {
|
2023-06-19 01:29:15 +03:00
|
|
|
View::center_content(ui, 162.0, |ui| {
|
2023-06-17 13:23:31 +03:00
|
|
|
View::big_loading_spinner(ui);
|
2023-06-19 01:29:15 +03:00
|
|
|
ui.add_space(18.0);
|
|
|
|
ui.label(RichText::new(t!("network_mining.loading"))
|
|
|
|
.size(16.0)
|
|
|
|
.color(Colors::INACTIVE_TEXT)
|
|
|
|
);
|
2023-06-17 13:23:31 +03:00
|
|
|
});
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2023-06-03 21:35:38 +03:00
|
|
|
|
2023-06-21 02:13:47 +03:00
|
|
|
let stratum_stats = &server_stats.as_ref().unwrap().stratum_stats;
|
|
|
|
|
2023-06-23 22:12:30 +03:00
|
|
|
// Show stratum server setup when mining server is not running.
|
2023-06-21 02:13:47 +03:00
|
|
|
if !stratum_stats.is_running && !Node::is_stratum_server_starting() {
|
|
|
|
ScrollArea::vertical()
|
2023-06-23 22:12:30 +03:00
|
|
|
.id_source("stratum_server_setup")
|
2023-06-21 02:13:47 +03:00
|
|
|
.auto_shrink([false; 2])
|
|
|
|
.show(ui, |ui| {
|
2023-06-23 22:12:30 +03:00
|
|
|
self.stratum_server_setup.ui(ui, cb);
|
2023-06-21 02:13:47 +03:00
|
|
|
|
|
|
|
ui.vertical_centered(|ui| {
|
|
|
|
// Show message about stratum server config.
|
2023-06-23 22:12:30 +03:00
|
|
|
let text = t!("network_mining.server_setting", "settings" => FADERS);
|
2023-06-21 02:13:47 +03:00
|
|
|
ui.label(RichText::new(text)
|
|
|
|
.size(16.0)
|
|
|
|
.color(Colors::INACTIVE_TEXT)
|
|
|
|
);
|
2023-06-23 22:12:30 +03:00
|
|
|
ui.add_space(4.0);
|
|
|
|
|
|
|
|
// Show button to enable stratum server if port is available.
|
|
|
|
if self.stratum_server_setup.stratum_port_available {
|
|
|
|
ui.add_space(6.0);
|
|
|
|
View::button(ui, t!("network_mining.enable_server"), Colors::GOLD, || {
|
|
|
|
Node::start_stratum_server();
|
|
|
|
});
|
|
|
|
ui.add_space(2.0);
|
|
|
|
}
|
2023-06-21 02:13:47 +03:00
|
|
|
|
|
|
|
let stratum_enabled = Settings::node_config_to_read()
|
|
|
|
.members.clone()
|
|
|
|
.server.stratum_mining_config.unwrap()
|
|
|
|
.enable_stratum_server.unwrap();
|
|
|
|
|
|
|
|
// Show stratum server autorun checkbox.
|
|
|
|
View::checkbox(ui, stratum_enabled, t!("network.autorun"), || {
|
|
|
|
let mut w_node_config = Settings::node_config_to_update();
|
|
|
|
w_node_config.members
|
|
|
|
.server.stratum_mining_config.as_mut().unwrap()
|
|
|
|
.enable_stratum_server = Some(!stratum_enabled);
|
|
|
|
w_node_config.save();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
ui.add_space(6.0);
|
2023-06-19 01:29:15 +03:00
|
|
|
});
|
|
|
|
return;
|
|
|
|
} else if Node::is_stratum_server_starting() {
|
2023-06-20 00:38:25 +03:00
|
|
|
ui.centered_and_justified(|ui| {
|
2023-06-19 01:29:15 +03:00
|
|
|
View::big_loading_spinner(ui);
|
|
|
|
});
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Show stratum mining server info.
|
2023-06-20 00:38:25 +03:00
|
|
|
View::sub_title(ui, format!("{} {}", COMPUTER_TOWER, t!("network_mining.server")));
|
2023-06-19 01:29:15 +03:00
|
|
|
ui.columns(2, |columns| {
|
|
|
|
columns[0].vertical_centered(|ui| {
|
2023-06-23 22:12:30 +03:00
|
|
|
let (stratum_addr, stratum_port) = NodeConfig::get_stratum_address_port();
|
2023-06-19 01:29:15 +03:00
|
|
|
View::rounded_box(ui,
|
2023-06-23 22:12:30 +03:00
|
|
|
format!("{}:{}", stratum_addr, stratum_port),
|
|
|
|
t!("network_mining.address"),
|
2023-06-19 01:29:15 +03:00
|
|
|
[true, false, true, false]);
|
|
|
|
});
|
|
|
|
columns[1].vertical_centered(|ui| {
|
2023-06-20 00:38:25 +03:00
|
|
|
//TODO: Stratum mining wallet listening address. Replace with local wallet name.
|
2023-06-19 01:29:15 +03:00
|
|
|
let wallet_address = Settings::node_config_to_read()
|
|
|
|
.members.clone()
|
|
|
|
.server.stratum_mining_config.unwrap()
|
2023-06-20 00:38:25 +03:00
|
|
|
.wallet_listener_url
|
|
|
|
.replace("http://", "");
|
2023-06-19 01:29:15 +03:00
|
|
|
View::rounded_box(ui,
|
|
|
|
wallet_address,
|
2023-06-21 02:13:47 +03:00
|
|
|
t!("network_mining.rewards_wallet"),
|
2023-06-19 01:29:15 +03:00
|
|
|
[false, true, false, true]);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
ui.add_space(4.0);
|
|
|
|
|
|
|
|
// Show network info.
|
2023-06-20 00:38:25 +03:00
|
|
|
View::sub_title(ui, format!("{} {}", POLYGON, t!("network.self")));
|
2023-06-19 01:29:15 +03:00
|
|
|
ui.columns(3, |columns| {
|
|
|
|
columns[0].vertical_centered(|ui| {
|
|
|
|
let difficulty = if stratum_stats.network_difficulty > 0 {
|
|
|
|
stratum_stats.network_difficulty.to_string()
|
|
|
|
} else {
|
|
|
|
"-".into()
|
|
|
|
};
|
|
|
|
View::rounded_box(ui,
|
|
|
|
difficulty,
|
|
|
|
t!("network_node.difficulty"),
|
|
|
|
[true, false, true, false]);
|
|
|
|
});
|
|
|
|
columns[1].vertical_centered(|ui| {
|
|
|
|
let block_height = if stratum_stats.block_height > 0 {
|
|
|
|
stratum_stats.block_height.to_string()
|
|
|
|
} else {
|
|
|
|
"-".into()
|
|
|
|
};
|
|
|
|
View::rounded_box(ui,
|
|
|
|
block_height,
|
|
|
|
t!("network_node.header"),
|
|
|
|
[false, false, false, false]);
|
|
|
|
});
|
|
|
|
columns[2].vertical_centered(|ui| {
|
|
|
|
let hashrate = if stratum_stats.network_hashrate > 0.0 {
|
2023-06-20 00:38:25 +03:00
|
|
|
format!("{:.*}", 2, stratum_stats.network_hashrate)
|
2023-06-19 01:29:15 +03:00
|
|
|
} else {
|
|
|
|
"-".into()
|
|
|
|
};
|
|
|
|
View::rounded_box(ui,
|
|
|
|
hashrate,
|
2023-06-20 00:38:25 +03:00
|
|
|
t!("network_mining.hashrate", "bits" => stratum_stats.edge_bits),
|
2023-06-19 01:29:15 +03:00
|
|
|
[false, true, false, true]);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
ui.add_space(4.0);
|
|
|
|
|
|
|
|
// Show mining info.
|
2023-06-20 00:38:25 +03:00
|
|
|
View::sub_title(ui, format!("{} {}", CPU, t!("network_mining.miners")));
|
2023-06-19 01:29:15 +03:00
|
|
|
ui.columns(2, |columns| {
|
|
|
|
columns[0].vertical_centered(|ui| {
|
|
|
|
View::rounded_box(ui,
|
|
|
|
stratum_stats.num_workers.to_string(),
|
|
|
|
t!("network_mining.devices"),
|
|
|
|
[true, false, true, false]);
|
|
|
|
});
|
|
|
|
|
|
|
|
columns[1].vertical_centered(|ui| {
|
|
|
|
View::rounded_box(ui,
|
|
|
|
stratum_stats.blocks_found.to_string(),
|
|
|
|
t!("network_mining.blocks_found"),
|
|
|
|
[false, true, false, true]);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
ui.add_space(4.0);
|
|
|
|
|
2023-06-20 00:38:25 +03:00
|
|
|
// Show workers stats or info text when possible.
|
|
|
|
let workers_size = stratum_stats.worker_stats.len();
|
|
|
|
if workers_size != 0 && stratum_stats.num_workers > 0 {
|
2023-06-21 02:13:47 +03:00
|
|
|
ui.add_space(4.0);
|
|
|
|
View::horizontal_line(ui, Colors::ITEM_STROKE);
|
|
|
|
ui.add_space(4.0);
|
2023-06-20 00:38:25 +03:00
|
|
|
ScrollArea::vertical()
|
|
|
|
.auto_shrink([false; 2])
|
|
|
|
.id_source("stratum_workers_scroll")
|
|
|
|
.show_rows(
|
|
|
|
ui,
|
|
|
|
WORKER_UI_HEIGHT,
|
|
|
|
workers_size,
|
|
|
|
|ui, row_range| {
|
|
|
|
for index in row_range {
|
|
|
|
let worker = stratum_stats.worker_stats.get(index).unwrap();
|
|
|
|
let rounding = if workers_size == 1 {
|
|
|
|
[true, true]
|
|
|
|
} else if index == 0 {
|
|
|
|
[true, false]
|
|
|
|
} else if index == workers_size - 1 {
|
|
|
|
[false, true]
|
|
|
|
} else {
|
|
|
|
[false, false]
|
|
|
|
};
|
2023-06-23 22:12:30 +03:00
|
|
|
draw_workers_stats(ui, worker, rounding)
|
2023-06-20 00:38:25 +03:00
|
|
|
}
|
|
|
|
},
|
|
|
|
);
|
2023-06-19 01:29:15 +03:00
|
|
|
} else if ui.available_height() > 142.0 {
|
|
|
|
View::center_content(ui, 142.0, |ui| {
|
|
|
|
ui.label(RichText::new(t!("network_mining.info", "settings" => FADERS))
|
|
|
|
.size(16.0)
|
|
|
|
.color(Colors::INACTIVE_TEXT)
|
|
|
|
);
|
|
|
|
});
|
|
|
|
}
|
2023-06-02 21:19:34 +03:00
|
|
|
}
|
2023-06-23 22:12:30 +03:00
|
|
|
|
|
|
|
fn on_modal_ui(&mut self, ui: &mut egui::Ui, modal: &Modal, cb: &dyn PlatformCallbacks) {
|
|
|
|
match modal.id {
|
|
|
|
StratumServerSetup::STRATUM_PORT_MODAL => {
|
|
|
|
self.stratum_server_setup.stratum_port_modal_ui(ui, modal, cb);
|
|
|
|
},
|
|
|
|
_ => {}
|
|
|
|
}
|
|
|
|
}
|
2023-06-20 00:38:25 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
const WORKER_UI_HEIGHT: f32 = 77.0;
|
|
|
|
|
2023-06-23 22:12:30 +03:00
|
|
|
fn draw_workers_stats(ui: &mut egui::Ui, ws: &WorkerStats, rounding: [bool; 2]) {
|
2023-06-20 00:38:25 +03:00
|
|
|
// Add space before the first item.
|
|
|
|
if rounding[0] {
|
|
|
|
ui.add_space(4.0);
|
|
|
|
}
|
|
|
|
|
2023-06-21 02:13:47 +03:00
|
|
|
ui.horizontal_wrapped(|ui| {
|
|
|
|
ui.vertical_centered_justified(|ui| {
|
2023-06-20 00:38:25 +03:00
|
|
|
let mut rect = ui.available_rect_before_wrap();
|
|
|
|
rect.set_height(WORKER_UI_HEIGHT);
|
|
|
|
ui.painter().rect(
|
|
|
|
rect,
|
|
|
|
Rounding {
|
|
|
|
nw: if rounding[0] { 8.0 } else { 0.0 },
|
|
|
|
ne: if rounding[0] { 8.0 } else { 0.0 },
|
|
|
|
sw: if rounding[1] { 8.0 } else { 0.0 },
|
|
|
|
se: if rounding[1] { 8.0 } else { 0.0 },
|
|
|
|
},
|
|
|
|
Colors::WHITE,
|
|
|
|
Stroke { width: 1.0, color: Colors::ITEM_STROKE }
|
|
|
|
);
|
|
|
|
|
|
|
|
ui.add_space(2.0);
|
|
|
|
ui.horizontal_top(|ui| {
|
2023-06-21 02:13:47 +03:00
|
|
|
let (status_text, status_icon, status_color) = match ws.is_connected {
|
|
|
|
true => { (t!("network_mining.connected"), PLUGS_CONNECTED, Colors::BLACK) }
|
|
|
|
false => { (t!("network_mining.disconnected"), PLUGS, Colors::INACTIVE_TEXT) }
|
2023-06-20 00:38:25 +03:00
|
|
|
};
|
|
|
|
ui.add_space(5.0);
|
|
|
|
ui.heading(RichText::new(status_icon)
|
2023-06-21 02:13:47 +03:00
|
|
|
.color(status_color)
|
2023-06-20 00:38:25 +03:00
|
|
|
.size(18.0));
|
|
|
|
ui.add_space(2.0);
|
|
|
|
|
|
|
|
// Draw worker ID.
|
|
|
|
ui.heading(RichText::new(&ws.id)
|
2023-06-21 02:13:47 +03:00
|
|
|
.color(status_color)
|
2023-06-20 00:38:25 +03:00
|
|
|
.size(18.0));
|
|
|
|
ui.add_space(3.0);
|
|
|
|
|
|
|
|
// Draw worker status.
|
|
|
|
ui.heading(RichText::new(status_text)
|
2023-06-21 02:13:47 +03:00
|
|
|
.color(status_color)
|
2023-06-20 00:38:25 +03:00
|
|
|
.size(18.0));
|
|
|
|
});
|
|
|
|
ui.horizontal_top(|ui| {
|
|
|
|
ui.add_space(6.0);
|
|
|
|
ui.heading(RichText::new(BARBELL)
|
|
|
|
.color(Colors::TITLE)
|
|
|
|
.size(16.0));
|
|
|
|
ui.add_space(4.0);
|
|
|
|
// Draw difficulty.
|
|
|
|
ui.heading(RichText::new(ws.pow_difficulty.to_string())
|
|
|
|
.color(Colors::TITLE)
|
|
|
|
.size(16.0));
|
|
|
|
ui.add_space(6.0);
|
|
|
|
|
|
|
|
ui.heading(RichText::new(FOLDER_NOTCH_PLUS)
|
|
|
|
.color(Colors::GREEN)
|
|
|
|
.size(16.0));
|
|
|
|
ui.add_space(3.0);
|
|
|
|
// Draw accepted shares.
|
|
|
|
ui.heading(RichText::new(ws.num_accepted.to_string())
|
|
|
|
.color(Colors::GREEN)
|
|
|
|
.size(16.0));
|
|
|
|
ui.add_space(6.0);
|
|
|
|
|
|
|
|
ui.heading(RichText::new(FOLDER_NOTCH_MINUS)
|
|
|
|
.color(Colors::RED)
|
|
|
|
.size(16.0));
|
|
|
|
ui.add_space(3.0);
|
|
|
|
// Draw rejected shares.
|
|
|
|
ui.heading(RichText::new(ws.num_rejected.to_string())
|
|
|
|
.color(Colors::RED)
|
|
|
|
.size(16.0));
|
|
|
|
ui.add_space(6.0);
|
|
|
|
|
|
|
|
ui.heading(RichText::new(FOLDER_DASHED)
|
|
|
|
.color(Colors::GRAY)
|
|
|
|
.size(16.0));
|
|
|
|
ui.add_space(3.0);
|
|
|
|
// Draw stale shares.
|
|
|
|
ui.heading(RichText::new(ws.num_stale.to_string())
|
|
|
|
.color(Colors::GRAY)
|
|
|
|
.size(16.0));
|
|
|
|
ui.add_space(6.0);
|
|
|
|
|
|
|
|
ui.heading(RichText::new(CUBE)
|
|
|
|
.color(Colors::TITLE)
|
|
|
|
.size(16.0));
|
|
|
|
ui.add_space(3.0);
|
|
|
|
// Draw blocks found.
|
|
|
|
ui.heading(RichText::new(ws.num_blocks_found.to_string())
|
|
|
|
.color(Colors::TITLE)
|
|
|
|
.size(16.0));
|
|
|
|
});
|
|
|
|
ui.horizontal_top(|ui| {
|
|
|
|
ui.add_space(6.0);
|
|
|
|
ui.heading(RichText::new(CLOCK_AFTERNOON)
|
|
|
|
.color(Colors::TITLE)
|
|
|
|
.size(16.0));
|
|
|
|
ui.add_space(4.0);
|
|
|
|
|
|
|
|
// Draw block time
|
|
|
|
let seen = ws.last_seen.duration_since(std::time::UNIX_EPOCH).unwrap().as_secs();
|
|
|
|
let naive_datetime = NaiveDateTime::from_timestamp_opt(seen as i64, 0).unwrap();
|
|
|
|
let datetime: DateTime<Utc> = DateTime::from_utc(naive_datetime, Utc);
|
|
|
|
ui.heading(RichText::new(datetime.to_string())
|
|
|
|
.color(Colors::GRAY)
|
|
|
|
.size(16.0));
|
|
|
|
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2023-06-02 21:19:34 +03:00
|
|
|
}
|