Add the ability to query the daemon to retrieve information about the current status

Author: ShellCode33

Cargo.lock

@@ -13,13 +13,21 @@ pub enum BacklightMode {
     Manual,
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct BacklightInfo {
+    pub brightness_percent: u8,
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 pub enum BacklightCommand {
     SetBrightness(u8),
     IncreaseBrightness(u8),
     DecreaseBrightness(u8),
     Refresh,
     SetMode(BacklightMode),
+    GetInfo,
+    GetInfoResponse(BacklightInfo),
+    NotifyShutdown,
 }
 
 // The following abstraction allow us to easily change the protocol if need be.

backlight_ipc/src/lib.rs

@@ -6,3 +6,4 @@ edition = "2021"
 [dependencies]
 clap = { version = "4.5.21", features = ["derive"] }
 backlight_ipc = { path = "../backlight_ipc" }
+serde_json = "1.0"

backlightctl/Cargo.toml

@@ -22,6 +22,10 @@ struct BacklightctlCli {
     /// UNIX socket path (for test purposes)
     #[clap(short, long, default_value = DEFAULT_UNIX_SOCKET_PATH)]
     unix_socket_path: PathBuf,
+
+    /// Output will be JSON
+    #[clap(long, default_value_t = false)]
+    json: bool,
 }
 
 fn main() {
@@ -167,4 +171,40 @@ fn main() {
             exit(1);
         }
     }
+
+    if let Err(err) = BacklightCommand::GetInfo.serialize_into(&stream) {
+        eprintln!("{err}");
+        exit(1);
+    }
+
+    let backlight_info = match BacklightCommand::deserialize_from(&stream) {
+        Ok(BacklightCommand::GetInfoResponse(info)) => info,
+        Ok(cmd) => {
+            eprintln!("Unexpected response: {cmd:?}");
+            exit(1);
+        }
+        Err(err) => {
+            eprintln!("{err}");
+            exit(1);
+        }
+    };
+
+    if cli.json {
+        match serde_json::to_string(&backlight_info) {
+            Ok(backlight_info_json) => {
+                println!("{backlight_info_json}");
+            }
+            Err(err) => {
+                eprintln!("Cannot serialize GetInfoResponse to json: {err}");
+                exit(1);
+            }
+        }
+    } else {
+        println!("Current brightness: {}%", backlight_info.brightness_percent);
+    }
+
+    if let Err(err) = BacklightCommand::NotifyShutdown.serialize_into(&stream) {
+        eprintln!("{err}");
+        exit(1);
+    }
 }

backlightctl/src/main.rs

@@ -1,16 +1,19 @@
 use std::{
     env,
-    fs::remove_file,
+    fs::{self, remove_file},
     io,
-    os::unix::net::UnixListener,
+    os::unix::{
+        fs::PermissionsExt,
+        net::{UnixListener, UnixStream},
+    },
     process::exit,
-    sync::mpsc::{channel, Receiver, Sender},
+    sync::mpsc::{channel, Sender},
     thread,
 };
 
+use anyhow::bail;
 use auto::auto_adjust;
-use backlight_ipc::{BacklightCommand, BacklightMode, DEFAULT_UNIX_SOCKET_PATH};
-use log::error;
+use backlight_ipc::{BacklightCommand, BacklightInfo, BacklightMode, DEFAULT_UNIX_SOCKET_PATH};
 use monitors::auto_refresh_monitors_list;
 
 mod acpi;
@@ -19,14 +22,16 @@ mod ddc;
 mod location;
 mod monitors;
 
-fn handle_commands(
-    cmd_receiver: Receiver<BacklightCommand>,
+fn handle_client(
+    client: UnixStream,
     auto_adjust_sender: Sender<BacklightMode>,
-) -> ! {
+) -> anyhow::Result<()> {
     loop {
-        let command = cmd_receiver
-            .recv()
-            .expect("Failed to receive command from cmd channel");
+        let command = match BacklightCommand::deserialize_from(&client) {
+            Ok(cmd) => cmd,
+            Err(err) => bail!("Unable to deserialize command: {err}"),
+        };
+
         let result = match command {
             BacklightCommand::SetBrightness(percent) => {
                 auto_adjust_sender
@@ -54,22 +59,38 @@ fn handle_commands(
                 auto_adjust_sender
                     .send(backlight_mode)
                     .unwrap_or_else(|err| {
-                        error!("Failed to send mode to auto adjust channel: {err}")
+                        log::error!("Failed to send mode to auto adjust channel: {err}")
                     });
                 Ok(())
             }
+            BacklightCommand::GetInfo => {
+                BacklightCommand::GetInfoResponse(BacklightInfo {
+                    brightness_percent: monitors::get_average_brightness(),
+                })
+                .serialize_into(&client)
+                .unwrap_or_else(|err| log::error!("Unable to serialize GetInfoResponse: {err}"));
+                Ok(())
+            }
+            BacklightCommand::GetInfoResponse(_) => {
+                log::warn!("Got GetInfoResponse from client, API misuse ?");
+                Ok(())
+            }
+            BacklightCommand::NotifyShutdown => break,
         };
 
         if let Err(err) = result {
-            error!("Command handling failed: {err}");
+            log::error!("Command handling failed: {err}");
         }
     }
+
+    Ok(())
 }
 
 fn main() {
     pretty_env_logger::formatted_builder()
         .filter_level(log::LevelFilter::Info)
         .parse_env("BACKLIGHTD_LOG_LEVEL")
+        .filter_module("ureq", log::LevelFilter::Warn)
         .init();
 
     let args: Vec<String> = env::args().collect();
@@ -90,54 +111,49 @@ fn main() {
 
     if let Err(err) = remove_file(unix_socket_path) {
         if !matches!(err.kind(), io::ErrorKind::NotFound) {
-            error!("{unix_socket_path}: {err}");
+            log::error!("{unix_socket_path}: {err}");
             exit(1);
         }
     }
 
     let listener = match UnixListener::bind(unix_socket_path) {
         Ok(listener) => listener,
         Err(err) => {
-            error!("{unix_socket_path}: {err}");
+            log::error!("{unix_socket_path}: {err}");
             exit(1);
         }
     };
 
-    let (cmd_sender, cmd_receiver) = channel();
+    if let Err(err) = fs::set_permissions(unix_socket_path, fs::Permissions::from_mode(0o777)) {
+        log::error!("{unix_socket_path}: {err}");
+        exit(1);
+    }
+
     let (auto_sender, auto_receiver) = channel();
 
     let auto_refresh_monitors_thread = thread::spawn(move || auto_refresh_monitors_list());
-    let command_handler_thread = thread::spawn(move || handle_commands(cmd_receiver, auto_sender));
     let auto_adjust_thread = thread::spawn(move || auto_adjust(auto_receiver));
 
     for stream in listener.incoming() {
         if auto_refresh_monitors_thread.is_finished() {
             panic!("auto refresh monitors thread is gone");
         }
 
-        if command_handler_thread.is_finished() {
-            panic!("command handler thread is gone");
-        }
-
         if auto_adjust_thread.is_finished() {
             panic!("auto adjust thread is gone");
         }
 
-        let stream = match stream {
-            Ok(stream) => stream,
+        let client = match stream {
+            Ok(client) => client,
             Err(err) => {
-                error!("A client tried to connect but something wrong happened: {err}");
+                log::error!("Failed to accept incoming client: {err}");
                 continue;
             }
         };
 
-        match BacklightCommand::deserialize_from(&stream) {
-            Ok(command) => {
-                cmd_sender.send(command).unwrap();
-            }
-            Err(err) => {
-                error!("Unable to deserialize command: {err}");
-            }
+        if let Err(err) = handle_client(client, auto_sender.clone()) {
+            log::error!("{err}");
+            continue;
         }
     }
 

backlightd/src/main.rs

@@ -165,3 +165,14 @@ pub(crate) fn decrease_brightness_percent(percent: u8) -> anyhow::Result<()> {
         Ok(())
     }
 }
+
+pub(crate) fn get_average_brightness() -> u8 {
+    let monitors = MONITORS.lock().unwrap();
+    let mut sum: usize = 0;
+
+    for monitor in &*monitors {
+        sum += monitor.get_brightness() as usize;
+    }
+
+    (sum / monitors.len()) as u8
+}