Improve D-Bus desktop service daemons (polkit, sessiond, udisks, upower)

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

local/recipes/system/redbear-polkit/source/src/main.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, env, error::Error, process};
+use std::{collections::HashMap, env, error::Error, path::Path, process, thread, time::Duration};
 
 use tokio::runtime::Builder as RuntimeBuilder;
 use zbus::{
@@ -34,6 +34,21 @@ fn usage() -> &'static str {
     "Usage: redbear-polkit [--help]"
 }
 
+async fn wait_for_dbus_socket() {
+    let socket_path = env::var("DBUS_STARTER_ADDRESS")
+        .ok()
+        .and_then(|addr| addr.strip_prefix("unix:path=").map(String::from))
+        .unwrap_or_else(|| "/run/dbus/system_bus_socket".to_string());
+
+    for _ in 0..30 {
+        if tokio::net::UnixStream::connect(&socket_path).await.is_ok() {
+            return;
+        }
+        tokio::time::sleep(Duration::from_secs(1)).await;
+    }
+    eprintln!("redbear-polkit: timed out waiting for D-Bus socket at {socket_path}");
+}
+
 fn parse_args() -> Result<Command, String> {
     let mut args = env::args().skip(1);
 
@@ -134,25 +149,34 @@ impl PolicyKitAuthority {
 }
 
 async fn run_daemon() -> Result<(), Box<dyn Error>> {
-    eprintln!("redbear-polkit: startup begin");
+    wait_for_dbus_socket().await;
-    let _authority_path = parse_object_path(AUTHORITY_PATH)?;
-    eprintln!("redbear-polkit: object paths parsed");
 
-    eprintln!("redbear-polkit: starter address={:?}", env::var("DBUS_STARTER_ADDRESS").ok());
+    let mut last_err = None;
-    eprintln!("redbear-polkit: building D-Bus connection");
+    for attempt in 1..=5 {
-    let connection = system_connection_builder()?
+        let _authority_path = parse_object_path(AUTHORITY_PATH)?;
+
+        match system_connection_builder()?
             .name(BUS_NAME)?
             .serve_at(AUTHORITY_PATH, PolicyKitAuthority)?
             .build()
-        .await?;
+            .await
-
+        {
+            Ok(connection) => {
                 eprintln!("redbear-polkit: registered {BUS_NAME} on the system bus");
-
                 wait_for_shutdown().await?;
                 drop(connection);
-    eprintln!("redbear-polkit: received shutdown signal, exiting cleanly");
+                return Ok(());
-
+            }
-    Ok(())
+            Err(err) => {
+                if attempt < 5 {
+                    eprintln!("redbear-polkit: attempt {attempt}/5 failed ({err}), retrying in 2s...");
+                    tokio::time::sleep(Duration::from_secs(2)).await;
+                }
+                last_err = Some(err.into());
+            }
+        }
+    }
+    Err(last_err.unwrap())
 }
 
 fn main() {

local/recipes/system/redbear-sessiond/source/src/main.rs

@@ -8,6 +8,7 @@ use std::{
     env,
     error::Error,
     process,
+    time::Duration,
 };
 
 use device_map::DeviceMap;
@@ -56,6 +57,21 @@ fn parse_object_path(path: &str) -> Result<OwnedObjectPath, Box<dyn Error>> {
     Ok(OwnedObjectPath::try_from(path.to_owned())?)
 }
 
+async fn wait_for_dbus_socket() {
+    let socket_path = env::var("DBUS_STARTER_ADDRESS")
+        .ok()
+        .and_then(|addr| addr.strip_prefix("unix:path=").map(String::from))
+        .unwrap_or_else(|| "/run/dbus/system_bus_socket".to_string());
+
+    for _ in 0..30 {
+        if tokio::net::UnixStream::connect(&socket_path).await.is_ok() {
+            return;
+        }
+        tokio::time::sleep(Duration::from_secs(1)).await;
+    }
+    eprintln!("redbear-sessiond: timed out waiting for D-Bus socket at {socket_path}");
+}
+
 fn system_connection_builder() -> Result<ConnectionBuilder<'static>, Box<dyn Error>> {
     if let Ok(address) = env::var("DBUS_STARTER_ADDRESS") {
         Ok(ConnectionBuilder::address(Address::try_from(address.as_str())?)?)
@@ -90,39 +106,43 @@ async fn wait_for_shutdown() -> Result<(), Box<dyn Error>> {
 }
 
 async fn run_daemon() -> Result<(), Box<dyn Error>> {
-    eprintln!("redbear-sessiond: startup begin");
+    wait_for_dbus_socket().await;
+
+    let mut last_err = None;
+    for attempt in 1..=5 {
         let session_path = parse_object_path(SESSION_PATH)?;
         let seat_path = parse_object_path(SEAT_PATH)?;
         let user_path = parse_object_path(USER_PATH)?;
-    eprintln!("redbear-sessiond: object paths parsed");
 
         let session = LoginSession::new(seat_path.clone(), user_path, DeviceMap::new());
         let seat = LoginSeat::new(session_path.clone());
         let manager = LoginManager::new(session_path, seat_path);
 
-    eprintln!("redbear-sessiond: starter address={:?}", env::var("DBUS_STARTER_ADDRESS").ok());
+        match system_connection_builder()?
-    eprintln!("redbear-sessiond: building D-Bus connection");
+            .name(BUS_NAME)?
-    let mut builder = system_connection_builder()?;
+            .serve_at(MANAGER_PATH, manager)?
-    eprintln!("redbear-sessiond: builder created");
+            .serve_at(SESSION_PATH, session)?
-    builder = builder.name(BUS_NAME)?;
+            .serve_at(SEAT_PATH, seat)?
-    eprintln!("redbear-sessiond: bus name reserved");
+            .build()
-    builder = builder.serve_at(MANAGER_PATH, manager)?;
+            .await
-    eprintln!("redbear-sessiond: served manager path {MANAGER_PATH}");
+        {
-    builder = builder.serve_at(SESSION_PATH, session)?;
+            Ok(connection) => {
-    eprintln!("redbear-sessiond: served session path {SESSION_PATH}");
-    builder = builder.serve_at(SEAT_PATH, seat)?;
-    eprintln!("redbear-sessiond: served seat path {SEAT_PATH}");
-    eprintln!("redbear-sessiond: finalizing connection build");
-    let connection = builder.build().await?;
-
                 eprintln!("redbear-sessiond: registered {BUS_NAME} on the system bus");
-
                 tokio::spawn(acpi_watcher::watch_and_emit(connection.clone()));
-
                 wait_for_shutdown().await?;
-    eprintln!("redbear-sessiond: received shutdown signal, exiting cleanly");
+                drop(connection);
-
+                return Ok(());
-    Ok(())
+            }
+            Err(err) => {
+                if attempt < 5 {
+                    eprintln!("redbear-sessiond: attempt {attempt}/5 failed ({err}), retrying in 2s...");
+                    tokio::time::sleep(Duration::from_secs(2)).await;
+                }
+                last_err = Some(err.into());
+            }
+        }
+    }
+    Err(last_err.unwrap())
 }
 
 fn main() {

local/recipes/system/redbear-udisks/source/src/inventory.rs

@@ -101,9 +101,7 @@ impl Inventory {
 
             for (root_key, entry_name) in roots {
                 let device_path = format!("{}/{entry_name}", scheme_path.display());
-                let Some(metadata) = read_device_metadata(Path::new(&device_path)) else {
+                let metadata = read_device_metadata(Path::new(&device_path));
-                    continue;
-                };
 
                 let drive = DriveDevice {
                     object_path: owned_object_path(&format!(
@@ -111,7 +109,7 @@ impl Inventory {
                         stable_object_name(&scheme_name, &entry_name)
                     )),
                     scheme_identity: scheme_identity.clone(),
-                    size: metadata.size,
+                    size: metadata.as_ref().map_or(0, |m| m.size),
                 };
 
                 drive_paths.insert(root_key, drive.object_path.clone());
@@ -123,9 +121,9 @@ impl Inventory {
                     )),
                     drive_object_path: drive.object_path.clone(),
                     device_path,
-                    size: metadata.size,
+                    size: metadata.as_ref().map_or(0, |m| m.size),
-                    logical_block_size: metadata.logical_block_size,
+                    logical_block_size: metadata.as_ref().map_or(0, |m| m.logical_block_size),
-                    read_only: metadata.read_only,
+                    read_only: metadata.as_ref().map_or(false, |m| m.read_only),
                     hint_partitionable: true,
                 });
 
@@ -141,9 +139,7 @@ impl Inventory {
                 };
 
                 let device_path = format!("{}/{entry_name}", scheme_path.display());
-                let Some(metadata) = read_device_metadata(Path::new(&device_path)) else {
+                let metadata = read_device_metadata(Path::new(&device_path));
-                    continue;
-                };
 
                 blocks.push(BlockDevice {
                     object_path: owned_object_path(&format!(
@@ -152,9 +148,9 @@ impl Inventory {
                     )),
                     drive_object_path: drive_object_path.clone(),
                     device_path,
-                    size: metadata.size,
+                    size: metadata.as_ref().map_or(0, |m| m.size),
-                    logical_block_size: metadata.logical_block_size,
+                    logical_block_size: metadata.as_ref().map_or(0, |m| m.logical_block_size),
-                    read_only: metadata.read_only,
+                    read_only: metadata.as_ref().map_or(false, |m| m.read_only),
                     hint_partitionable: false,
                 });
             }

local/recipes/system/redbear-udisks/source/src/main.rs

@@ -4,8 +4,11 @@ mod inventory;
 use std::{
     env,
     error::Error,
+    path::Path,
     process,
     sync::Arc,
+    thread,
+    time::Duration,
 };
 
 use interfaces::{BlockDeviceInterface, DriveInterface, ObjectManagerRoot, UDisksManager};
@@ -28,6 +31,21 @@ fn usage() -> &'static str {
     "Usage: redbear-udisks [--help]"
 }
 
+async fn wait_for_dbus_socket() {
+    let socket_path = env::var("DBUS_STARTER_ADDRESS")
+        .ok()
+        .and_then(|addr| addr.strip_prefix("unix:path=").map(String::from))
+        .unwrap_or_else(|| "/run/dbus/system_bus_socket".to_string());
+
+    for _ in 0..30 {
+        if tokio::net::UnixStream::connect(&socket_path).await.is_ok() {
+            return;
+        }
+        tokio::time::sleep(Duration::from_secs(1)).await;
+    }
+    eprintln!("redbear-udisks: timed out waiting for D-Bus socket at {socket_path}");
+}
+
 fn parse_args() -> Result<Command, String> {
     let mut args = env::args().skip(1);
 
@@ -82,24 +100,14 @@ async fn wait_for_shutdown() -> Result<(), Box<dyn Error>> {
 }
 
 async fn run_daemon() -> Result<(), Box<dyn Error>> {
-    eprintln!("redbear-udisks: startup begin");
+    wait_for_dbus_socket().await;
+
+    let mut last_err = None;
+    for attempt in 1..=5 {
         let _root_path = parse_object_path(ROOT_PATH)?;
         let _manager_path = parse_object_path(MANAGER_PATH)?;
-    eprintln!("redbear-udisks: object paths parsed");
         let inventory = Arc::new(Inventory::scan());
-    eprintln!(
-        "redbear-udisks: inventory scanned drives={} blocks={}",
-        inventory.drives().len(),
-        inventory.blocks().len()
-    );
-    let block_sizes_known = inventory
-        .blocks()
-        .iter()
-        .filter(|block| block.logical_block_size > 0)
-        .count();
 
-    eprintln!("redbear-udisks: starter address={:?}", env::var("DBUS_STARTER_ADDRESS").ok());
-    eprintln!("redbear-udisks: building D-Bus connection");
         let mut builder = system_connection_builder()?
             .name(BUS_NAME)?
             .serve_at(ROOT_PATH, ObjectManagerRoot::new(inventory.clone()))?
@@ -113,20 +121,27 @@ async fn run_daemon() -> Result<(), Box<dyn Error>> {
             builder = builder.serve_at(block.object_path.as_str(), BlockDeviceInterface::new(block.clone()))?;
         }
 
-    let connection = builder.build().await?;
+        match builder.build().await {
-
+            Ok(connection) => {
                 eprintln!(
-        "redbear-udisks: registered {BUS_NAME} on the system bus with {} drives, {} block devices, {} metadata-backed block sizes",
+                    "redbear-udisks: registered {BUS_NAME} on the system bus ({} drives, {} blocks)",
                     inventory.drives().len(),
                     inventory.blocks().len(),
-        block_sizes_known,
                 );
-
                 wait_for_shutdown().await?;
                 drop(connection);
-    eprintln!("redbear-udisks: received shutdown signal, exiting cleanly");
+                return Ok(());
-
+            }
-    Ok(())
+            Err(err) => {
+                if attempt < 5 {
+                    eprintln!("redbear-udisks: attempt {attempt}/5 failed ({err}), retrying in 2s...");
+                    tokio::time::sleep(Duration::from_secs(2)).await;
+                }
+                last_err = Some(err.into());
+            }
+        }
+    }
+    Err(last_err.unwrap())
 }
 
 fn main() {

local/recipes/system/redbear-upower/source/src/main.rs

@@ -4,6 +4,8 @@ use std::{
     fs,
     path::{Path, PathBuf},
     process,
+    thread,
+    time::Duration,
 };
 
 use tokio::runtime::Builder as RuntimeBuilder;
@@ -102,6 +104,21 @@ fn parse_args() -> Result<Command, String> {
     }
 }
 
+async fn wait_for_dbus_socket() {
+    let socket_path = env::var("DBUS_STARTER_ADDRESS")
+        .ok()
+        .and_then(|addr| addr.strip_prefix("unix:path=").map(String::from))
+        .unwrap_or_else(|| "/run/dbus/system_bus_socket".to_string());
+
+    for _ in 0..30 {
+        if tokio::net::UnixStream::connect(&socket_path).await.is_ok() {
+            return;
+        }
+        tokio::time::sleep(Duration::from_secs(1)).await;
+    }
+    eprintln!("redbear-upower: timed out waiting for D-Bus socket at {socket_path}");
+}
+
 fn parse_object_path(path: &str) -> Result<OwnedObjectPath, Box<dyn Error>> {
     Ok(OwnedObjectPath::try_from(path.to_owned())?)
 }
@@ -453,40 +470,29 @@ impl PowerDevice {
 }
 
 async fn run_daemon() -> Result<(), Box<dyn Error>> {
-    eprintln!("redbear-upower: startup begin");
+    wait_for_dbus_socket().await;
     let runtime = PowerRuntime::discover()?;
-    eprintln!(
-        "redbear-upower: runtime discovered adapters={} batteries={}",
-        runtime.adapter_ids.len(),
-        runtime.battery_ids.len()
-    );
     let _display_device_path = parse_object_path(DISPLAY_DEVICE_PATH)?;
-    eprintln!("redbear-upower: object paths parsed");
 
-    eprintln!("redbear-upower: starter address={:?}", env::var("DBUS_STARTER_ADDRESS").ok());
+    let mut last_err = None;
-    eprintln!("redbear-upower: building D-Bus connection");
+    for attempt in 1..=5 {
-    let mut builder = system_connection_builder()?;
+        let mut builder = system_connection_builder()?
-    eprintln!("redbear-upower: builder created");
+            .name(BUS_NAME)?
-    builder = builder.name(BUS_NAME)?;
+            .serve_at(
-    eprintln!("redbear-upower: bus name reserved");
-    builder = builder.serve_at(
                 UPOWER_PATH,
                 UPowerDaemon {
                     runtime: runtime.clone(),
                 },
-    )?;
+            )?
-    eprintln!("redbear-upower: served manager path {UPOWER_PATH}");
+            .serve_at(
-    builder = builder.serve_at(
                 DISPLAY_DEVICE_PATH,
                 DisplayDevice {
                     runtime: runtime.clone(),
                 },
             )?;
-    eprintln!("redbear-upower: served display device path {DISPLAY_DEVICE_PATH}");
 
         for adapter_id in &runtime.adapter_ids {
             let path = format!("/org/freedesktop/UPower/devices/line_power_{adapter_id}");
-        eprintln!("redbear-upower: serving adapter path {path}");
             builder = builder.serve_at(
                 path,
                 PowerDevice {
@@ -497,7 +503,6 @@ async fn run_daemon() -> Result<(), Box<dyn Error>> {
         }
         for battery_id in &runtime.battery_ids {
             let path = format!("/org/freedesktop/UPower/devices/battery_{battery_id}");
-        eprintln!("redbear-upower: serving battery path {path}");
             builder = builder.serve_at(
                 path,
                 PowerDevice {
@@ -507,16 +512,23 @@ async fn run_daemon() -> Result<(), Box<dyn Error>> {
             )?;
         }
 
-    eprintln!("redbear-upower: finalizing connection build");
+        match builder.build().await {
-    let connection = builder.build().await?;
+            Ok(connection) => {
-
                 eprintln!("redbear-upower: registered {BUS_NAME} on the system bus");
-
                 wait_for_shutdown().await?;
                 drop(connection);
-    eprintln!("redbear-upower: received shutdown signal, exiting cleanly");
+                return Ok(());
-
+            }
-    Ok(())
+            Err(err) => {
+                if attempt < 5 {
+                    eprintln!("redbear-upower: attempt {attempt}/5 failed ({err}), retrying in 2s...");
+                    tokio::time::sleep(Duration::from_secs(2)).await;
+                }
+                last_err = Some(err.into());
+            }
+        }
+    }
+    Err(last_err.unwrap())
 }
 
 fn main() {