From 4d61971a0864a65f2bf515b6103b3e24a5421bf1 Mon Sep 17 00:00:00 2001 From: Ilya Zlobintsev Date: Mon, 1 Mar 2021 15:10:53 +0200 Subject: [PATCH] Ask the user permission to use the online database --- cli/src/main.rs | 41 ++++++++++++++++++++++++++++++--- daemon/src/daemon_connection.rs | 19 ++++++++++++++- daemon/src/gpu_controller.rs | 5 +++- daemon/src/lib.rs | 40 ++++++++++++++++++++++++++++---- gui/src/main.rs | 28 +++++++++++++++++++++- 5 files changed, 122 insertions(+), 11 deletions(-) diff --git a/cli/src/main.rs b/cli/src/main.rs index b4d3c52..95ad27d 100644 --- a/cli/src/main.rs +++ b/cli/src/main.rs @@ -3,7 +3,14 @@ use daemon::daemon_connection::DaemonConnection; use structopt::StructOpt; #[derive(StructOpt)] -enum Curve { +enum ConfigOpt { + Show, + AllowOnlineUpdating, + DisallowOnlineUpdating, +} + +#[derive(StructOpt)] +enum CurveOpt { /// Shows current fan control information Status { /// Specify a GPU ID as printed in `lact-cli gpus`. By default, all GPUs are printed. @@ -26,8 +33,9 @@ enum Opt { /// Specify a GPU ID as printed in `lact-cli gpus`. By default, all GPUs are printed. gpu_id: Option, }, + Config(ConfigOpt), /// Fan curve control - Curve(Curve), + Curve(CurveOpt), } fn main() { @@ -74,7 +82,7 @@ fn main() { } } Opt::Curve(curve) => match curve { - Curve::Status { gpu_id } => { + CurveOpt::Status { gpu_id } => { let mut gpu_ids: Vec = Vec::new(); if let Some(gpu_id) = gpu_id { @@ -90,9 +98,36 @@ fn main() { } } }, + Opt::Config(config_opt) => match config_opt { + ConfigOpt::Show => print_config(&d), + ConfigOpt::AllowOnlineUpdating => enable_online_update(&d), + ConfigOpt::DisallowOnlineUpdating => disable_online_update(&d), + }, } } +fn disable_online_update(d: &DaemonConnection) { + let mut config = d.get_config().unwrap(); + config.allow_online_update = Some(false); + d.set_config(config).unwrap(); +} + +fn enable_online_update(d: &DaemonConnection) { + let mut config = d.get_config().unwrap(); + config.allow_online_update = Some(true); + d.set_config(config).unwrap(); +} + +fn print_config(d: &DaemonConnection) { + let config = d.get_config().unwrap(); + + println!( + "{} {:?}", + "Online PCI DB updating:".purple(), + config.allow_online_update + ); +} + fn print_fan_curve(d: &DaemonConnection, gpu_id: u32) { let fan_control = d.get_fan_control(gpu_id).unwrap(); diff --git a/daemon/src/daemon_connection.rs b/daemon/src/daemon_connection.rs index 6713371..3a4ad6c 100644 --- a/daemon/src/daemon_connection.rs +++ b/daemon/src/daemon_connection.rs @@ -1,6 +1,9 @@ -use crate::gpu_controller::{FanControlInfo, GpuStats}; use crate::gpu_controller::{GpuInfo, PowerProfile}; use crate::DaemonError; +use crate::{ + config::Config, + gpu_controller::{FanControlInfo, GpuStats}, +}; use crate::{Action, DaemonResponse, SOCK_PATH}; use std::collections::{BTreeMap, HashMap}; use std::io::{Read, Write}; @@ -164,4 +167,18 @@ impl DaemonConnection { s.write_all(&bincode::serialize(&Action::Shutdown).unwrap()) .unwrap(); } + + pub fn get_config(&self) -> Result { + match self.send_action(Action::GetConfig)? { + DaemonResponse::Config(config) => Ok(config), + _ => unreachable!(), + } + } + + pub fn set_config(&self, config: Config) -> Result<(), DaemonError> { + match self.send_action(Action::SetConfig(config))? { + DaemonResponse::OK => Ok(()), + _ => unreachable!(), + } + } } diff --git a/daemon/src/gpu_controller.rs b/daemon/src/gpu_controller.rs index a3a93cb..1f72fba 100644 --- a/daemon/src/gpu_controller.rs +++ b/daemon/src/gpu_controller.rs @@ -292,7 +292,10 @@ impl GpuController { } } Err(err) => { - println!("{:?} pci.ids not found! Make sure you have 'hwdata' installed", err); + println!( + "{:?} pci.ids not found! Make sure you have 'hwdata' installed", + err + ); VendorData::default() } }, diff --git a/daemon/src/lib.rs b/daemon/src/lib.rs index 23ad888..1f3aa94 100644 --- a/daemon/src/lib.rs +++ b/daemon/src/lib.rs @@ -32,6 +32,8 @@ pub struct Daemon { #[derive(Serialize, Deserialize, Debug)] pub enum Action { CheckAlive, + GetConfig, + SetConfig(Config), GetGpus, GetInfo(u32), GetStats(u32), @@ -81,8 +83,12 @@ impl Daemon { Config::new(&config_path) } else { match Config::read_from_file(&config_path) { - Ok(c) => c, + Ok(c) => { + log::info!("Loaded config from {}", c.config_path.to_string_lossy()); + c + } Err(_) => { + log::info!("Config not found, creating"); let c = Config::new(&config_path); //c.save().unwrap(); c @@ -90,7 +96,7 @@ impl Daemon { } }; - log::trace!("Using config {:?}", config); + log::info!("Using config {:?}", config); let gpu_controllers = Self::load_gpu_controllers(&mut config); @@ -129,10 +135,25 @@ impl Daemon { let mut controller = GpuController::new(entry.path().join("device"), GpuConfig::new(), &pci_db); - let gpu_info = &controller.get_info(); + let current_identifier = controller.get_identifier(); + + log::info!( + "Searching the config for GPU with identifier {:?}", + current_identifier + ); + + log::info!("{}", &config.gpu_configs.len()); for (id, (gpu_identifier, gpu_config)) in &config.gpu_configs { - if gpu_info.pci_slot == gpu_identifier.pci_id + log::info!("Comparing with {:?}", gpu_identifier); + if current_identifier == *gpu_identifier { + controller.load_config(&gpu_config); + gpu_controllers.insert(id.clone(), controller); + log::info!("already known"); + continue 'entries; + } + + /*if gpu_info.pci_slot == gpu_identifier.pci_id && gpu_info.vendor_data.card_model == gpu_identifier.card_model && gpu_info.vendor_data.gpu_model == gpu_identifier.gpu_model { @@ -140,7 +161,7 @@ impl Daemon { gpu_controllers.insert(id.clone(), controller); log::info!("already known"); continue 'entries; - } + }*/ } log::info!("initializing for the first time"); @@ -403,6 +424,14 @@ impl Daemon { } std::process::exit(0); } + Action::SetConfig(config) => { + self.config = config; + self.gpu_controllers.clear(); + self.gpu_controllers = Self::load_gpu_controllers(&mut self.config); + self.config.save().expect("Failed to save config"); + Ok(DaemonResponse::OK) + } + Action::GetConfig => Ok(DaemonResponse::Config(self.config.clone())), }; log::trace!("Responding"); @@ -429,6 +458,7 @@ pub enum DaemonResponse { Gpus(HashMap>), PowerCap((i64, i64)), FanControlInfo(gpu_controller::FanControlInfo), + Config(Config), } #[derive(Serialize, Deserialize, Debug)] diff --git a/gui/src/main.rs b/gui/src/main.rs index f2361b1..98c9f6b 100644 --- a/gui/src/main.rs +++ b/gui/src/main.rs @@ -12,11 +12,37 @@ fn main() { panic!("Cannot initialize GTK"); } - let app = App::new(connect_daemon()); + let connection = connect_daemon(); + + ask_for_online_update(&connection); + + let app = App::new(connection); app.run().unwrap(); } +fn ask_for_online_update(connection: &DaemonConnection) { + let mut config = connection.get_config().unwrap(); + + if let None = config.allow_online_update { + let diag = MessageDialog::new( + None::<&Window>, + DialogFlags::empty(), + MessageType::Warning, + ButtonsType::YesNo, + "Do you wish to use the online database for GPU identification?", + ); + match diag.run() { + ResponseType::Yes => config.allow_online_update = Some(true), + ResponseType::No => config.allow_online_update = Some(false), + _ => unreachable!(), + } + diag.hide(); + + connection.set_config(config).unwrap(); + } +} + fn connect_daemon() -> DaemonConnection { match DaemonConnection::new() { Ok(connection) => {