mirror of
https://github.com/Zedfrigg/ironbar.git
synced 2025-09-16 03:36:58 +02:00
WIP update of networkmanager & volume modules
This commit is contained in:
parent
c42024d48a
commit
26686739a0
GPG key ID:
3AFCC06481308BC6
5 changed files with 323 additions and 522 deletions
|
|
@ -1,71 +1,71 @@
|
|||
use color_eyre::Result;
|
||||
use zbus::dbus_proxy;
|
||||
use zbus::proxy;
|
||||
use zbus::zvariant::{ObjectPath, OwnedValue, Str};
|
||||
|
||||
#[dbus_proxy(
|
||||
#[proxy(
|
||||
default_service = "org.freedesktop.NetworkManager",
|
||||
interface = "org.freedesktop.NetworkManager",
|
||||
default_path = "/org/freedesktop/NetworkManager"
|
||||
)]
|
||||
trait Dbus {
|
||||
#[dbus_proxy(property)]
|
||||
pub(super) trait Dbus {
|
||||
#[zbus(property)]
|
||||
fn active_connections(&self) -> Result<Vec<ObjectPath>>;
|
||||
|
||||
#[dbus_proxy(property)]
|
||||
#[zbus(property)]
|
||||
fn devices(&self) -> Result<Vec<ObjectPath>>;
|
||||
|
||||
// #[dbus_proxy(property)]
|
||||
// #[zbus(property)]
|
||||
// fn networking_enabled(&self) -> Result<bool>;
|
||||
|
||||
// #[dbus_proxy(property)]
|
||||
// #[zbus(property)]
|
||||
// fn primary_connection(&self) -> Result<ObjectPath>;
|
||||
|
||||
// #[dbus_proxy(property)]
|
||||
// #[zbus(property)]
|
||||
// fn primary_connection_type(&self) -> Result<Str>;
|
||||
|
||||
// #[dbus_proxy(property)]
|
||||
// #[zbus(property)]
|
||||
// fn wireless_enabled(&self) -> Result<bool>;
|
||||
}
|
||||
|
||||
#[dbus_proxy(
|
||||
#[proxy(
|
||||
default_service = "org.freedesktop.NetworkManager",
|
||||
interface = "org.freedesktop.NetworkManager.Connection.Active"
|
||||
)]
|
||||
trait ActiveConnectionDbus {
|
||||
// #[dbus_proxy(property)]
|
||||
pub(super) trait ActiveConnectionDbus {
|
||||
// #[zbus(property)]
|
||||
// fn connection(&self) -> Result<ObjectPath>;
|
||||
|
||||
// #[dbus_proxy(property)]
|
||||
// #[zbus(property)]
|
||||
// fn default(&self) -> Result<bool>;
|
||||
|
||||
// #[dbus_proxy(property)]
|
||||
// #[zbus(property)]
|
||||
// fn default6(&self) -> Result<bool>;
|
||||
|
||||
#[dbus_proxy(property)]
|
||||
#[zbus(property)]
|
||||
fn devices(&self) -> Result<Vec<ObjectPath>>;
|
||||
|
||||
// #[dbus_proxy(property)]
|
||||
// #[zbus(property)]
|
||||
// fn id(&self) -> Result<Str>;
|
||||
|
||||
#[dbus_proxy(property)]
|
||||
#[zbus(property)]
|
||||
fn type_(&self) -> Result<Str>;
|
||||
|
||||
// #[dbus_proxy(property)]
|
||||
// #[zbus(property)]
|
||||
// fn uuid(&self) -> Result<Str>;
|
||||
}
|
||||
|
||||
#[dbus_proxy(
|
||||
#[proxy(
|
||||
default_service = "org.freedesktop.NetworkManager",
|
||||
interface = "org.freedesktop.NetworkManager.Device"
|
||||
)]
|
||||
trait DeviceDbus {
|
||||
// #[dbus_proxy(property)]
|
||||
pub(super) trait DeviceDbus {
|
||||
// #[zbus(property)]
|
||||
// fn active_connection(&self) -> Result<ObjectPath>;
|
||||
|
||||
#[dbus_proxy(property)]
|
||||
#[zbus(property)]
|
||||
fn device_type(&self) -> Result<DeviceType>;
|
||||
|
||||
#[dbus_proxy(property)]
|
||||
#[zbus(property)]
|
||||
fn state(&self) -> Result<DeviceState>;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
use color_eyre::Result;
|
||||
|
||||
use crate::clients::networkmanager::dbus::{
|
||||
ActiveConnectionDbusProxyBlocking, DeviceDbusProxyBlocking, DeviceState, DeviceType,
|
||||
};
|
||||
use crate::clients::networkmanager::PathMap;
|
||||
use crate::clients::networkmanager::dbus::{
|
||||
ActiveConnectionDbusProxy, DeviceDbusProxy, DeviceState, DeviceType,
|
||||
};
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct State {
|
||||
|
|
@ -56,16 +56,16 @@ pub struct VpnConnectedState {
|
|||
pub name: String,
|
||||
}
|
||||
|
||||
pub(super) fn determine_wired_state(
|
||||
devices: &PathMap<DeviceDbusProxyBlocking>,
|
||||
pub(super) async fn determine_wired_state(
|
||||
devices: &PathMap<'_, DeviceDbusProxy<'_>>,
|
||||
) -> Result<WiredState> {
|
||||
let mut present = false;
|
||||
let mut connected = false;
|
||||
|
||||
for device in devices.values() {
|
||||
if device.device_type()? == DeviceType::Ethernet {
|
||||
if device.device_type().await? == DeviceType::Ethernet {
|
||||
present = true;
|
||||
if device.state()?.is_enabled() {
|
||||
if device.state().await?.is_enabled() {
|
||||
connected = true;
|
||||
break;
|
||||
}
|
||||
|
|
@ -81,19 +81,19 @@ pub(super) fn determine_wired_state(
|
|||
}
|
||||
}
|
||||
|
||||
pub(super) fn determine_wifi_state(
|
||||
devices: &PathMap<DeviceDbusProxyBlocking>,
|
||||
pub(super) async fn determine_wifi_state(
|
||||
devices: &PathMap<'_, DeviceDbusProxy<'_>>,
|
||||
) -> Result<WifiState> {
|
||||
let mut present = false;
|
||||
let mut enabled = false;
|
||||
let mut connected = false;
|
||||
|
||||
for device in devices.values() {
|
||||
if device.device_type()? == DeviceType::Wifi {
|
||||
if device.device_type().await? == DeviceType::Wifi {
|
||||
present = true;
|
||||
if device.state()?.is_enabled() {
|
||||
if device.state().await?.is_enabled() {
|
||||
enabled = true;
|
||||
if device.state()? == DeviceState::Activated {
|
||||
if device.state().await? == DeviceState::Activated {
|
||||
connected = true;
|
||||
break;
|
||||
}
|
||||
|
|
@ -115,19 +115,19 @@ pub(super) fn determine_wifi_state(
|
|||
}
|
||||
}
|
||||
|
||||
pub(super) fn determine_cellular_state(
|
||||
devices: &PathMap<DeviceDbusProxyBlocking>,
|
||||
pub(super) async fn determine_cellular_state(
|
||||
devices: &PathMap<'_, DeviceDbusProxy<'_>>,
|
||||
) -> Result<CellularState> {
|
||||
let mut present = false;
|
||||
let mut enabled = false;
|
||||
let mut connected = false;
|
||||
|
||||
for device in devices.values() {
|
||||
if device.device_type()? == DeviceType::Modem {
|
||||
if device.device_type().await? == DeviceType::Modem {
|
||||
present = true;
|
||||
if device.state()?.is_enabled() {
|
||||
if device.state().await?.is_enabled() {
|
||||
enabled = true;
|
||||
if device.state()? == DeviceState::Activated {
|
||||
if device.state().await? == DeviceState::Activated {
|
||||
connected = true;
|
||||
break;
|
||||
}
|
||||
|
|
@ -146,11 +146,11 @@ pub(super) fn determine_cellular_state(
|
|||
}
|
||||
}
|
||||
|
||||
pub(super) fn determine_vpn_state(
|
||||
active_connections: &PathMap<ActiveConnectionDbusProxyBlocking>,
|
||||
pub(super) async fn determine_vpn_state(
|
||||
active_connections: &PathMap<'_, ActiveConnectionDbusProxy<'_>>,
|
||||
) -> Result<VpnState> {
|
||||
for connection in active_connections.values() {
|
||||
match connection.type_()?.as_str() {
|
||||
match connection.type_().await?.as_str() {
|
||||
"vpn" | "wireguard" => {
|
||||
return Ok(VpnState::Connected(VpnConnectedState {
|
||||
name: "unknown".into(),
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue