zedfrigg/ironbar
1
0
Fork 0
mirror of https://github.com/Zedfrigg/ironbar.git synced 2025-09-15 19:26:58 +02:00
Code Activity

WIP update of networkmanager & volume modules

Browse source
This commit is contained in:
Reinout Meliesie 2025-08-10 16:37:55 +02:00
commit 26686739a0
Signed by: zedfrigg
GPG key ID: 3AFCC06481308BC6
5 changed files with 323 additions and 522 deletions
Download patch file Download diff file Expand all files Collapse all files

334
src/clients/networkmanager/mod.rs
View file

@ -2,17 +2,16 @@ use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use color_eyre::Result;
use futures_lite::StreamExt;
use futures_signals::signal::{Mutable, MutableSignalCloned};
use tracing::error;
use zbus::blocking::Connection;
use zbus::Connection;
use zbus::zvariant::ObjectPath;
use crate::clients::networkmanager::dbus::{
ActiveConnectionDbusProxyBlocking, DbusProxyBlocking, DeviceDbusProxyBlocking,
};
use crate::clients::networkmanager::dbus::{ActiveConnectionDbusProxy, DbusProxy, DeviceDbusProxy};
use crate::clients::networkmanager::state::{
determine_cellular_state, determine_vpn_state, determine_wifi_state, determine_wired_state,
CellularState, State, VpnState, WifiState, WiredState,
CellularState, State, VpnState, WifiState, WiredState, determine_cellular_state,
determine_vpn_state, determine_wifi_state, determine_wired_state,
};
use crate::{
read_lock, register_fallible_client, spawn_blocking, spawn_blocking_result, write_lock,
@ -29,23 +28,23 @@ pub struct Client(Arc<ClientInner<'static>>);
#[derive(Debug)]
struct ClientInner<'l> {
state: Mutable<State>,
root_object: &'l DbusProxyBlocking<'l>,
active_connections: RwLock<PathMap<'l, ActiveConnectionDbusProxyBlocking<'l>>>,
devices: RwLock<PathMap<'l, DeviceDbusProxyBlocking<'l>>>,
root_object: &'l DbusProxy<'l>,
active_connections: RwLock<PathMap<'l, ActiveConnectionDbusProxy<'l>>>,
devices: RwLock<PathMap<'l, DeviceDbusProxy<'l>>>,
dbus_connection: Connection,
}
impl Client {
fn new() -> Result<Client> {
async fn new() -> Result<Client> {
let state = Mutable::new(State {
wired: WiredState::Unknown,
wifi: WifiState::Unknown,
cellular: CellularState::Unknown,
vpn: VpnState::Unknown,
});
let dbus_connection = Connection::system()?;
let dbus_connection = Connection::system().await?;
let root_object = {
let root_object = DbusProxyBlocking::new(&dbus_connection)?;
let root_object = DbusProxy::new(&dbus_connection).await?;
// Workaround for the fact that zbus (unnecessarily) requires a static lifetime here
Box::leak(Box::new(root_object))
};
@ -59,158 +58,159 @@ impl Client {
})))
}
fn run(&self) -> Result<()> {
macro_rules! update_state_for_device_change {
($client:ident) => {
$client.state.set(State {
wired: determine_wired_state(&read_lock!($client.devices))?,
wifi: determine_wifi_state(&read_lock!($client.devices))?,
cellular: determine_cellular_state(&read_lock!($client.devices))?,
vpn: $client.state.get_cloned().vpn,
});
};
async fn run(&self) -> Result<()> {
// TODO: Reimplement DBus watching without these write-only macros
let mut active_connections_stream = self.0.root_object.receive_active_connections_changed().await;
while let Some(change) = active_connections_stream.next().await {
}
macro_rules! initialise_path_map {
(
$client:expr,
$path_map:ident,
$proxy_type:ident
$(, |$new_path:ident| $property_watcher:expr)*
) => {
let new_paths = $client.root_object.$path_map()?;
let mut path_map = HashMap::new();
for new_path in new_paths {
let new_proxy = $proxy_type::builder(&$client.dbus_connection)
.path(new_path.clone())?
.build()?;
path_map.insert(new_path.clone(), new_proxy);
$({
let $new_path = &new_path;
$property_watcher;
})*
}
*write_lock!($client.$path_map) = path_map;
};
}
// ActiveConnectionDbusProxy::builder(&self.0.dbus_connection)
macro_rules! spawn_path_list_watcher {
(
$client:expr,
$property:ident,
$property_changes:ident,
$proxy_type:ident,
|$state_client:ident| $state_update:expr
$(, |$property_client:ident, $new_path:ident| $property_watcher:expr)*
) => {
let client = $client.clone();
spawn_blocking_result!({
let changes = client.root_object.$property_changes();
for _ in changes {
let mut new_path_map = HashMap::new();
{
let new_paths = client.root_object.$property()?;
let path_map = read_lock!(client.$property);
for new_path in new_paths {
if path_map.contains_key(&new_path) {
let proxy = path_map
.get(&new_path)
.expect("Should contain the key, guarded by runtime check");
new_path_map.insert(new_path, proxy.to_owned());
} else {
let new_proxy = $proxy_type::builder(&client.dbus_connection)
.path(new_path.clone())?
.build()?;
new_path_map.insert(new_path.clone(), new_proxy);
$({
let $property_client = &client;
let $new_path = &new_path;
$property_watcher;
})*
}
}
}
*write_lock!(client.$property) = new_path_map;
let $state_client = &client;
$state_update;
}
Ok(())
});
}
}
macro_rules! spawn_property_watcher {
(
$client:expr,
$path:expr,
$property_changes:ident,
$containing_list:ident,
|$inner_client:ident| $state_update:expr
) => {
let client = $client.clone();
let path = $path.clone();
spawn_blocking_result!({
let changes = read_lock!(client.$containing_list)
.get(&path)
.expect("Should contain the key upon watcher start")
.$property_changes();
for _ in changes {
if !read_lock!(client.$containing_list).contains_key(&path) {
break;
}
let $inner_client = &client;
$state_update;
}
Ok(())
});
};
}
initialise_path_map!(
self.0,
active_connections,
ActiveConnectionDbusProxyBlocking
);
initialise_path_map!(self.0, devices, DeviceDbusProxyBlocking, |path| {
spawn_property_watcher!(self.0, path, receive_state_changed, devices, |client| {
update_state_for_device_change!(client);
});
});
self.0.state.set(State {
wired: determine_wired_state(&read_lock!(self.0.devices))?,
wifi: determine_wifi_state(&read_lock!(self.0.devices))?,
cellular: determine_cellular_state(&read_lock!(self.0.devices))?,
vpn: determine_vpn_state(&read_lock!(self.0.active_connections))?,
});
spawn_path_list_watcher!(
self.0,
active_connections,
receive_active_connections_changed,
ActiveConnectionDbusProxyBlocking,
|client| {
client.state.set(State {
wired: client.state.get_cloned().wired,
wifi: client.state.get_cloned().wifi,
cellular: client.state.get_cloned().cellular,
vpn: determine_vpn_state(&read_lock!(client.active_connections))?,
});
}
);
spawn_path_list_watcher!(
self.0,
devices,
receive_devices_changed,
DeviceDbusProxyBlocking,
|client| {
update_state_for_device_change!(client);
},
|client, path| {
spawn_property_watcher!(client, path, receive_state_changed, devices, |client| {
update_state_for_device_change!(client);
});
}
);
// macro_rules! update_state_for_device_change {
// ($client:ident) => {
// $client.state.set(State {
// wired: determine_wired_state(&read_lock!($client.devices)).await?,
// wifi: determine_wifi_state(&read_lock!($client.devices)).await?,
// cellular: determine_cellular_state(&read_lock!($client.devices)).await?,
// vpn: $client.state.get_cloned().vpn,
// });
// };
// }
//
// macro_rules! initialise_path_map {
// (
// $client:expr,
// $path_map:ident,
// $proxy_type:ident
// $(, |$new_path:ident| $property_watcher:expr)*
// ) => {
// let new_paths = $client.root_object.$path_map().await?;
// let mut path_map = HashMap::new();
// for new_path in new_paths {
// let new_proxy = $proxy_type::builder(&$client.dbus_connection)
// .path(new_path.clone())?
// .build().await?;
// path_map.insert(new_path.clone(), new_proxy);
// $({
// let $new_path = &new_path;
// $property_watcher;
// })*
// }
// *write_lock!($client.$path_map) = path_map;
// };
// }
//
// macro_rules! spawn_path_list_watcher {
// (
// $client:expr,
// $property:ident,
// $property_changes:ident,
// $proxy_type:ident,
// |$state_client:ident| $state_update:expr
// $(, |$property_client:ident, $new_path:ident| $property_watcher:expr)*
// ) => {
// let client = $client.clone();
//
// let changes = client.root_object.$property_changes();
// for _ in changes {
// let mut new_path_map = HashMap::new();
// {
// let new_paths = client.root_object.$property()?;
// let path_map = read_lock!(client.$property);
// for new_path in new_paths {
// if path_map.contains_key(&new_path) {
// let proxy = path_map
// .get(&new_path)
// .expect("Should contain the key, guarded by runtime check");
// new_path_map.insert(new_path, proxy.to_owned());
// } else {
// let new_proxy = $proxy_type::builder(&client.dbus_connection)
// .path(new_path.clone())?
// .build()?;
// new_path_map.insert(new_path.clone(), new_proxy);
// $({
// let $property_client = &client;
// let $new_path = &new_path;
// $property_watcher;
// })*
// }
// }
// }
// *write_lock!(client.$property) = new_path_map;
// let $state_client = &client;
// $state_update;
// }
// }
// }
//
// macro_rules! spawn_property_watcher {
// (
// $client:expr,
// $path:expr,
// $property_changes:ident,
// $containing_list:ident,
// |$inner_client:ident| $state_update:expr
// ) => {
// let client = $client.clone();
// let path = $path.clone();
//
// let changes = read_lock!(client.$containing_list)
// .get(&path)
// .expect("Should contain the key upon watcher start")
// .$property_changes().await;
// for _ in changes {
// if !read_lock!(client.$containing_list).contains_key(&path) {
// break;
// }
// let $inner_client = &client;
// $state_update;
// }
// };
// }
//
// initialise_path_map!(self.0, active_connections, ActiveConnectionDbusProxy);
// initialise_path_map!(self.0, devices, DeviceDbusProxy, |path| {
// spawn_property_watcher!(self.0, path, receive_state_changed, devices, |client| {
// update_state_for_device_change!(client);
// });
// });
// self.0.state.set(State {
// wired: determine_wired_state(&read_lock!(self.0.devices))?,
// wifi: determine_wifi_state(&read_lock!(self.0.devices))?,
// cellular: determine_cellular_state(&read_lock!(self.0.devices))?,
// vpn: determine_vpn_state(&read_lock!(self.0.active_connections))?,
// });
//
// spawn_path_list_watcher!(
// self.0,
// active_connections,
// receive_active_connections_changed,
// ActiveConnectionDbusProxy,
// |client| {
// client.state.set(State {
// wired: client.state.get_cloned().wired,
// wifi: client.state.get_cloned().wifi,
// cellular: client.state.get_cloned().cellular,
// vpn: determine_vpn_state(&read_lock!(client.active_connections))?,
// });
// }
// );
// spawn_path_list_watcher!(
// self.0,
// devices,
// receive_devices_changed,
// DeviceDbusProxy,
// |client| {
// update_state_for_device_change!(client);
// },
// |client, path| {
// spawn_property_watcher!(client, path, receive_state_changed, devices, |client| {
// update_state_for_device_change!(client);
// });
// }
// );
Ok(())
}
@ -220,15 +220,9 @@ impl Client {
}
}
pub fn create_client() -> Result<Arc<Client>> {
let client = Arc::new(Client::new()?);
{
let client = client.clone();
spawn_blocking_result!({
client.run()?;
Ok(())
});
}
pub async fn create_client() -> Result<Arc<Client>> {
let client = Arc::new(Client::new().await?);
client.run().await?;
Ok(client)
}