use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use super::Result;
use crate::{
OwnedVariant, Type,
as_variant::optional,
names::{BusName, OwnedUniqueName},
proxy,
};
#[proxy(
interface = "org.freedesktop.DBus.Debug.Stats",
default_service = "org.freedesktop.DBus",
default_path = "/org/freedesktop/DBus"
)]
pub trait Stats {
fn get_stats(&self) -> Result<Stats>;
fn get_connection_stats(&self, name: BusName<'_>) -> Result<ConnectionStats>;
fn get_all_match_rules(&self) -> Result<HashMap<OwnedUniqueName, Vec<crate::OwnedMatchRule>>>;
}
#[derive(Debug, Default, Deserialize, PartialEq, Serialize, Type)]
#[zbus(signature = "a{sv}", rename_all = "PascalCase")]
#[serde(default, rename_all = "PascalCase")]
pub struct Stats {
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) serial: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) active_connections: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) incomplete_connections: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) match_rules: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) peak_match_rules: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) peak_match_rules_per_connection: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) bus_names: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) peak_bus_names: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) peak_bus_names_per_connection: Option<u32>,
#[serde(flatten)]
pub(crate) rest: HashMap<String, OwnedVariant>,
}
impl Stats {
pub fn serial(&self) -> Option<u32> {
self.serial
}
pub fn active_connections(&self) -> Option<u32> {
self.active_connections
}
pub fn incomplete_connections(&self) -> Option<u32> {
self.incomplete_connections
}
pub fn match_rules(&self) -> Option<u32> {
self.match_rules
}
pub fn peak_match_rules(&self) -> Option<u32> {
self.peak_match_rules
}
pub fn peak_match_rules_per_connection(&self) -> Option<u32> {
self.peak_match_rules_per_connection
}
pub fn bus_names(&self) -> Option<u32> {
self.bus_names
}
pub fn peak_bus_names(&self) -> Option<u32> {
self.peak_bus_names
}
pub fn peak_bus_names_per_connection(&self) -> Option<u32> {
self.peak_bus_names_per_connection
}
pub fn rest(&self) -> &HashMap<String, OwnedVariant> {
&self.rest
}
}
#[derive(Debug, Default, Deserialize, PartialEq, Serialize, Type)]
#[zbus(signature = "a{sv}")]
#[serde(default, rename_all = "PascalCase")]
pub struct ConnectionStats {
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) serial: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) unique_name: Option<OwnedUniqueName>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) match_rules: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) peak_match_rules: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) bus_names: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) peak_bus_names: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) incoming_messages: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) outgoing_messages: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) incoming_bytes: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) outgoing_bytes: Option<u32>,
#[serde(
rename = "IncomingFDs",
with = "optional",
skip_serializing_if = "Option::is_none"
)]
pub(crate) incoming_fds: Option<u32>,
#[serde(
rename = "OutgoingFDs",
with = "optional",
skip_serializing_if = "Option::is_none"
)]
pub(crate) outgoing_fds: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) peak_incoming_messages: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) peak_outgoing_messages: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) peak_incoming_bytes: Option<u32>,
#[serde(with = "optional", skip_serializing_if = "Option::is_none")]
pub(crate) peak_outgoing_bytes: Option<u32>,
#[serde(
rename = "PeakIncomingFDs",
with = "optional",
skip_serializing_if = "Option::is_none"
)]
pub(crate) peak_incoming_fds: Option<u32>,
#[serde(
rename = "PeakOutgoingFDs",
with = "optional",
skip_serializing_if = "Option::is_none"
)]
pub(crate) peak_outgoing_fds: Option<u32>,
#[serde(flatten)]
pub(crate) rest: HashMap<String, OwnedVariant>,
}
impl ConnectionStats {
pub fn serial(&self) -> Option<u32> {
self.serial
}
pub fn unique_name(&self) -> Option<&OwnedUniqueName> {
self.unique_name.as_ref()
}
pub fn match_rules(&self) -> Option<u32> {
self.match_rules
}
pub fn peak_match_rules(&self) -> Option<u32> {
self.peak_match_rules
}
pub fn bus_names(&self) -> Option<u32> {
self.bus_names
}
pub fn peak_bus_names(&self) -> Option<u32> {
self.peak_bus_names
}
pub fn incoming_messages(&self) -> Option<u32> {
self.incoming_messages
}
pub fn outgoing_messages(&self) -> Option<u32> {
self.outgoing_messages
}
pub fn incoming_bytes(&self) -> Option<u32> {
self.incoming_bytes
}
pub fn outgoing_bytes(&self) -> Option<u32> {
self.outgoing_bytes
}
pub fn incoming_fds(&self) -> Option<u32> {
self.incoming_fds
}
pub fn outgoing_fds(&self) -> Option<u32> {
self.outgoing_fds
}
pub fn peak_incoming_messages(&self) -> Option<u32> {
self.peak_incoming_messages
}
pub fn peak_outgoing_messages(&self) -> Option<u32> {
self.peak_outgoing_messages
}
pub fn peak_incoming_bytes(&self) -> Option<u32> {
self.peak_incoming_bytes
}
pub fn peak_outgoing_bytes(&self) -> Option<u32> {
self.peak_outgoing_bytes
}
pub fn peak_incoming_fds(&self) -> Option<u32> {
self.peak_incoming_fds
}
pub fn peak_outgoing_fds(&self) -> Option<u32> {
self.peak_outgoing_fds
}
pub fn rest(&self) -> &HashMap<String, OwnedVariant> {
&self.rest
}
}
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use super::ConnectionStats;
use crate::{
Variant,
wire::{LE, serialized::Context, to_bytes},
};
#[test]
fn connection_stats_read_the_entries_of_the_specification() {
let ctxt = Context::new(LE, 0);
let encoded = to_bytes(ctxt, &reply()).unwrap();
let stats: ConnectionStats = encoded.deserialize().unwrap().0;
assert_eq!(stats.serial(), Some(7));
assert_eq!(stats.unique_name().unwrap().as_str(), ":1.42");
assert_eq!(stats.incoming_messages(), Some(10));
assert_eq!(stats.incoming_bytes(), Some(11));
assert_eq!(stats.incoming_fds(), Some(12));
assert_eq!(stats.peak_incoming_bytes(), Some(13));
assert_eq!(stats.peak_incoming_fds(), Some(14));
assert_eq!(stats.outgoing_messages(), Some(20));
assert_eq!(stats.outgoing_bytes(), Some(21));
assert_eq!(stats.outgoing_fds(), Some(22));
assert_eq!(stats.peak_outgoing_bytes(), Some(23));
assert_eq!(stats.peak_outgoing_fds(), Some(24));
assert!(stats.rest().is_empty(), "{:?}", stats.rest());
}
#[test]
fn connection_stats_write_the_entries_of_the_specification() {
let stats = ConnectionStats {
incoming_fds: Some(1),
outgoing_fds: Some(2),
peak_incoming_fds: Some(3),
peak_outgoing_fds: Some(4),
..Default::default()
};
let ctxt = Context::new(LE, 0);
let encoded = to_bytes(ctxt, &stats).unwrap();
let entries: HashMap<String, u32> = encoded
.deserialize::<HashMap<String, Variant<'_>>>()
.unwrap()
.0
.into_iter()
.map(|(name, value)| (name, u32::try_from(value).unwrap()))
.collect();
assert_eq!(
entries,
HashMap::from([
("IncomingFDs".to_string(), 1),
("OutgoingFDs".to_string(), 2),
("PeakIncomingFDs".to_string(), 3),
("PeakOutgoingFDs".to_string(), 4),
])
);
}
fn reply() -> HashMap<&'static str, Variant<'static>> {
HashMap::from([
("Serial", Variant::from(7u32)),
("UniqueName", Variant::from(":1.42")),
("MatchRules", Variant::from(3u32)),
("PeakMatchRules", Variant::from(4u32)),
("BusNames", Variant::from(1u32)),
("PeakBusNames", Variant::from(2u32)),
("IncomingMessages", Variant::from(10u32)),
("IncomingBytes", Variant::from(11u32)),
("IncomingFDs", Variant::from(12u32)),
("PeakIncomingBytes", Variant::from(13u32)),
("PeakIncomingFDs", Variant::from(14u32)),
("OutgoingMessages", Variant::from(20u32)),
("OutgoingBytes", Variant::from(21u32)),
("OutgoingFDs", Variant::from(22u32)),
("PeakOutgoingBytes", Variant::from(23u32)),
("PeakOutgoingFDs", Variant::from(24u32)),
])
}
}