Struct SocketProxy

pub struct SocketProxy<'p>(/* private fields */);

Implementations

impl<'p> SocketProxy<'p>

pub async fn new<P>(conn: &Connection, path: P) -> Result<SocketProxy<'p>>

where P: TryInto<ObjectPath<'p>>, P::Error: Into<Error>,

Creates a new proxy with the given path, and the default destination.

pub fn builder(conn: &Connection) -> Builder<'p, Self>

Returns a customizable builder for this proxy.

pub fn into_inner(self) -> Proxy<'p>

Consumes self, returning the underlying zbus::Proxy.

pub fn inner(&self) -> &Proxy<'p>

The reference to the underlying zbus::Proxy.

pub fn inner_mut(&mut self) -> &mut Proxy<'p>

The mutable reference to the underlying zbus::Proxy.

pub async fn attach_processes( &self, subcgroup: &str, pids: &[u32], ) -> Result<()>

AttachProcesses method

pub async fn get_processes(&self) -> Result<Vec<Process>>

GetProcesses method

pub async fn accept(&self) -> Result<bool>

Accept property

pub fn cached_accept( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Accept property Get the cached value of the Accept property, or None if the property is not cached.

pub async fn receive_accept_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Accept property Create a stream for the Accept property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn allowed_cpus(&self) -> Result<Vec<u8>>

AllowedCPUs property

pub fn cached_allowed_cpus( &self, ) -> Result<Option<<Result<Vec<u8>> as ResultAdapter>::Ok>, <Result<Vec<u8>> as ResultAdapter>::Err>

AllowedCPUs property Get the cached value of the AllowedCPUs property, or None if the property is not cached.

pub async fn receive_allowed_cpus_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

AllowedCPUs property Create a stream for the AllowedCPUs property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn allowed_memory_nodes(&self) -> Result<Vec<u8>>

AllowedMemoryNodes property

pub fn cached_allowed_memory_nodes( &self, ) -> Result<Option<<Result<Vec<u8>> as ResultAdapter>::Ok>, <Result<Vec<u8>> as ResultAdapter>::Err>

AllowedMemoryNodes property Get the cached value of the AllowedMemoryNodes property, or None if the property is not cached.

pub async fn receive_allowed_memory_nodes_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

AllowedMemoryNodes property Create a stream for the AllowedMemoryNodes property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ambient_capabilities(&self) -> Result<u64>

AmbientCapabilities property

pub fn cached_ambient_capabilities( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

AmbientCapabilities property Get the cached value of the AmbientCapabilities property, or None if the property is not cached.

pub async fn receive_ambient_capabilities_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

AmbientCapabilities property Create a stream for the AmbientCapabilities property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn app_armor_profile(&self) -> Result<(bool, String)>

AppArmorProfile property

pub fn cached_app_armor_profile( &self, ) -> Result<Option<<Result<(bool, String)> as ResultAdapter>::Ok>, <Result<(bool, String)> as ResultAdapter>::Err>

AppArmorProfile property Get the cached value of the AppArmorProfile property, or None if the property is not cached.

pub async fn receive_app_armor_profile_changed( &self, ) -> PropertyStream<'p, <Result<(bool, String)> as ResultAdapter>::Ok>

AppArmorProfile property Create a stream for the AppArmorProfile property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn bpf_program(&self) -> Result<Vec<(String, String)>>

BPFProgram property

pub fn cached_bpf_program( &self, ) -> Result<Option<<Result<Vec<(String, String)>> as ResultAdapter>::Ok>, <Result<Vec<(String, String)>> as ResultAdapter>::Err>

BPFProgram property Get the cached value of the BPFProgram property, or None if the property is not cached.

pub async fn receive_bpf_program_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

BPFProgram property Create a stream for the BPFProgram property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn backlog(&self) -> Result<u32>

Backlog property

pub fn cached_backlog( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

Backlog property Get the cached value of the Backlog property, or None if the property is not cached.

pub async fn receive_backlog_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

Backlog property Create a stream for the Backlog property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn bind_ipv6_only(&self) -> Result<String>

BindIPv6Only property

pub fn cached_bind_ipv6_only( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

BindIPv6Only property Get the cached value of the BindIPv6Only property, or None if the property is not cached.

pub async fn receive_bind_ipv6_only_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

BindIPv6Only property Create a stream for the BindIPv6Only property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn bind_paths(&self) -> Result<Vec<(String, String, bool, u64)>>

BindPaths property

pub fn cached_bind_paths( &self, ) -> Result<Option<<Result<Vec<(String, String, bool, u64)>> as ResultAdapter>::Ok>, <Result<Vec<(String, String, bool, u64)>> as ResultAdapter>::Err>

BindPaths property Get the cached value of the BindPaths property, or None if the property is not cached.

pub async fn receive_bind_paths_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, String, bool, u64)>> as ResultAdapter>::Ok>

BindPaths property Create a stream for the BindPaths property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn bind_read_only_paths( &self, ) -> Result<Vec<(String, String, bool, u64)>>

BindReadOnlyPaths property

pub fn cached_bind_read_only_paths( &self, ) -> Result<Option<<Result<Vec<(String, String, bool, u64)>> as ResultAdapter>::Ok>, <Result<Vec<(String, String, bool, u64)>> as ResultAdapter>::Err>

BindReadOnlyPaths property Get the cached value of the BindReadOnlyPaths property, or None if the property is not cached.

pub async fn receive_bind_read_only_paths_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, String, bool, u64)>> as ResultAdapter>::Ok>

BindReadOnlyPaths property Create a stream for the BindReadOnlyPaths property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn bind_to_device(&self) -> Result<String>

BindToDevice property

pub fn cached_bind_to_device( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

BindToDevice property Get the cached value of the BindToDevice property, or None if the property is not cached.

pub async fn receive_bind_to_device_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

BindToDevice property Create a stream for the BindToDevice property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn block_io_accounting(&self) -> Result<bool>

BlockIOAccounting property

pub fn cached_block_io_accounting( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

BlockIOAccounting property Get the cached value of the BlockIOAccounting property, or None if the property is not cached.

pub async fn receive_block_io_accounting_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

BlockIOAccounting property Create a stream for the BlockIOAccounting property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn block_io_device_weight(&self) -> Result<Vec<(String, u64)>>

BlockIODeviceWeight property

pub fn cached_block_io_device_weight( &self, ) -> Result<Option<<Result<Vec<(String, u64)>> as ResultAdapter>::Ok>, <Result<Vec<(String, u64)>> as ResultAdapter>::Err>

BlockIODeviceWeight property Get the cached value of the BlockIODeviceWeight property, or None if the property is not cached.

pub async fn receive_block_io_device_weight_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

BlockIODeviceWeight property Create a stream for the BlockIODeviceWeight property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn block_io_read_bandwidth(&self) -> Result<Vec<(String, u64)>>

BlockIOReadBandwidth property

pub fn cached_block_io_read_bandwidth( &self, ) -> Result<Option<<Result<Vec<(String, u64)>> as ResultAdapter>::Ok>, <Result<Vec<(String, u64)>> as ResultAdapter>::Err>

BlockIOReadBandwidth property Get the cached value of the BlockIOReadBandwidth property, or None if the property is not cached.

pub async fn receive_block_io_read_bandwidth_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

BlockIOReadBandwidth property Create a stream for the BlockIOReadBandwidth property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn block_io_weight(&self) -> Result<u64>

BlockIOWeight property

pub fn cached_block_io_weight( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

BlockIOWeight property Get the cached value of the BlockIOWeight property, or None if the property is not cached.

pub async fn receive_block_io_weight_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

BlockIOWeight property Create a stream for the BlockIOWeight property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn block_io_write_bandwidth(&self) -> Result<Vec<(String, u64)>>

BlockIOWriteBandwidth property

pub fn cached_block_io_write_bandwidth( &self, ) -> Result<Option<<Result<Vec<(String, u64)>> as ResultAdapter>::Ok>, <Result<Vec<(String, u64)>> as ResultAdapter>::Err>

BlockIOWriteBandwidth property Get the cached value of the BlockIOWriteBandwidth property, or None if the property is not cached.

pub async fn receive_block_io_write_bandwidth_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

BlockIOWriteBandwidth property Create a stream for the BlockIOWriteBandwidth property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn broadcast(&self) -> Result<bool>

Broadcast property

pub fn cached_broadcast( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Broadcast property Get the cached value of the Broadcast property, or None if the property is not cached.

pub async fn receive_broadcast_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Broadcast property Create a stream for the Broadcast property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cpu_accounting(&self) -> Result<bool>

CPUAccounting property

pub fn cached_cpu_accounting( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

CPUAccounting property Get the cached value of the CPUAccounting property, or None if the property is not cached.

pub async fn receive_cpu_accounting_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

CPUAccounting property Create a stream for the CPUAccounting property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cpu_affinity(&self) -> Result<Vec<u8>>

CPUAffinity property

pub fn cached_cpu_affinity( &self, ) -> Result<Option<<Result<Vec<u8>> as ResultAdapter>::Ok>, <Result<Vec<u8>> as ResultAdapter>::Err>

CPUAffinity property Get the cached value of the CPUAffinity property, or None if the property is not cached.

pub async fn receive_cpu_affinity_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

CPUAffinity property Create a stream for the CPUAffinity property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cpu_affinity_from_numa(&self) -> Result<bool>

CPUAffinityFromNUMA property

pub fn cached_cpu_affinity_from_numa( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

CPUAffinityFromNUMA property Get the cached value of the CPUAffinityFromNUMA property, or None if the property is not cached.

pub async fn receive_cpu_affinity_from_numa_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

CPUAffinityFromNUMA property Create a stream for the CPUAffinityFromNUMA property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cpu_quota_per_sec_usec(&self) -> Result<u64>

CPUQuotaPerSecUSec property

pub fn cached_cpu_quota_per_sec_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

CPUQuotaPerSecUSec property Get the cached value of the CPUQuotaPerSecUSec property, or None if the property is not cached.

pub async fn receive_cpu_quota_per_sec_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

CPUQuotaPerSecUSec property Create a stream for the CPUQuotaPerSecUSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cpu_quota_period_usec(&self) -> Result<u64>

CPUQuotaPeriodUSec property

pub fn cached_cpu_quota_period_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

CPUQuotaPeriodUSec property Get the cached value of the CPUQuotaPeriodUSec property, or None if the property is not cached.

pub async fn receive_cpu_quota_period_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

CPUQuotaPeriodUSec property Create a stream for the CPUQuotaPeriodUSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cpu_scheduling_policy(&self) -> Result<i32>

CPUSchedulingPolicy property

pub fn cached_cpu_scheduling_policy( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

CPUSchedulingPolicy property Get the cached value of the CPUSchedulingPolicy property, or None if the property is not cached.

pub async fn receive_cpu_scheduling_policy_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

CPUSchedulingPolicy property Create a stream for the CPUSchedulingPolicy property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cpu_scheduling_priority(&self) -> Result<i32>

CPUSchedulingPriority property

pub fn cached_cpu_scheduling_priority( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

CPUSchedulingPriority property Get the cached value of the CPUSchedulingPriority property, or None if the property is not cached.

pub async fn receive_cpu_scheduling_priority_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

CPUSchedulingPriority property Create a stream for the CPUSchedulingPriority property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cpu_scheduling_reset_on_fork(&self) -> Result<bool>

CPUSchedulingResetOnFork property

pub fn cached_cpu_scheduling_reset_on_fork( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

CPUSchedulingResetOnFork property Get the cached value of the CPUSchedulingResetOnFork property, or None if the property is not cached.

pub async fn receive_cpu_scheduling_reset_on_fork_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

CPUSchedulingResetOnFork property Create a stream for the CPUSchedulingResetOnFork property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cpu_shares(&self) -> Result<u64>

CPUShares property

pub fn cached_cpu_shares( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

CPUShares property Get the cached value of the CPUShares property, or None if the property is not cached.

pub async fn receive_cpu_shares_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

CPUShares property Create a stream for the CPUShares property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cpu_usage_nsec(&self) -> Result<u64>

CPUUsageNSec property

pub fn cached_cpu_usage_nsec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

CPUUsageNSec property Get the cached value of the CPUUsageNSec property, or None if the property is not cached.

pub async fn receive_cpu_usage_nsec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

CPUUsageNSec property Create a stream for the CPUUsageNSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cpu_weight(&self) -> Result<u64>

CPUWeight property

pub fn cached_cpu_weight( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

CPUWeight property Get the cached value of the CPUWeight property, or None if the property is not cached.

pub async fn receive_cpu_weight_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

CPUWeight property Create a stream for the CPUWeight property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cache_directory(&self) -> Result<Vec<String>>

CacheDirectory property

pub fn cached_cache_directory( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

CacheDirectory property Get the cached value of the CacheDirectory property, or None if the property is not cached.

pub async fn receive_cache_directory_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

CacheDirectory property Create a stream for the CacheDirectory property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cache_directory_mode(&self) -> Result<u32>

CacheDirectoryMode property

pub fn cached_cache_directory_mode( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

CacheDirectoryMode property Get the cached value of the CacheDirectoryMode property, or None if the property is not cached.

pub async fn receive_cache_directory_mode_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

CacheDirectoryMode property Create a stream for the CacheDirectoryMode property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn cache_directory_symlink(&self) -> Result<Vec<DirectorySymlink>>

CacheDirectorySymlink property

pub fn cached_cache_directory_symlink( &self, ) -> Result<Option<<Result<Vec<DirectorySymlink>> as ResultAdapter>::Ok>, <Result<Vec<DirectorySymlink>> as ResultAdapter>::Err>

CacheDirectorySymlink property Get the cached value of the CacheDirectorySymlink property, or None if the property is not cached.

pub async fn receive_cache_directory_symlink_changed( &self, ) -> PropertyStream<'p, <Result<Vec<DirectorySymlink>> as ResultAdapter>::Ok>

CacheDirectorySymlink property Create a stream for the CacheDirectorySymlink property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn capability_bounding_set(&self) -> Result<u64>

CapabilityBoundingSet property

pub fn cached_capability_bounding_set( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

CapabilityBoundingSet property Get the cached value of the CapabilityBoundingSet property, or None if the property is not cached.

pub async fn receive_capability_bounding_set_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

CapabilityBoundingSet property Create a stream for the CapabilityBoundingSet property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn configuration_directory(&self) -> Result<Vec<String>>

ConfigurationDirectory property

pub fn cached_configuration_directory( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

ConfigurationDirectory property Get the cached value of the ConfigurationDirectory property, or None if the property is not cached.

pub async fn receive_configuration_directory_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

ConfigurationDirectory property Create a stream for the ConfigurationDirectory property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn configuration_directory_mode(&self) -> Result<u32>

ConfigurationDirectoryMode property

pub fn cached_configuration_directory_mode( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

ConfigurationDirectoryMode property Get the cached value of the ConfigurationDirectoryMode property, or None if the property is not cached.

pub async fn receive_configuration_directory_mode_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

ConfigurationDirectoryMode property Create a stream for the ConfigurationDirectoryMode property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn control_group(&self) -> Result<String>

ControlGroup property

pub fn cached_control_group( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

ControlGroup property Get the cached value of the ControlGroup property, or None if the property is not cached.

pub async fn receive_control_group_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

ControlGroup property Create a stream for the ControlGroup property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn control_group_id(&self) -> Result<u64>

ControlGroupId property

pub fn cached_control_group_id( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

ControlGroupId property Get the cached value of the ControlGroupId property, or None if the property is not cached.

pub async fn receive_control_group_id_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

ControlGroupId property Create a stream for the ControlGroupId property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn control_pid(&self) -> Result<u32>

ControlPID property

pub fn cached_control_pid( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

ControlPID property Get the cached value of the ControlPID property, or None if the property is not cached.

pub async fn receive_control_pid_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

ControlPID property Create a stream for the ControlPID property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn coredump_filter(&self) -> Result<u64>

CoredumpFilter property

pub fn cached_coredump_filter( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

CoredumpFilter property Get the cached value of the CoredumpFilter property, or None if the property is not cached.

pub async fn receive_coredump_filter_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

CoredumpFilter property Create a stream for the CoredumpFilter property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn default_memory_low(&self) -> Result<u64>

DefaultMemoryLow property

pub fn cached_default_memory_low( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

DefaultMemoryLow property Get the cached value of the DefaultMemoryLow property, or None if the property is not cached.

pub async fn receive_default_memory_low_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

DefaultMemoryLow property Create a stream for the DefaultMemoryLow property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn default_memory_min(&self) -> Result<u64>

DefaultMemoryMin property

pub fn cached_default_memory_min( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

DefaultMemoryMin property Get the cached value of the DefaultMemoryMin property, or None if the property is not cached.

pub async fn receive_default_memory_min_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

DefaultMemoryMin property Create a stream for the DefaultMemoryMin property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn defer_accept_usec(&self) -> Result<u64>

DeferAcceptUSec property

pub fn cached_defer_accept_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

DeferAcceptUSec property Get the cached value of the DeferAcceptUSec property, or None if the property is not cached.

pub async fn receive_defer_accept_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

DeferAcceptUSec property Create a stream for the DeferAcceptUSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn delegate(&self) -> Result<bool>

Delegate property

pub fn cached_delegate( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Delegate property Get the cached value of the Delegate property, or None if the property is not cached.

pub async fn receive_delegate_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Delegate property Create a stream for the Delegate property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn delegate_controllers(&self) -> Result<Vec<String>>

DelegateControllers property

pub fn cached_delegate_controllers( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

DelegateControllers property Get the cached value of the DelegateControllers property, or None if the property is not cached.

pub async fn receive_delegate_controllers_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

DelegateControllers property Create a stream for the DelegateControllers property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn device_allow(&self) -> Result<Vec<(String, String)>>

DeviceAllow property

pub fn cached_device_allow( &self, ) -> Result<Option<<Result<Vec<(String, String)>> as ResultAdapter>::Ok>, <Result<Vec<(String, String)>> as ResultAdapter>::Err>

DeviceAllow property Get the cached value of the DeviceAllow property, or None if the property is not cached.

pub async fn receive_device_allow_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

DeviceAllow property Create a stream for the DeviceAllow property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn device_policy(&self) -> Result<String>

DevicePolicy property

pub fn cached_device_policy( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

DevicePolicy property Get the cached value of the DevicePolicy property, or None if the property is not cached.

pub async fn receive_device_policy_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

DevicePolicy property Create a stream for the DevicePolicy property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn directory_mode(&self) -> Result<u32>

DirectoryMode property

pub fn cached_directory_mode( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

DirectoryMode property Get the cached value of the DirectoryMode property, or None if the property is not cached.

pub async fn receive_directory_mode_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

DirectoryMode property Create a stream for the DirectoryMode property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn disable_controllers(&self) -> Result<Vec<String>>

DisableControllers property

pub fn cached_disable_controllers( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

DisableControllers property Get the cached value of the DisableControllers property, or None if the property is not cached.

pub async fn receive_disable_controllers_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

DisableControllers property Create a stream for the DisableControllers property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn dynamic_user(&self) -> Result<bool>

DynamicUser property

pub fn cached_dynamic_user( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

DynamicUser property Get the cached value of the DynamicUser property, or None if the property is not cached.

pub async fn receive_dynamic_user_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

DynamicUser property Create a stream for the DynamicUser property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn effective_cpus(&self) -> Result<Vec<u8>>

EffectiveCPUs property

pub fn cached_effective_cpus( &self, ) -> Result<Option<<Result<Vec<u8>> as ResultAdapter>::Ok>, <Result<Vec<u8>> as ResultAdapter>::Err>

EffectiveCPUs property Get the cached value of the EffectiveCPUs property, or None if the property is not cached.

pub async fn receive_effective_cpus_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

EffectiveCPUs property Create a stream for the EffectiveCPUs property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn effective_memory_nodes(&self) -> Result<Vec<u8>>

EffectiveMemoryNodes property

pub fn cached_effective_memory_nodes( &self, ) -> Result<Option<<Result<Vec<u8>> as ResultAdapter>::Ok>, <Result<Vec<u8>> as ResultAdapter>::Err>

EffectiveMemoryNodes property Get the cached value of the EffectiveMemoryNodes property, or None if the property is not cached.

pub async fn receive_effective_memory_nodes_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

EffectiveMemoryNodes property Create a stream for the EffectiveMemoryNodes property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn environment(&self) -> Result<Vec<String>>

Environment property

pub fn cached_environment( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Environment property Get the cached value of the Environment property, or None if the property is not cached.

pub async fn receive_environment_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Environment property Create a stream for the Environment property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn environment_files(&self) -> Result<Vec<(String, bool)>>

EnvironmentFiles property

pub fn cached_environment_files( &self, ) -> Result<Option<<Result<Vec<(String, bool)>> as ResultAdapter>::Ok>, <Result<Vec<(String, bool)>> as ResultAdapter>::Err>

EnvironmentFiles property Get the cached value of the EnvironmentFiles property, or None if the property is not cached.

pub async fn receive_environment_files_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, bool)>> as ResultAdapter>::Ok>

EnvironmentFiles property Create a stream for the EnvironmentFiles property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn exec_paths(&self) -> Result<Vec<String>>

ExecPaths property

pub fn cached_exec_paths( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

ExecPaths property Get the cached value of the ExecPaths property, or None if the property is not cached.

pub async fn receive_exec_paths_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

ExecPaths property Create a stream for the ExecPaths property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn exec_search_path(&self) -> Result<Vec<String>>

ExecSearchPath property

pub fn cached_exec_search_path( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

ExecSearchPath property Get the cached value of the ExecSearchPath property, or None if the property is not cached.

pub async fn receive_exec_search_path_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

ExecSearchPath property Create a stream for the ExecSearchPath property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn exec_start_post(&self) -> Result<Vec<Exec>>

ExecStartPost property

pub fn cached_exec_start_post( &self, ) -> Result<Option<<Result<Vec<Exec>> as ResultAdapter>::Ok>, <Result<Vec<Exec>> as ResultAdapter>::Err>

ExecStartPost property Get the cached value of the ExecStartPost property, or None if the property is not cached.

pub async fn receive_exec_start_post_changed( &self, ) -> PropertyStream<'p, <Result<Vec<Exec>> as ResultAdapter>::Ok>

ExecStartPost property Create a stream for the ExecStartPost property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn exec_start_pre(&self) -> Result<Vec<Exec>>

ExecStartPre property

pub fn cached_exec_start_pre( &self, ) -> Result<Option<<Result<Vec<Exec>> as ResultAdapter>::Ok>, <Result<Vec<Exec>> as ResultAdapter>::Err>

ExecStartPre property Get the cached value of the ExecStartPre property, or None if the property is not cached.

pub async fn receive_exec_start_pre_changed( &self, ) -> PropertyStream<'p, <Result<Vec<Exec>> as ResultAdapter>::Ok>

ExecStartPre property Create a stream for the ExecStartPre property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn exec_stop_post(&self) -> Result<Vec<Exec>>

ExecStopPost property

pub fn cached_exec_stop_post( &self, ) -> Result<Option<<Result<Vec<Exec>> as ResultAdapter>::Ok>, <Result<Vec<Exec>> as ResultAdapter>::Err>

ExecStopPost property Get the cached value of the ExecStopPost property, or None if the property is not cached.

pub async fn receive_exec_stop_post_changed( &self, ) -> PropertyStream<'p, <Result<Vec<Exec>> as ResultAdapter>::Ok>

ExecStopPost property Create a stream for the ExecStopPost property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn exec_stop_pre(&self) -> Result<Vec<Exec>>

ExecStopPre property

pub fn cached_exec_stop_pre( &self, ) -> Result<Option<<Result<Vec<Exec>> as ResultAdapter>::Ok>, <Result<Vec<Exec>> as ResultAdapter>::Err>

ExecStopPre property Get the cached value of the ExecStopPre property, or None if the property is not cached.

pub async fn receive_exec_stop_pre_changed( &self, ) -> PropertyStream<'p, <Result<Vec<Exec>> as ResultAdapter>::Ok>

ExecStopPre property Create a stream for the ExecStopPre property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn extension_directories(&self) -> Result<Vec<String>>

ExtensionDirectories property

pub fn cached_extension_directories( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

ExtensionDirectories property Get the cached value of the ExtensionDirectories property, or None if the property is not cached.

pub async fn receive_extension_directories_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

ExtensionDirectories property Create a stream for the ExtensionDirectories property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn extension_images(&self) -> Result<Vec<ExtensionImage>>

ExtensionImages property

pub fn cached_extension_images( &self, ) -> Result<Option<<Result<Vec<ExtensionImage>> as ResultAdapter>::Ok>, <Result<Vec<ExtensionImage>> as ResultAdapter>::Err>

ExtensionImages property Get the cached value of the ExtensionImages property, or None if the property is not cached.

pub async fn receive_extension_images_changed( &self, ) -> PropertyStream<'p, <Result<Vec<ExtensionImage>> as ResultAdapter>::Ok>

ExtensionImages property Create a stream for the ExtensionImages property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn file_descriptor_name(&self) -> Result<String>

FileDescriptorName property

pub fn cached_file_descriptor_name( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

FileDescriptorName property Get the cached value of the FileDescriptorName property, or None if the property is not cached.

pub async fn receive_file_descriptor_name_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

FileDescriptorName property Create a stream for the FileDescriptorName property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn final_kill_signal(&self) -> Result<i32>

FinalKillSignal property

pub fn cached_final_kill_signal( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

FinalKillSignal property Get the cached value of the FinalKillSignal property, or None if the property is not cached.

pub async fn receive_final_kill_signal_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

FinalKillSignal property Create a stream for the FinalKillSignal property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn flush_pending(&self) -> Result<bool>

FlushPending property

pub fn cached_flush_pending( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

FlushPending property Get the cached value of the FlushPending property, or None if the property is not cached.

pub async fn receive_flush_pending_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

FlushPending property Create a stream for the FlushPending property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn free_bind(&self) -> Result<bool>

FreeBind property

pub fn cached_free_bind( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

FreeBind property Get the cached value of the FreeBind property, or None if the property is not cached.

pub async fn receive_free_bind_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

FreeBind property Create a stream for the FreeBind property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn gid(&self) -> Result<u32>

GID property

pub fn cached_gid( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

GID property Get the cached value of the GID property, or None if the property is not cached.

pub async fn receive_gid_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

GID property Create a stream for the GID property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn group(&self) -> Result<String>

Group property

pub fn cached_group( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Group property Get the cached value of the Group property, or None if the property is not cached.

pub async fn receive_group_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Group property Create a stream for the Group property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn io_accounting(&self) -> Result<bool>

IOAccounting property

pub fn cached_io_accounting( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

IOAccounting property Get the cached value of the IOAccounting property, or None if the property is not cached.

pub async fn receive_io_accounting_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

IOAccounting property Create a stream for the IOAccounting property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn io_device_latency_target_usec(&self) -> Result<Vec<(String, u64)>>

IODeviceLatencyTargetUSec property

pub fn cached_io_device_latency_target_usec( &self, ) -> Result<Option<<Result<Vec<(String, u64)>> as ResultAdapter>::Ok>, <Result<Vec<(String, u64)>> as ResultAdapter>::Err>

IODeviceLatencyTargetUSec property Get the cached value of the IODeviceLatencyTargetUSec property, or None if the property is not cached.

pub async fn receive_io_device_latency_target_usec_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

IODeviceLatencyTargetUSec property Create a stream for the IODeviceLatencyTargetUSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn io_device_weight(&self) -> Result<Vec<(String, u64)>>

IODeviceWeight property

pub fn cached_io_device_weight( &self, ) -> Result<Option<<Result<Vec<(String, u64)>> as ResultAdapter>::Ok>, <Result<Vec<(String, u64)>> as ResultAdapter>::Err>

IODeviceWeight property Get the cached value of the IODeviceWeight property, or None if the property is not cached.

pub async fn receive_io_device_weight_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

IODeviceWeight property Create a stream for the IODeviceWeight property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn io_read_bandwidth_max(&self) -> Result<Vec<(String, u64)>>

IOReadBandwidthMax property

pub fn cached_io_read_bandwidth_max( &self, ) -> Result<Option<<Result<Vec<(String, u64)>> as ResultAdapter>::Ok>, <Result<Vec<(String, u64)>> as ResultAdapter>::Err>

IOReadBandwidthMax property Get the cached value of the IOReadBandwidthMax property, or None if the property is not cached.

pub async fn receive_io_read_bandwidth_max_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

IOReadBandwidthMax property Create a stream for the IOReadBandwidthMax property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn io_read_bytes(&self) -> Result<u64>

IOReadBytes property

pub fn cached_io_read_bytes( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

IOReadBytes property Get the cached value of the IOReadBytes property, or None if the property is not cached.

pub async fn receive_io_read_bytes_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

IOReadBytes property Create a stream for the IOReadBytes property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn io_read_iops_max(&self) -> Result<Vec<(String, u64)>>

IOReadIOPSMax property

pub fn cached_io_read_iops_max( &self, ) -> Result<Option<<Result<Vec<(String, u64)>> as ResultAdapter>::Ok>, <Result<Vec<(String, u64)>> as ResultAdapter>::Err>

IOReadIOPSMax property Get the cached value of the IOReadIOPSMax property, or None if the property is not cached.

pub async fn receive_io_read_iops_max_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

IOReadIOPSMax property Create a stream for the IOReadIOPSMax property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn io_read_operations(&self) -> Result<u64>

IOReadOperations property

pub fn cached_io_read_operations( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

IOReadOperations property Get the cached value of the IOReadOperations property, or None if the property is not cached.

pub async fn receive_io_read_operations_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

IOReadOperations property Create a stream for the IOReadOperations property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn io_scheduling_class(&self) -> Result<i32>

IOSchedulingClass property

pub fn cached_io_scheduling_class( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

IOSchedulingClass property Get the cached value of the IOSchedulingClass property, or None if the property is not cached.

pub async fn receive_io_scheduling_class_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

IOSchedulingClass property Create a stream for the IOSchedulingClass property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn io_scheduling_priority(&self) -> Result<i32>

IOSchedulingPriority property

pub fn cached_io_scheduling_priority( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

IOSchedulingPriority property Get the cached value of the IOSchedulingPriority property, or None if the property is not cached.

pub async fn receive_io_scheduling_priority_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

IOSchedulingPriority property Create a stream for the IOSchedulingPriority property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn io_weight(&self) -> Result<u64>

IOWeight property

pub fn cached_io_weight( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

IOWeight property Get the cached value of the IOWeight property, or None if the property is not cached.

pub async fn receive_io_weight_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

IOWeight property Create a stream for the IOWeight property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn io_write_bandwidth_max(&self) -> Result<Vec<(String, u64)>>

IOWriteBandwidthMax property

pub fn cached_io_write_bandwidth_max( &self, ) -> Result<Option<<Result<Vec<(String, u64)>> as ResultAdapter>::Ok>, <Result<Vec<(String, u64)>> as ResultAdapter>::Err>

IOWriteBandwidthMax property Get the cached value of the IOWriteBandwidthMax property, or None if the property is not cached.

pub async fn receive_io_write_bandwidth_max_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

IOWriteBandwidthMax property Create a stream for the IOWriteBandwidthMax property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn io_write_bytes(&self) -> Result<u64>

IOWriteBytes property

pub fn cached_io_write_bytes( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

IOWriteBytes property Get the cached value of the IOWriteBytes property, or None if the property is not cached.

pub async fn receive_io_write_bytes_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

IOWriteBytes property Create a stream for the IOWriteBytes property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn iowrite_iops_max(&self) -> Result<Vec<(String, u64)>>

IOWriteIOPSMax property

pub fn cached_iowrite_iops_max( &self, ) -> Result<Option<<Result<Vec<(String, u64)>> as ResultAdapter>::Ok>, <Result<Vec<(String, u64)>> as ResultAdapter>::Err>

IOWriteIOPSMax property Get the cached value of the IOWriteIOPSMax property, or None if the property is not cached.

pub async fn receive_iowrite_iops_max_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, u64)>> as ResultAdapter>::Ok>

IOWriteIOPSMax property Create a stream for the IOWriteIOPSMax property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn io_write_operations(&self) -> Result<u64>

IOWriteOperations property

pub fn cached_io_write_operations( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

IOWriteOperations property Get the cached value of the IOWriteOperations property, or None if the property is not cached.

pub async fn receive_io_write_operations_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

IOWriteOperations property Create a stream for the IOWriteOperations property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ip_accounting(&self) -> Result<bool>

IPAccounting property

pub fn cached_ip_accounting( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

IPAccounting property Get the cached value of the IPAccounting property, or None if the property is not cached.

pub async fn receive_ip_accounting_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

IPAccounting property Create a stream for the IPAccounting property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ip_address_allow(&self) -> Result<Vec<(i32, Vec<u8>, u32)>>

IPAddressAllow property

pub fn cached_ip_address_allow( &self, ) -> Result<Option<<Result<Vec<(i32, Vec<u8>, u32)>> as ResultAdapter>::Ok>, <Result<Vec<(i32, Vec<u8>, u32)>> as ResultAdapter>::Err>

IPAddressAllow property Get the cached value of the IPAddressAllow property, or None if the property is not cached.

pub async fn receive_ip_address_allow_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(i32, Vec<u8>, u32)>> as ResultAdapter>::Ok>

IPAddressAllow property Create a stream for the IPAddressAllow property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ip_address_deny(&self) -> Result<Vec<(i32, Vec<u8>, u32)>>

IPAddressDeny property

pub fn cached_ip_address_deny( &self, ) -> Result<Option<<Result<Vec<(i32, Vec<u8>, u32)>> as ResultAdapter>::Ok>, <Result<Vec<(i32, Vec<u8>, u32)>> as ResultAdapter>::Err>

IPAddressDeny property Get the cached value of the IPAddressDeny property, or None if the property is not cached.

pub async fn receive_ip_address_deny_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(i32, Vec<u8>, u32)>> as ResultAdapter>::Ok>

IPAddressDeny property Create a stream for the IPAddressDeny property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ipc_namespace_path(&self) -> Result<String>

IPCNamespacePath property

pub fn cached_ipc_namespace_path( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

IPCNamespacePath property Get the cached value of the IPCNamespacePath property, or None if the property is not cached.

pub async fn receive_ipc_namespace_path_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

IPCNamespacePath property Create a stream for the IPCNamespacePath property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ip_egress_bytes(&self) -> Result<u64>

IPEgressBytes property

pub fn cached_ip_egress_bytes( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

IPEgressBytes property Get the cached value of the IPEgressBytes property, or None if the property is not cached.

pub async fn receive_ip_egress_bytes_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

IPEgressBytes property Create a stream for the IPEgressBytes property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ip_egress_filter_path(&self) -> Result<Vec<String>>

IPEgressFilterPath property

pub fn cached_ip_egress_filter_path( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

IPEgressFilterPath property Get the cached value of the IPEgressFilterPath property, or None if the property is not cached.

pub async fn receive_ip_egress_filter_path_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

IPEgressFilterPath property Create a stream for the IPEgressFilterPath property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ip_egress_packets(&self) -> Result<u64>

IPEgressPackets property

pub fn cached_ip_egress_packets( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

IPEgressPackets property Get the cached value of the IPEgressPackets property, or None if the property is not cached.

pub async fn receive_ip_egress_packets_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

IPEgressPackets property Create a stream for the IPEgressPackets property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ip_ingress_bytes(&self) -> Result<u64>

IPIngressBytes property

pub fn cached_ip_ingress_bytes( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

IPIngressBytes property Get the cached value of the IPIngressBytes property, or None if the property is not cached.

pub async fn receive_ip_ingress_bytes_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

IPIngressBytes property Create a stream for the IPIngressBytes property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ip_ingress_filter_path(&self) -> Result<Vec<String>>

IPIngressFilterPath property

pub fn cached_ip_ingress_filter_path( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

IPIngressFilterPath property Get the cached value of the IPIngressFilterPath property, or None if the property is not cached.

pub async fn receive_ip_ingress_filter_path_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

IPIngressFilterPath property Create a stream for the IPIngressFilterPath property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ip_ingress_packets(&self) -> Result<u64>

IPIngressPackets property

pub fn cached_ip_ingress_packets( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

IPIngressPackets property Get the cached value of the IPIngressPackets property, or None if the property is not cached.

pub async fn receive_ip_ingress_packets_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

IPIngressPackets property Create a stream for the IPIngressPackets property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ip_tos(&self) -> Result<i32>

IPTOS property

pub fn cached_ip_tos( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

IPTOS property Get the cached value of the IPTOS property, or None if the property is not cached.

pub async fn receive_ip_tos_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

IPTOS property Create a stream for the IPTOS property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ip_ttl(&self) -> Result<i32>

IPTTL property

pub fn cached_ip_ttl( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

IPTTL property Get the cached value of the IPTTL property, or None if the property is not cached.

pub async fn receive_ip_ttl_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

IPTTL property Create a stream for the IPTTL property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn ignore_sigpipe(&self) -> Result<bool>

IgnoreSIGPIPE property

pub fn cached_ignore_sigpipe( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

IgnoreSIGPIPE property Get the cached value of the IgnoreSIGPIPE property, or None if the property is not cached.

pub async fn receive_ignore_sigpipe_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

IgnoreSIGPIPE property Create a stream for the IgnoreSIGPIPE property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn inaccessible_paths(&self) -> Result<Vec<String>>

InaccessiblePaths property

pub fn cached_inaccessible_paths( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

InaccessiblePaths property Get the cached value of the InaccessiblePaths property, or None if the property is not cached.

pub async fn receive_inaccessible_paths_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

InaccessiblePaths property Create a stream for the InaccessiblePaths property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn keep_alive(&self) -> Result<bool>

KeepAlive property

pub fn cached_keep_alive( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

KeepAlive property Get the cached value of the KeepAlive property, or None if the property is not cached.

pub async fn receive_keep_alive_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

KeepAlive property Create a stream for the KeepAlive property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn keep_alive_interval_usec(&self) -> Result<u64>

KeepAliveIntervalUSec property

pub fn cached_keep_alive_interval_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

KeepAliveIntervalUSec property Get the cached value of the KeepAliveIntervalUSec property, or None if the property is not cached.

pub async fn receive_keep_alive_interval_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

KeepAliveIntervalUSec property Create a stream for the KeepAliveIntervalUSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn keep_alive_probes(&self) -> Result<u32>

KeepAliveProbes property

pub fn cached_keep_alive_probes( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

KeepAliveProbes property Get the cached value of the KeepAliveProbes property, or None if the property is not cached.

pub async fn receive_keep_alive_probes_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

KeepAliveProbes property Create a stream for the KeepAliveProbes property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn keep_alive_time_usec(&self) -> Result<u64>

KeepAliveTimeUSec property

pub fn cached_keep_alive_time_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

KeepAliveTimeUSec property Get the cached value of the KeepAliveTimeUSec property, or None if the property is not cached.

pub async fn receive_keep_alive_time_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

KeepAliveTimeUSec property Create a stream for the KeepAliveTimeUSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn keyring_mode(&self) -> Result<String>

KeyringMode property

pub fn cached_keyring_mode( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

KeyringMode property Get the cached value of the KeyringMode property, or None if the property is not cached.

pub async fn receive_keyring_mode_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

KeyringMode property Create a stream for the KeyringMode property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn kill_mode(&self) -> Result<String>

KillMode property

pub fn cached_kill_mode( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

KillMode property Get the cached value of the KillMode property, or None if the property is not cached.

pub async fn receive_kill_mode_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

KillMode property Create a stream for the KillMode property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn kill_signal(&self) -> Result<i32>

KillSignal property

pub fn cached_kill_signal( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

KillSignal property Get the cached value of the KillSignal property, or None if the property is not cached.

pub async fn receive_kill_signal_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

KillSignal property Create a stream for the KillSignal property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_as(&self) -> Result<u64>

LimitAS property

pub fn cached_limit_as( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitAS property Get the cached value of the LimitAS property, or None if the property is not cached.

pub async fn receive_limit_as_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitAS property Create a stream for the LimitAS property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_as_soft(&self) -> Result<u64>

LimitASSoft property

pub fn cached_limit_as_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitASSoft property Get the cached value of the LimitASSoft property, or None if the property is not cached.

pub async fn receive_limit_as_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitASSoft property Create a stream for the LimitASSoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_core(&self) -> Result<u64>

LimitCORE property

pub fn cached_limit_core( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitCORE property Get the cached value of the LimitCORE property, or None if the property is not cached.

pub async fn receive_limit_core_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitCORE property Create a stream for the LimitCORE property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_core_soft(&self) -> Result<u64>

LimitCORESoft property

pub fn cached_limit_core_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitCORESoft property Get the cached value of the LimitCORESoft property, or None if the property is not cached.

pub async fn receive_limit_core_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitCORESoft property Create a stream for the LimitCORESoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_cpu(&self) -> Result<u64>

LimitCPU property

pub fn cached_limit_cpu( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitCPU property Get the cached value of the LimitCPU property, or None if the property is not cached.

pub async fn receive_limit_cpu_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitCPU property Create a stream for the LimitCPU property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_cpu_soft(&self) -> Result<u64>

LimitCPUSoft property

pub fn cached_limit_cpu_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitCPUSoft property Get the cached value of the LimitCPUSoft property, or None if the property is not cached.

pub async fn receive_limit_cpu_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitCPUSoft property Create a stream for the LimitCPUSoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_data(&self) -> Result<u64>

LimitDATA property

pub fn cached_limit_data( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitDATA property Get the cached value of the LimitDATA property, or None if the property is not cached.

pub async fn receive_limit_data_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitDATA property Create a stream for the LimitDATA property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_data_soft(&self) -> Result<u64>

LimitDATASoft property

pub fn cached_limit_data_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitDATASoft property Get the cached value of the LimitDATASoft property, or None if the property is not cached.

pub async fn receive_limit_data_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitDATASoft property Create a stream for the LimitDATASoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_fsize(&self) -> Result<u64>

LimitFSIZE property

pub fn cached_limit_fsize( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitFSIZE property Get the cached value of the LimitFSIZE property, or None if the property is not cached.

pub async fn receive_limit_fsize_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitFSIZE property Create a stream for the LimitFSIZE property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_fsize_soft(&self) -> Result<u64>

LimitFSIZESoft property

pub fn cached_limit_fsize_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitFSIZESoft property Get the cached value of the LimitFSIZESoft property, or None if the property is not cached.

pub async fn receive_limit_fsize_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitFSIZESoft property Create a stream for the LimitFSIZESoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_locks(&self) -> Result<u64>

LimitLOCKS property

pub fn cached_limit_locks( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitLOCKS property Get the cached value of the LimitLOCKS property, or None if the property is not cached.

pub async fn receive_limit_locks_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitLOCKS property Create a stream for the LimitLOCKS property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_locks_soft(&self) -> Result<u64>

LimitLOCKSSoft property

pub fn cached_limit_locks_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitLOCKSSoft property Get the cached value of the LimitLOCKSSoft property, or None if the property is not cached.

pub async fn receive_limit_locks_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitLOCKSSoft property Create a stream for the LimitLOCKSSoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_memlock(&self) -> Result<u64>

LimitMEMLOCK property

pub fn cached_limit_memlock( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitMEMLOCK property Get the cached value of the LimitMEMLOCK property, or None if the property is not cached.

pub async fn receive_limit_memlock_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitMEMLOCK property Create a stream for the LimitMEMLOCK property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_memlock_soft(&self) -> Result<u64>

LimitMEMLOCKSoft property

pub fn cached_limit_memlock_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitMEMLOCKSoft property Get the cached value of the LimitMEMLOCKSoft property, or None if the property is not cached.

pub async fn receive_limit_memlock_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitMEMLOCKSoft property Create a stream for the LimitMEMLOCKSoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_msgqueue(&self) -> Result<u64>

LimitMSGQUEUE property

pub fn cached_limit_msgqueue( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitMSGQUEUE property Get the cached value of the LimitMSGQUEUE property, or None if the property is not cached.

pub async fn receive_limit_msgqueue_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitMSGQUEUE property Create a stream for the LimitMSGQUEUE property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_msgqueue_soft(&self) -> Result<u64>

LimitMSGQUEUESoft property

pub fn cached_limit_msgqueue_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitMSGQUEUESoft property Get the cached value of the LimitMSGQUEUESoft property, or None if the property is not cached.

pub async fn receive_limit_msgqueue_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitMSGQUEUESoft property Create a stream for the LimitMSGQUEUESoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_nice(&self) -> Result<u64>

LimitNICE property

pub fn cached_limit_nice( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitNICE property Get the cached value of the LimitNICE property, or None if the property is not cached.

pub async fn receive_limit_nice_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitNICE property Create a stream for the LimitNICE property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_nice_soft(&self) -> Result<u64>

LimitNICESoft property

pub fn cached_limit_nice_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitNICESoft property Get the cached value of the LimitNICESoft property, or None if the property is not cached.

pub async fn receive_limit_nice_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitNICESoft property Create a stream for the LimitNICESoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_nofile(&self) -> Result<u64>

LimitNOFILE property

pub fn cached_limit_nofile( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitNOFILE property Get the cached value of the LimitNOFILE property, or None if the property is not cached.

pub async fn receive_limit_nofile_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitNOFILE property Create a stream for the LimitNOFILE property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_nofile_soft(&self) -> Result<u64>

LimitNOFILESoft property

pub fn cached_limit_nofile_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitNOFILESoft property Get the cached value of the LimitNOFILESoft property, or None if the property is not cached.

pub async fn receive_limit_nofile_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitNOFILESoft property Create a stream for the LimitNOFILESoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_nproc(&self) -> Result<u64>

LimitNPROC property

pub fn cached_limit_nproc( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitNPROC property Get the cached value of the LimitNPROC property, or None if the property is not cached.

pub async fn receive_limit_nproc_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitNPROC property Create a stream for the LimitNPROC property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_nproc_soft(&self) -> Result<u64>

LimitNPROCSoft property

pub fn cached_limit_nproc_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitNPROCSoft property Get the cached value of the LimitNPROCSoft property, or None if the property is not cached.

pub async fn receive_limit_nproc_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitNPROCSoft property Create a stream for the LimitNPROCSoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_rss(&self) -> Result<u64>

LimitRSS property

pub fn cached_limit_rss( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitRSS property Get the cached value of the LimitRSS property, or None if the property is not cached.

pub async fn receive_limit_rss_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitRSS property Create a stream for the LimitRSS property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_rss_soft(&self) -> Result<u64>

LimitRSSSoft property

pub fn cached_limit_rss_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitRSSSoft property Get the cached value of the LimitRSSSoft property, or None if the property is not cached.

pub async fn receive_limit_rss_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitRSSSoft property Create a stream for the LimitRSSSoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_rtprio(&self) -> Result<u64>

LimitRTPRIO property

pub fn cached_limit_rtprio( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitRTPRIO property Get the cached value of the LimitRTPRIO property, or None if the property is not cached.

pub async fn receive_limit_rtprio_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitRTPRIO property Create a stream for the LimitRTPRIO property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_rtprio_soft(&self) -> Result<u64>

LimitRTPRIOSoft property

pub fn cached_limit_rtprio_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitRTPRIOSoft property Get the cached value of the LimitRTPRIOSoft property, or None if the property is not cached.

pub async fn receive_limit_rtprio_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitRTPRIOSoft property Create a stream for the LimitRTPRIOSoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_rttime(&self) -> Result<u64>

LimitRTTIME property

pub fn cached_limit_rttime( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitRTTIME property Get the cached value of the LimitRTTIME property, or None if the property is not cached.

pub async fn receive_limit_rttime_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitRTTIME property Create a stream for the LimitRTTIME property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_rttime_soft(&self) -> Result<u64>

LimitRTTIMESoft property

pub fn cached_limit_rttime_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitRTTIMESoft property Get the cached value of the LimitRTTIMESoft property, or None if the property is not cached.

pub async fn receive_limit_rttime_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitRTTIMESoft property Create a stream for the LimitRTTIMESoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_sigpending(&self) -> Result<u64>

LimitSIGPENDING property

pub fn cached_limit_sigpending( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitSIGPENDING property Get the cached value of the LimitSIGPENDING property, or None if the property is not cached.

pub async fn receive_limit_sigpending_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitSIGPENDING property Create a stream for the LimitSIGPENDING property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_sigpending_soft(&self) -> Result<u64>

LimitSIGPENDINGSoft property

pub fn cached_limit_sigpending_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitSIGPENDINGSoft property Get the cached value of the LimitSIGPENDINGSoft property, or None if the property is not cached.

pub async fn receive_limit_sigpending_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitSIGPENDINGSoft property Create a stream for the LimitSIGPENDINGSoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_stack(&self) -> Result<u64>

LimitSTACK property

pub fn cached_limit_stack( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitSTACK property Get the cached value of the LimitSTACK property, or None if the property is not cached.

pub async fn receive_limit_stack_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitSTACK property Create a stream for the LimitSTACK property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn limit_stack_soft(&self) -> Result<u64>

LimitSTACKSoft property

pub fn cached_limit_stack_soft( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LimitSTACKSoft property Get the cached value of the LimitSTACKSoft property, or None if the property is not cached.

pub async fn receive_limit_stack_soft_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LimitSTACKSoft property Create a stream for the LimitSTACKSoft property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn listen(&self) -> Result<Vec<(String, String)>>

Listen property

pub fn cached_listen( &self, ) -> Result<Option<<Result<Vec<(String, String)>> as ResultAdapter>::Ok>, <Result<Vec<(String, String)>> as ResultAdapter>::Err>

Listen property Get the cached value of the Listen property, or None if the property is not cached.

pub async fn receive_listen_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

Listen property Create a stream for the Listen property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn load_credential(&self) -> Result<Vec<(String, String)>>

LoadCredential property

pub fn cached_load_credential( &self, ) -> Result<Option<<Result<Vec<(String, String)>> as ResultAdapter>::Ok>, <Result<Vec<(String, String)>> as ResultAdapter>::Err>

LoadCredential property Get the cached value of the LoadCredential property, or None if the property is not cached.

pub async fn receive_load_credential_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

LoadCredential property Create a stream for the LoadCredential property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn load_credential_encrypted(&self) -> Result<Vec<(String, String)>>

LoadCredentialEncrypted property

pub fn cached_load_credential_encrypted( &self, ) -> Result<Option<<Result<Vec<(String, String)>> as ResultAdapter>::Ok>, <Result<Vec<(String, String)>> as ResultAdapter>::Err>

LoadCredentialEncrypted property Get the cached value of the LoadCredentialEncrypted property, or None if the property is not cached.

pub async fn receive_load_credential_encrypted_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

LoadCredentialEncrypted property Create a stream for the LoadCredentialEncrypted property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn lock_personality(&self) -> Result<bool>

LockPersonality property

pub fn cached_lock_personality( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

LockPersonality property Get the cached value of the LockPersonality property, or None if the property is not cached.

pub async fn receive_lock_personality_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

LockPersonality property Create a stream for the LockPersonality property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn log_extra_fields(&self) -> Result<Vec<Vec<u8>>>

LogExtraFields property

pub fn cached_log_extra_fields( &self, ) -> Result<Option<<Result<Vec<Vec<u8>>> as ResultAdapter>::Ok>, <Result<Vec<Vec<u8>>> as ResultAdapter>::Err>

LogExtraFields property Get the cached value of the LogExtraFields property, or None if the property is not cached.

pub async fn receive_log_extra_fields_changed( &self, ) -> PropertyStream<'p, <Result<Vec<Vec<u8>>> as ResultAdapter>::Ok>

LogExtraFields property Create a stream for the LogExtraFields property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn log_level_max(&self) -> Result<i32>

LogLevelMax property

pub fn cached_log_level_max( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

LogLevelMax property Get the cached value of the LogLevelMax property, or None if the property is not cached.

pub async fn receive_log_level_max_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

LogLevelMax property Create a stream for the LogLevelMax property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn log_namespace(&self) -> Result<String>

LogNamespace property

pub fn cached_log_namespace( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

LogNamespace property Get the cached value of the LogNamespace property, or None if the property is not cached.

pub async fn receive_log_namespace_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

LogNamespace property Create a stream for the LogNamespace property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn log_rate_limit_burst(&self) -> Result<u32>

LogRateLimitBurst property

pub fn cached_log_rate_limit_burst( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

LogRateLimitBurst property Get the cached value of the LogRateLimitBurst property, or None if the property is not cached.

pub async fn receive_log_rate_limit_burst_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

LogRateLimitBurst property Create a stream for the LogRateLimitBurst property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn log_rate_limit_interval_usec(&self) -> Result<u64>

LogRateLimitIntervalUSec property

pub fn cached_log_rate_limit_interval_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

LogRateLimitIntervalUSec property Get the cached value of the LogRateLimitIntervalUSec property, or None if the property is not cached.

pub async fn receive_log_rate_limit_interval_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

LogRateLimitIntervalUSec property Create a stream for the LogRateLimitIntervalUSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn logs_directory(&self) -> Result<Vec<String>>

LogsDirectory property

pub fn cached_logs_directory( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

LogsDirectory property Get the cached value of the LogsDirectory property, or None if the property is not cached.

pub async fn receive_logs_directory_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

LogsDirectory property Create a stream for the LogsDirectory property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn logs_directory_mode(&self) -> Result<u32>

LogsDirectoryMode property

pub fn cached_logs_directory_mode( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

LogsDirectoryMode property Get the cached value of the LogsDirectoryMode property, or None if the property is not cached.

pub async fn receive_logs_directory_mode_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

LogsDirectoryMode property Create a stream for the LogsDirectoryMode property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn logs_directory_symlink(&self) -> Result<Vec<DirectorySymlink>>

LogsDirectorySymlink property

pub fn cached_logs_directory_symlink( &self, ) -> Result<Option<<Result<Vec<DirectorySymlink>> as ResultAdapter>::Ok>, <Result<Vec<DirectorySymlink>> as ResultAdapter>::Err>

LogsDirectorySymlink property Get the cached value of the LogsDirectorySymlink property, or None if the property is not cached.

pub async fn receive_logs_directory_symlink_changed( &self, ) -> PropertyStream<'p, <Result<Vec<DirectorySymlink>> as ResultAdapter>::Ok>

LogsDirectorySymlink property Create a stream for the LogsDirectorySymlink property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn managed_oom_memory_pressure(&self) -> Result<String>

ManagedOOMMemoryPressure property

pub fn cached_managed_oom_memory_pressure( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

ManagedOOMMemoryPressure property Get the cached value of the ManagedOOMMemoryPressure property, or None if the property is not cached.

pub async fn receive_managed_oom_memory_pressure_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

ManagedOOMMemoryPressure property Create a stream for the ManagedOOMMemoryPressure property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn managed_oom_memory_pressure_limit(&self) -> Result<u32>

ManagedOOMMemoryPressureLimit property

pub fn cached_managed_oom_memory_pressure_limit( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

ManagedOOMMemoryPressureLimit property Get the cached value of the ManagedOOMMemoryPressureLimit property, or None if the property is not cached.

pub async fn receive_managed_oom_memory_pressure_limit_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

ManagedOOMMemoryPressureLimit property Create a stream for the ManagedOOMMemoryPressureLimit property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn managed_oom_preference(&self) -> Result<String>

ManagedOOMPreference property

pub fn cached_managed_oom_preference( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

ManagedOOMPreference property Get the cached value of the ManagedOOMPreference property, or None if the property is not cached.

pub async fn receive_managed_oom_preference_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

ManagedOOMPreference property Create a stream for the ManagedOOMPreference property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn managed_oom_swap(&self) -> Result<String>

ManagedOOMSwap property

pub fn cached_managed_oom_swap( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

ManagedOOMSwap property Get the cached value of the ManagedOOMSwap property, or None if the property is not cached.

pub async fn receive_managed_oom_swap_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

ManagedOOMSwap property Create a stream for the ManagedOOMSwap property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn mark(&self) -> Result<i32>

Mark property

pub fn cached_mark( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

Mark property Get the cached value of the Mark property, or None if the property is not cached.

pub async fn receive_mark_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

Mark property Create a stream for the Mark property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn max_connections(&self) -> Result<u32>

MaxConnections property

pub fn cached_max_connections( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

MaxConnections property Get the cached value of the MaxConnections property, or None if the property is not cached.

pub async fn receive_max_connections_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

MaxConnections property Create a stream for the MaxConnections property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn max_connections_per_source(&self) -> Result<u32>

MaxConnectionsPerSource property

pub fn cached_max_connections_per_source( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

MaxConnectionsPerSource property Get the cached value of the MaxConnectionsPerSource property, or None if the property is not cached.

pub async fn receive_max_connections_per_source_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

MaxConnectionsPerSource property Create a stream for the MaxConnectionsPerSource property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn memory_accounting(&self) -> Result<bool>

MemoryAccounting property

pub fn cached_memory_accounting( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

MemoryAccounting property Get the cached value of the MemoryAccounting property, or None if the property is not cached.

pub async fn receive_memory_accounting_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

MemoryAccounting property Create a stream for the MemoryAccounting property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn memory_available(&self) -> Result<u64>

MemoryAvailable property

pub fn cached_memory_available( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

MemoryAvailable property Get the cached value of the MemoryAvailable property, or None if the property is not cached.

pub async fn receive_memory_available_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

MemoryAvailable property Create a stream for the MemoryAvailable property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn memory_current(&self) -> Result<u64>

MemoryCurrent property

pub fn cached_memory_current( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

MemoryCurrent property Get the cached value of the MemoryCurrent property, or None if the property is not cached.

pub async fn receive_memory_current_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

MemoryCurrent property Create a stream for the MemoryCurrent property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn memory_deny_write_execute(&self) -> Result<bool>

MemoryDenyWriteExecute property

pub fn cached_memory_deny_write_execute( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

MemoryDenyWriteExecute property Get the cached value of the MemoryDenyWriteExecute property, or None if the property is not cached.

pub async fn receive_memory_deny_write_execute_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

MemoryDenyWriteExecute property Create a stream for the MemoryDenyWriteExecute property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn memory_high(&self) -> Result<u64>

MemoryHigh property

pub fn cached_memory_high( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

MemoryHigh property Get the cached value of the MemoryHigh property, or None if the property is not cached.

pub async fn receive_memory_high_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

MemoryHigh property Create a stream for the MemoryHigh property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn memory_limit(&self) -> Result<u64>

MemoryLimit property

pub fn cached_memory_limit( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

MemoryLimit property Get the cached value of the MemoryLimit property, or None if the property is not cached.

pub async fn receive_memory_limit_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

MemoryLimit property Create a stream for the MemoryLimit property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn memory_low(&self) -> Result<u64>

MemoryLow property

pub fn cached_memory_low( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

MemoryLow property Get the cached value of the MemoryLow property, or None if the property is not cached.

pub async fn receive_memory_low_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

MemoryLow property Create a stream for the MemoryLow property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn memory_max(&self) -> Result<u64>

MemoryMax property

pub fn cached_memory_max( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

MemoryMax property Get the cached value of the MemoryMax property, or None if the property is not cached.

pub async fn receive_memory_max_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

MemoryMax property Create a stream for the MemoryMax property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn memory_min(&self) -> Result<u64>

MemoryMin property

pub fn cached_memory_min( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

MemoryMin property Get the cached value of the MemoryMin property, or None if the property is not cached.

pub async fn receive_memory_min_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

MemoryMin property Create a stream for the MemoryMin property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn memory_swap_max(&self) -> Result<u64>

MemorySwapMax property

pub fn cached_memory_swap_max( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

MemorySwapMax property Get the cached value of the MemorySwapMax property, or None if the property is not cached.

pub async fn receive_memory_swap_max_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

MemorySwapMax property Create a stream for the MemorySwapMax property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn message_queue_max_messages(&self) -> Result<i64>

MessageQueueMaxMessages property

pub fn cached_message_queue_max_messages( &self, ) -> Result<Option<<Result<i64> as ResultAdapter>::Ok>, <Result<i64> as ResultAdapter>::Err>

MessageQueueMaxMessages property Get the cached value of the MessageQueueMaxMessages property, or None if the property is not cached.

pub async fn receive_message_queue_max_messages_changed( &self, ) -> PropertyStream<'p, <Result<i64> as ResultAdapter>::Ok>

MessageQueueMaxMessages property Create a stream for the MessageQueueMaxMessages property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn message_queue_message_size(&self) -> Result<i64>

MessageQueueMessageSize property

pub fn cached_message_queue_message_size( &self, ) -> Result<Option<<Result<i64> as ResultAdapter>::Ok>, <Result<i64> as ResultAdapter>::Err>

MessageQueueMessageSize property Get the cached value of the MessageQueueMessageSize property, or None if the property is not cached.

pub async fn receive_message_queue_message_size_changed( &self, ) -> PropertyStream<'p, <Result<i64> as ResultAdapter>::Ok>

MessageQueueMessageSize property Create a stream for the MessageQueueMessageSize property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn mount_apivfs(&self) -> Result<bool>

MountAPIVFS property

pub fn cached_mount_apivfs( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

MountAPIVFS property Get the cached value of the MountAPIVFS property, or None if the property is not cached.

pub async fn receive_mount_apivfs_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

MountAPIVFS property Create a stream for the MountAPIVFS property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn mount_flags(&self) -> Result<u64>

MountFlags property

pub fn cached_mount_flags( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

MountFlags property Get the cached value of the MountFlags property, or None if the property is not cached.

pub async fn receive_mount_flags_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

MountFlags property Create a stream for the MountFlags property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn mount_images(&self) -> Result<Vec<MountImage>>

MountImages property

pub fn cached_mount_images( &self, ) -> Result<Option<<Result<Vec<MountImage>> as ResultAdapter>::Ok>, <Result<Vec<MountImage>> as ResultAdapter>::Err>

MountImages property Get the cached value of the MountImages property, or None if the property is not cached.

pub async fn receive_mount_images_changed( &self, ) -> PropertyStream<'p, <Result<Vec<MountImage>> as ResultAdapter>::Ok>

MountImages property Create a stream for the MountImages property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn n_accepted(&self) -> Result<u32>

NAccepted property

pub fn cached_n_accepted( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

NAccepted property Get the cached value of the NAccepted property, or None if the property is not cached.

pub async fn receive_n_accepted_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

NAccepted property Create a stream for the NAccepted property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn n_connections(&self) -> Result<u32>

NConnections property

pub fn cached_n_connections( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

NConnections property Get the cached value of the NConnections property, or None if the property is not cached.

pub async fn receive_n_connections_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

NConnections property Create a stream for the NConnections property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn n_refused(&self) -> Result<u32>

NRefused property

pub fn cached_n_refused( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

NRefused property Get the cached value of the NRefused property, or None if the property is not cached.

pub async fn receive_n_refused_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

NRefused property Create a stream for the NRefused property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn numa_mask(&self) -> Result<Vec<u8>>

NUMAMask property

pub fn cached_numa_mask( &self, ) -> Result<Option<<Result<Vec<u8>> as ResultAdapter>::Ok>, <Result<Vec<u8>> as ResultAdapter>::Err>

NUMAMask property Get the cached value of the NUMAMask property, or None if the property is not cached.

pub async fn receive_numa_mask_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

NUMAMask property Create a stream for the NUMAMask property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn numa_policy(&self) -> Result<i32>

NUMAPolicy property

pub fn cached_numa_policy( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

NUMAPolicy property Get the cached value of the NUMAPolicy property, or None if the property is not cached.

pub async fn receive_numa_policy_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

NUMAPolicy property Create a stream for the NUMAPolicy property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn network_namespace_path(&self) -> Result<String>

NetworkNamespacePath property

pub fn cached_network_namespace_path( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

NetworkNamespacePath property Get the cached value of the NetworkNamespacePath property, or None if the property is not cached.

pub async fn receive_network_namespace_path_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

NetworkNamespacePath property Create a stream for the NetworkNamespacePath property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn nice(&self) -> Result<i32>

Nice property

pub fn cached_nice( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

Nice property Get the cached value of the Nice property, or None if the property is not cached.

pub async fn receive_nice_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

Nice property Create a stream for the Nice property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn no_delay(&self) -> Result<bool>

NoDelay property

pub fn cached_no_delay( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

NoDelay property Get the cached value of the NoDelay property, or None if the property is not cached.

pub async fn receive_no_delay_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

NoDelay property Create a stream for the NoDelay property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn no_exec_paths(&self) -> Result<Vec<String>>

NoExecPaths property

pub fn cached_no_exec_paths( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

NoExecPaths property Get the cached value of the NoExecPaths property, or None if the property is not cached.

pub async fn receive_no_exec_paths_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

NoExecPaths property Create a stream for the NoExecPaths property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn no_new_privileges(&self) -> Result<bool>

NoNewPrivileges property

pub fn cached_no_new_privileges( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

NoNewPrivileges property Get the cached value of the NoNewPrivileges property, or None if the property is not cached.

pub async fn receive_no_new_privileges_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

NoNewPrivileges property Create a stream for the NoNewPrivileges property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn non_blocking(&self) -> Result<bool>

NonBlocking property

pub fn cached_non_blocking( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

NonBlocking property Get the cached value of the NonBlocking property, or None if the property is not cached.

pub async fn receive_non_blocking_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

NonBlocking property Create a stream for the NonBlocking property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn oom_score_adjust(&self) -> Result<i32>

OOMScoreAdjust property

pub fn cached_oom_score_adjust( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

OOMScoreAdjust property Get the cached value of the OOMScoreAdjust property, or None if the property is not cached.

pub async fn receive_oom_score_adjust_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

OOMScoreAdjust property Create a stream for the OOMScoreAdjust property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn pam_name(&self) -> Result<String>

PAMName property

pub fn cached_pam_name( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

PAMName property Get the cached value of the PAMName property, or None if the property is not cached.

pub async fn receive_pam_name_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

PAMName property Create a stream for the PAMName property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn pass_credentials(&self) -> Result<bool>

PassCredentials property

pub fn cached_pass_credentials( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

PassCredentials property Get the cached value of the PassCredentials property, or None if the property is not cached.

pub async fn receive_pass_credentials_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

PassCredentials property Create a stream for the PassCredentials property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn pass_environment(&self) -> Result<Vec<String>>

PassEnvironment property

pub fn cached_pass_environment( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

PassEnvironment property Get the cached value of the PassEnvironment property, or None if the property is not cached.

pub async fn receive_pass_environment_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

PassEnvironment property Create a stream for the PassEnvironment property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn pass_packet_info(&self) -> Result<bool>

PassPacketInfo property

pub fn cached_pass_packet_info( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

PassPacketInfo property Get the cached value of the PassPacketInfo property, or None if the property is not cached.

pub async fn receive_pass_packet_info_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

PassPacketInfo property Create a stream for the PassPacketInfo property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn pass_security(&self) -> Result<bool>

PassSecurity property

pub fn cached_pass_security( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

PassSecurity property Get the cached value of the PassSecurity property, or None if the property is not cached.

pub async fn receive_pass_security_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

PassSecurity property Create a stream for the PassSecurity property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn personality(&self) -> Result<String>

Personality property

pub fn cached_personality( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Personality property Get the cached value of the Personality property, or None if the property is not cached.

pub async fn receive_personality_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Personality property Create a stream for the Personality property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn pipe_size(&self) -> Result<u64>

PipeSize property

pub fn cached_pipe_size( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

PipeSize property Get the cached value of the PipeSize property, or None if the property is not cached.

pub async fn receive_pipe_size_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

PipeSize property Create a stream for the PipeSize property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn priority(&self) -> Result<i32>

Priority property

pub fn cached_priority( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

Priority property Get the cached value of the Priority property, or None if the property is not cached.

pub async fn receive_priority_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

Priority property Create a stream for the Priority property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn private_devices(&self) -> Result<bool>

PrivateDevices property

pub fn cached_private_devices( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

PrivateDevices property Get the cached value of the PrivateDevices property, or None if the property is not cached.

pub async fn receive_private_devices_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

PrivateDevices property Create a stream for the PrivateDevices property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn private_ipc(&self) -> Result<bool>

PrivateIPC property

pub fn cached_private_ipc( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

PrivateIPC property Get the cached value of the PrivateIPC property, or None if the property is not cached.

pub async fn receive_private_ipc_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

PrivateIPC property Create a stream for the PrivateIPC property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn private_mounts(&self) -> Result<bool>

PrivateMounts property

pub fn cached_private_mounts( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

PrivateMounts property Get the cached value of the PrivateMounts property, or None if the property is not cached.

pub async fn receive_private_mounts_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

PrivateMounts property Create a stream for the PrivateMounts property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn private_network(&self) -> Result<bool>

PrivateNetwork property

pub fn cached_private_network( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

PrivateNetwork property Get the cached value of the PrivateNetwork property, or None if the property is not cached.

pub async fn receive_private_network_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

PrivateNetwork property Create a stream for the PrivateNetwork property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn private_tmp(&self) -> Result<bool>

PrivateTmp property

pub fn cached_private_tmp( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

PrivateTmp property Get the cached value of the PrivateTmp property, or None if the property is not cached.

pub async fn receive_private_tmp_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

PrivateTmp property Create a stream for the PrivateTmp property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn private_users(&self) -> Result<bool>

PrivateUsers property

pub fn cached_private_users( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

PrivateUsers property Get the cached value of the PrivateUsers property, or None if the property is not cached.

pub async fn receive_private_users_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

PrivateUsers property Create a stream for the PrivateUsers property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn proc_subset(&self) -> Result<String>

ProcSubset property

pub fn cached_proc_subset( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

ProcSubset property Get the cached value of the ProcSubset property, or None if the property is not cached.

pub async fn receive_proc_subset_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

ProcSubset property Create a stream for the ProcSubset property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn protect_clock(&self) -> Result<bool>

ProtectClock property

pub fn cached_protect_clock( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

ProtectClock property Get the cached value of the ProtectClock property, or None if the property is not cached.

pub async fn receive_protect_clock_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

ProtectClock property Create a stream for the ProtectClock property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn protect_control_groups(&self) -> Result<bool>

ProtectControlGroups property

pub fn cached_protect_control_groups( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

ProtectControlGroups property Get the cached value of the ProtectControlGroups property, or None if the property is not cached.

pub async fn receive_protect_control_groups_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

ProtectControlGroups property Create a stream for the ProtectControlGroups property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn protect_home(&self) -> Result<String>

ProtectHome property

pub fn cached_protect_home( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

ProtectHome property Get the cached value of the ProtectHome property, or None if the property is not cached.

pub async fn receive_protect_home_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

ProtectHome property Create a stream for the ProtectHome property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn protect_hostname(&self) -> Result<bool>

ProtectHostname property

pub fn cached_protect_hostname( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

ProtectHostname property Get the cached value of the ProtectHostname property, or None if the property is not cached.

pub async fn receive_protect_hostname_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

ProtectHostname property Create a stream for the ProtectHostname property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn protect_kernel_logs(&self) -> Result<bool>

ProtectKernelLogs property

pub fn cached_protect_kernel_logs( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

ProtectKernelLogs property Get the cached value of the ProtectKernelLogs property, or None if the property is not cached.

pub async fn receive_protect_kernel_logs_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

ProtectKernelLogs property Create a stream for the ProtectKernelLogs property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn protect_kernel_modules(&self) -> Result<bool>

ProtectKernelModules property

pub fn cached_protect_kernel_modules( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

ProtectKernelModules property Get the cached value of the ProtectKernelModules property, or None if the property is not cached.

pub async fn receive_protect_kernel_modules_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

ProtectKernelModules property Create a stream for the ProtectKernelModules property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn protect_kernel_tunables(&self) -> Result<bool>

ProtectKernelTunables property

pub fn cached_protect_kernel_tunables( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

ProtectKernelTunables property Get the cached value of the ProtectKernelTunables property, or None if the property is not cached.

pub async fn receive_protect_kernel_tunables_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

ProtectKernelTunables property Create a stream for the ProtectKernelTunables property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn protect_proc(&self) -> Result<String>

ProtectProc property

pub fn cached_protect_proc( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

ProtectProc property Get the cached value of the ProtectProc property, or None if the property is not cached.

pub async fn receive_protect_proc_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

ProtectProc property Create a stream for the ProtectProc property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn protect_system(&self) -> Result<String>

ProtectSystem property

pub fn cached_protect_system( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

ProtectSystem property Get the cached value of the ProtectSystem property, or None if the property is not cached.

pub async fn receive_protect_system_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

ProtectSystem property Create a stream for the ProtectSystem property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn read_only_paths(&self) -> Result<Vec<String>>

ReadOnlyPaths property

pub fn cached_read_only_paths( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

ReadOnlyPaths property Get the cached value of the ReadOnlyPaths property, or None if the property is not cached.

pub async fn receive_read_only_paths_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

ReadOnlyPaths property Create a stream for the ReadOnlyPaths property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn read_write_paths(&self) -> Result<Vec<String>>

ReadWritePaths property

pub fn cached_read_write_paths( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

ReadWritePaths property Get the cached value of the ReadWritePaths property, or None if the property is not cached.

pub async fn receive_read_write_paths_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

ReadWritePaths property Create a stream for the ReadWritePaths property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn receive_buffer(&self) -> Result<u64>

ReceiveBuffer property

pub fn cached_receive_buffer( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

ReceiveBuffer property Get the cached value of the ReceiveBuffer property, or None if the property is not cached.

pub async fn receive_receive_buffer_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

ReceiveBuffer property Create a stream for the ReceiveBuffer property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn remove_ipc(&self) -> Result<bool>

RemoveIPC property

pub fn cached_remove_ipc( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

RemoveIPC property Get the cached value of the RemoveIPC property, or None if the property is not cached.

pub async fn receive_remove_ipc_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

RemoveIPC property Create a stream for the RemoveIPC property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn remove_on_stop(&self) -> Result<bool>

RemoveOnStop property

pub fn cached_remove_on_stop( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

RemoveOnStop property Get the cached value of the RemoveOnStop property, or None if the property is not cached.

pub async fn receive_remove_on_stop_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

RemoveOnStop property Create a stream for the RemoveOnStop property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn restart_kill_signal(&self) -> Result<i32>

RestartKillSignal property

pub fn cached_restart_kill_signal( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

RestartKillSignal property Get the cached value of the RestartKillSignal property, or None if the property is not cached.

pub async fn receive_restart_kill_signal_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

RestartKillSignal property Create a stream for the RestartKillSignal property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn restrict_address_families(&self) -> Result<(bool, Vec<String>)>

RestrictAddressFamilies property

pub fn cached_restrict_address_families( &self, ) -> Result<Option<<Result<(bool, Vec<String>)> as ResultAdapter>::Ok>, <Result<(bool, Vec<String>)> as ResultAdapter>::Err>

RestrictAddressFamilies property Get the cached value of the RestrictAddressFamilies property, or None if the property is not cached.

pub async fn receive_restrict_address_families_changed( &self, ) -> PropertyStream<'p, <Result<(bool, Vec<String>)> as ResultAdapter>::Ok>

RestrictAddressFamilies property Create a stream for the RestrictAddressFamilies property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn restrict_file_systems(&self) -> Result<(bool, Vec<String>)>

RestrictFileSystems property

pub fn cached_restrict_file_systems( &self, ) -> Result<Option<<Result<(bool, Vec<String>)> as ResultAdapter>::Ok>, <Result<(bool, Vec<String>)> as ResultAdapter>::Err>

RestrictFileSystems property Get the cached value of the RestrictFileSystems property, or None if the property is not cached.

pub async fn receive_restrict_file_systems_changed( &self, ) -> PropertyStream<'p, <Result<(bool, Vec<String>)> as ResultAdapter>::Ok>

RestrictFileSystems property Create a stream for the RestrictFileSystems property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn restrict_namespaces(&self) -> Result<u64>

RestrictNamespaces property

pub fn cached_restrict_namespaces( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

RestrictNamespaces property Get the cached value of the RestrictNamespaces property, or None if the property is not cached.

pub async fn receive_restrict_namespaces_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

RestrictNamespaces property Create a stream for the RestrictNamespaces property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn restrict_network_interfaces(&self) -> Result<(bool, Vec<String>)>

RestrictNetworkInterfaces property

pub fn cached_restrict_network_interfaces( &self, ) -> Result<Option<<Result<(bool, Vec<String>)> as ResultAdapter>::Ok>, <Result<(bool, Vec<String>)> as ResultAdapter>::Err>

RestrictNetworkInterfaces property Get the cached value of the RestrictNetworkInterfaces property, or None if the property is not cached.

pub async fn receive_restrict_network_interfaces_changed( &self, ) -> PropertyStream<'p, <Result<(bool, Vec<String>)> as ResultAdapter>::Ok>

RestrictNetworkInterfaces property Create a stream for the RestrictNetworkInterfaces property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn restrict_realtime(&self) -> Result<bool>

RestrictRealtime property

pub fn cached_restrict_realtime( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

RestrictRealtime property Get the cached value of the RestrictRealtime property, or None if the property is not cached.

pub async fn receive_restrict_realtime_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

RestrictRealtime property Create a stream for the RestrictRealtime property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn restrict_suidsgid(&self) -> Result<bool>

RestrictSUIDSGID property

pub fn cached_restrict_suidsgid( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

RestrictSUIDSGID property Get the cached value of the RestrictSUIDSGID property, or None if the property is not cached.

pub async fn receive_restrict_suidsgid_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

RestrictSUIDSGID property Create a stream for the RestrictSUIDSGID property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn result(&self) -> Result<String>

Result property

pub fn cached_result( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Result property Get the cached value of the Result property, or None if the property is not cached.

pub async fn receive_result_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Result property Create a stream for the Result property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn reuse_port(&self) -> Result<bool>

ReusePort property

pub fn cached_reuse_port( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

ReusePort property Get the cached value of the ReusePort property, or None if the property is not cached.

pub async fn receive_reuse_port_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

ReusePort property Create a stream for the ReusePort property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn root_directory(&self) -> Result<String>

RootDirectory property

pub fn cached_root_directory( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

RootDirectory property Get the cached value of the RootDirectory property, or None if the property is not cached.

pub async fn receive_root_directory_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

RootDirectory property Create a stream for the RootDirectory property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn root_hash(&self) -> Result<Vec<u8>>

RootHash property

pub fn cached_root_hash( &self, ) -> Result<Option<<Result<Vec<u8>> as ResultAdapter>::Ok>, <Result<Vec<u8>> as ResultAdapter>::Err>

RootHash property Get the cached value of the RootHash property, or None if the property is not cached.

pub async fn receive_root_hash_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

RootHash property Create a stream for the RootHash property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn root_hash_path(&self) -> Result<String>

RootHashPath property

pub fn cached_root_hash_path( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

RootHashPath property Get the cached value of the RootHashPath property, or None if the property is not cached.

pub async fn receive_root_hash_path_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

RootHashPath property Create a stream for the RootHashPath property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn root_hash_signature(&self) -> Result<Vec<u8>>

RootHashSignature property

pub fn cached_root_hash_signature( &self, ) -> Result<Option<<Result<Vec<u8>> as ResultAdapter>::Ok>, <Result<Vec<u8>> as ResultAdapter>::Err>

RootHashSignature property Get the cached value of the RootHashSignature property, or None if the property is not cached.

pub async fn receive_root_hash_signature_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

RootHashSignature property Create a stream for the RootHashSignature property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn root_hash_signature_path(&self) -> Result<String>

RootHashSignaturePath property

pub fn cached_root_hash_signature_path( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

RootHashSignaturePath property Get the cached value of the RootHashSignaturePath property, or None if the property is not cached.

pub async fn receive_root_hash_signature_path_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

RootHashSignaturePath property Create a stream for the RootHashSignaturePath property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn root_image(&self) -> Result<String>

RootImage property

pub fn cached_root_image( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

RootImage property Get the cached value of the RootImage property, or None if the property is not cached.

pub async fn receive_root_image_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

RootImage property Create a stream for the RootImage property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn root_image_options(&self) -> Result<Vec<(String, String)>>

RootImageOptions property

pub fn cached_root_image_options( &self, ) -> Result<Option<<Result<Vec<(String, String)>> as ResultAdapter>::Ok>, <Result<Vec<(String, String)>> as ResultAdapter>::Err>

RootImageOptions property Get the cached value of the RootImageOptions property, or None if the property is not cached.

pub async fn receive_root_image_options_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

RootImageOptions property Create a stream for the RootImageOptions property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn root_verity(&self) -> Result<String>

RootVerity property

pub fn cached_root_verity( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

RootVerity property Get the cached value of the RootVerity property, or None if the property is not cached.

pub async fn receive_root_verity_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

RootVerity property Create a stream for the RootVerity property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn runtime_directory(&self) -> Result<Vec<String>>

RuntimeDirectory property

pub fn cached_runtime_directory( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

RuntimeDirectory property Get the cached value of the RuntimeDirectory property, or None if the property is not cached.

pub async fn receive_runtime_directory_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

RuntimeDirectory property Create a stream for the RuntimeDirectory property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn runtime_directory_mode(&self) -> Result<u32>

RuntimeDirectoryMode property

pub fn cached_runtime_directory_mode( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

RuntimeDirectoryMode property Get the cached value of the RuntimeDirectoryMode property, or None if the property is not cached.

pub async fn receive_runtime_directory_mode_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

RuntimeDirectoryMode property Create a stream for the RuntimeDirectoryMode property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn runtime_directory_preserve(&self) -> Result<String>

RuntimeDirectoryPreserve property

pub fn cached_runtime_directory_preserve( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

RuntimeDirectoryPreserve property Get the cached value of the RuntimeDirectoryPreserve property, or None if the property is not cached.

pub async fn receive_runtime_directory_preserve_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

RuntimeDirectoryPreserve property Create a stream for the RuntimeDirectoryPreserve property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn runtime_directory_symlink(&self) -> Result<Vec<DirectorySymlink>>

RuntimeDirectorySymlink property

pub fn cached_runtime_directory_symlink( &self, ) -> Result<Option<<Result<Vec<DirectorySymlink>> as ResultAdapter>::Ok>, <Result<Vec<DirectorySymlink>> as ResultAdapter>::Err>

RuntimeDirectorySymlink property Get the cached value of the RuntimeDirectorySymlink property, or None if the property is not cached.

pub async fn receive_runtime_directory_symlink_changed( &self, ) -> PropertyStream<'p, <Result<Vec<DirectorySymlink>> as ResultAdapter>::Ok>

RuntimeDirectorySymlink property Create a stream for the RuntimeDirectorySymlink property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn selinux_context(&self) -> Result<(bool, String)>

SELinuxContext property

pub fn cached_selinux_context( &self, ) -> Result<Option<<Result<(bool, String)> as ResultAdapter>::Ok>, <Result<(bool, String)> as ResultAdapter>::Err>

SELinuxContext property Get the cached value of the SELinuxContext property, or None if the property is not cached.

pub async fn receive_selinux_context_changed( &self, ) -> PropertyStream<'p, <Result<(bool, String)> as ResultAdapter>::Ok>

SELinuxContext property Create a stream for the SELinuxContext property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn same_process_group(&self) -> Result<bool>

SameProcessGroup property

pub fn cached_same_process_group( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

SameProcessGroup property Get the cached value of the SameProcessGroup property, or None if the property is not cached.

pub async fn receive_same_process_group_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

SameProcessGroup property Create a stream for the SameProcessGroup property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn secure_bits(&self) -> Result<i32>

SecureBits property

pub fn cached_secure_bits( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

SecureBits property Get the cached value of the SecureBits property, or None if the property is not cached.

pub async fn receive_secure_bits_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

SecureBits property Create a stream for the SecureBits property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn send_buffer(&self) -> Result<u64>

SendBuffer property

pub fn cached_send_buffer( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

SendBuffer property Get the cached value of the SendBuffer property, or None if the property is not cached.

pub async fn receive_send_buffer_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

SendBuffer property Create a stream for the SendBuffer property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn send_sighup(&self) -> Result<bool>

SendSIGHUP property

pub fn cached_send_sighup( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

SendSIGHUP property Get the cached value of the SendSIGHUP property, or None if the property is not cached.

pub async fn receive_send_sighup_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

SendSIGHUP property Create a stream for the SendSIGHUP property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn send_sigkill(&self) -> Result<bool>

SendSIGKILL property

pub fn cached_send_sigkill( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

SendSIGKILL property Get the cached value of the SendSIGKILL property, or None if the property is not cached.

pub async fn receive_send_sigkill_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

SendSIGKILL property Create a stream for the SendSIGKILL property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn set_credential(&self) -> Result<Vec<(String, Vec<u8>)>>

SetCredential property

pub fn cached_set_credential( &self, ) -> Result<Option<<Result<Vec<(String, Vec<u8>)>> as ResultAdapter>::Ok>, <Result<Vec<(String, Vec<u8>)>> as ResultAdapter>::Err>

SetCredential property Get the cached value of the SetCredential property, or None if the property is not cached.

pub async fn receive_set_credential_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, Vec<u8>)>> as ResultAdapter>::Ok>

SetCredential property Create a stream for the SetCredential property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn set_credential_encrypted(&self) -> Result<Vec<(String, Vec<u8>)>>

SetCredentialEncrypted property

pub fn cached_set_credential_encrypted( &self, ) -> Result<Option<<Result<Vec<(String, Vec<u8>)>> as ResultAdapter>::Ok>, <Result<Vec<(String, Vec<u8>)>> as ResultAdapter>::Err>

SetCredentialEncrypted property Get the cached value of the SetCredentialEncrypted property, or None if the property is not cached.

pub async fn receive_set_credential_encrypted_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, Vec<u8>)>> as ResultAdapter>::Ok>

SetCredentialEncrypted property Create a stream for the SetCredentialEncrypted property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn slice(&self) -> Result<String>

Slice property

pub fn cached_slice( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Slice property Get the cached value of the Slice property, or None if the property is not cached.

pub async fn receive_slice_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Slice property Create a stream for the Slice property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn smack_label(&self) -> Result<String>

SmackLabel property

pub fn cached_smack_label( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

SmackLabel property Get the cached value of the SmackLabel property, or None if the property is not cached.

pub async fn receive_smack_label_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

SmackLabel property Create a stream for the SmackLabel property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn smack_label_ip_in(&self) -> Result<String>

SmackLabelIPIn property

pub fn cached_smack_label_ip_in( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

SmackLabelIPIn property Get the cached value of the SmackLabelIPIn property, or None if the property is not cached.

pub async fn receive_smack_label_ip_in_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

SmackLabelIPIn property Create a stream for the SmackLabelIPIn property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn smack_label_ip_out(&self) -> Result<String>

SmackLabelIPOut property

pub fn cached_smack_label_ip_out( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

SmackLabelIPOut property Get the cached value of the SmackLabelIPOut property, or None if the property is not cached.

pub async fn receive_smack_label_ip_out_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

SmackLabelIPOut property Create a stream for the SmackLabelIPOut property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn smack_process_label(&self) -> Result<(bool, String)>

SmackProcessLabel property

pub fn cached_smack_process_label( &self, ) -> Result<Option<<Result<(bool, String)> as ResultAdapter>::Ok>, <Result<(bool, String)> as ResultAdapter>::Err>

SmackProcessLabel property Get the cached value of the SmackProcessLabel property, or None if the property is not cached.

pub async fn receive_smack_process_label_changed( &self, ) -> PropertyStream<'p, <Result<(bool, String)> as ResultAdapter>::Ok>

SmackProcessLabel property Create a stream for the SmackProcessLabel property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn socket_bind_allow(&self) -> Result<Vec<(i32, i32, u16, u16)>>

SocketBindAllow property

pub fn cached_socket_bind_allow( &self, ) -> Result<Option<<Result<Vec<(i32, i32, u16, u16)>> as ResultAdapter>::Ok>, <Result<Vec<(i32, i32, u16, u16)>> as ResultAdapter>::Err>

SocketBindAllow property Get the cached value of the SocketBindAllow property, or None if the property is not cached.

pub async fn receive_socket_bind_allow_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(i32, i32, u16, u16)>> as ResultAdapter>::Ok>

SocketBindAllow property Create a stream for the SocketBindAllow property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn socket_bind_deny(&self) -> Result<Vec<(i32, i32, u16, u16)>>

SocketBindDeny property

pub fn cached_socket_bind_deny( &self, ) -> Result<Option<<Result<Vec<(i32, i32, u16, u16)>> as ResultAdapter>::Ok>, <Result<Vec<(i32, i32, u16, u16)>> as ResultAdapter>::Err>

SocketBindDeny property Get the cached value of the SocketBindDeny property, or None if the property is not cached.

pub async fn receive_socket_bind_deny_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(i32, i32, u16, u16)>> as ResultAdapter>::Ok>

SocketBindDeny property Create a stream for the SocketBindDeny property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn socket_group(&self) -> Result<String>

SocketGroup property

pub fn cached_socket_group( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

SocketGroup property Get the cached value of the SocketGroup property, or None if the property is not cached.

pub async fn receive_socket_group_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

SocketGroup property Create a stream for the SocketGroup property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn socket_mode(&self) -> Result<u32>

SocketMode property

pub fn cached_socket_mode( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

SocketMode property Get the cached value of the SocketMode property, or None if the property is not cached.

pub async fn receive_socket_mode_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

SocketMode property Create a stream for the SocketMode property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn socket_protocol(&self) -> Result<i32>

SocketProtocol property

pub fn cached_socket_protocol( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

SocketProtocol property Get the cached value of the SocketProtocol property, or None if the property is not cached.

pub async fn receive_socket_protocol_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

SocketProtocol property Create a stream for the SocketProtocol property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn socket_user(&self) -> Result<String>

SocketUser property

pub fn cached_socket_user( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

SocketUser property Get the cached value of the SocketUser property, or None if the property is not cached.

pub async fn receive_socket_user_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

SocketUser property Create a stream for the SocketUser property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn standard_error(&self) -> Result<String>

StandardError property

pub fn cached_standard_error( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

StandardError property Get the cached value of the StandardError property, or None if the property is not cached.

pub async fn receive_standard_error_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

StandardError property Create a stream for the StandardError property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn standard_error_file_descriptor_name(&self) -> Result<String>

StandardErrorFileDescriptorName property

pub fn cached_standard_error_file_descriptor_name( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

StandardErrorFileDescriptorName property Get the cached value of the StandardErrorFileDescriptorName property, or None if the property is not cached.

pub async fn receive_standard_error_file_descriptor_name_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

StandardErrorFileDescriptorName property Create a stream for the StandardErrorFileDescriptorName property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn standard_input(&self) -> Result<String>

StandardInput property

pub fn cached_standard_input( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

StandardInput property Get the cached value of the StandardInput property, or None if the property is not cached.

pub async fn receive_standard_input_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

StandardInput property Create a stream for the StandardInput property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn standard_input_data(&self) -> Result<Vec<u8>>

StandardInputData property

pub fn cached_standard_input_data( &self, ) -> Result<Option<<Result<Vec<u8>> as ResultAdapter>::Ok>, <Result<Vec<u8>> as ResultAdapter>::Err>

StandardInputData property Get the cached value of the StandardInputData property, or None if the property is not cached.

pub async fn receive_standard_input_data_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

StandardInputData property Create a stream for the StandardInputData property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn standard_input_file_descriptor_name(&self) -> Result<String>

StandardInputFileDescriptorName property

pub fn cached_standard_input_file_descriptor_name( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

StandardInputFileDescriptorName property Get the cached value of the StandardInputFileDescriptorName property, or None if the property is not cached.

pub async fn receive_standard_input_file_descriptor_name_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

StandardInputFileDescriptorName property Create a stream for the StandardInputFileDescriptorName property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn standard_output(&self) -> Result<String>

StandardOutput property

pub fn cached_standard_output( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

StandardOutput property Get the cached value of the StandardOutput property, or None if the property is not cached.

pub async fn receive_standard_output_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

StandardOutput property Create a stream for the StandardOutput property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn standard_output_file_descriptor_name(&self) -> Result<String>

StandardOutputFileDescriptorName property

pub fn cached_standard_output_file_descriptor_name( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

StandardOutputFileDescriptorName property Get the cached value of the StandardOutputFileDescriptorName property, or None if the property is not cached.

pub async fn receive_standard_output_file_descriptor_name_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

StandardOutputFileDescriptorName property Create a stream for the StandardOutputFileDescriptorName property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn startup_allowed_cpus(&self) -> Result<Vec<u8>>

StartupAllowedCPUs property

pub fn cached_startup_allowed_cpus( &self, ) -> Result<Option<<Result<Vec<u8>> as ResultAdapter>::Ok>, <Result<Vec<u8>> as ResultAdapter>::Err>

StartupAllowedCPUs property Get the cached value of the StartupAllowedCPUs property, or None if the property is not cached.

pub async fn receive_startup_allowed_cpus_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

StartupAllowedCPUs property Create a stream for the StartupAllowedCPUs property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn startup_allowed_memory_nodes(&self) -> Result<Vec<u8>>

StartupAllowedMemoryNodes property

pub fn cached_startup_allowed_memory_nodes( &self, ) -> Result<Option<<Result<Vec<u8>> as ResultAdapter>::Ok>, <Result<Vec<u8>> as ResultAdapter>::Err>

StartupAllowedMemoryNodes property Get the cached value of the StartupAllowedMemoryNodes property, or None if the property is not cached.

pub async fn receive_startup_allowed_memory_nodes_changed( &self, ) -> PropertyStream<'p, <Result<Vec<u8>> as ResultAdapter>::Ok>

StartupAllowedMemoryNodes property Create a stream for the StartupAllowedMemoryNodes property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn startup_block_io_weight(&self) -> Result<u64>

StartupBlockIOWeight property

pub fn cached_startup_block_io_weight( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

StartupBlockIOWeight property Get the cached value of the StartupBlockIOWeight property, or None if the property is not cached.

pub async fn receive_startup_block_io_weight_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

StartupBlockIOWeight property Create a stream for the StartupBlockIOWeight property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn startup_cpu_shares(&self) -> Result<u64>

StartupCPUShares property

pub fn cached_startup_cpu_shares( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

StartupCPUShares property Get the cached value of the StartupCPUShares property, or None if the property is not cached.

pub async fn receive_startup_cpu_shares_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

StartupCPUShares property Create a stream for the StartupCPUShares property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn startup_cpu_weight(&self) -> Result<u64>

StartupCPUWeight property

pub fn cached_startup_cpu_weight( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

StartupCPUWeight property Get the cached value of the StartupCPUWeight property, or None if the property is not cached.

pub async fn receive_startup_cpu_weight_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

StartupCPUWeight property Create a stream for the StartupCPUWeight property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn startup_io_weight(&self) -> Result<u64>

StartupIOWeight property

pub fn cached_startup_io_weight( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

StartupIOWeight property Get the cached value of the StartupIOWeight property, or None if the property is not cached.

pub async fn receive_startup_io_weight_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

StartupIOWeight property Create a stream for the StartupIOWeight property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn state_directory(&self) -> Result<Vec<String>>

StateDirectory property

pub fn cached_state_directory( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

StateDirectory property Get the cached value of the StateDirectory property, or None if the property is not cached.

pub async fn receive_state_directory_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

StateDirectory property Create a stream for the StateDirectory property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn state_directory_mode(&self) -> Result<u32>

StateDirectoryMode property

pub fn cached_state_directory_mode( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

StateDirectoryMode property Get the cached value of the StateDirectoryMode property, or None if the property is not cached.

pub async fn receive_state_directory_mode_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

StateDirectoryMode property Create a stream for the StateDirectoryMode property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn state_directory_symlink(&self) -> Result<Vec<DirectorySymlink>>

StateDirectorySymlink property

pub fn cached_state_directory_symlink( &self, ) -> Result<Option<<Result<Vec<DirectorySymlink>> as ResultAdapter>::Ok>, <Result<Vec<DirectorySymlink>> as ResultAdapter>::Err>

StateDirectorySymlink property Get the cached value of the StateDirectorySymlink property, or None if the property is not cached.

pub async fn receive_state_directory_symlink_changed( &self, ) -> PropertyStream<'p, <Result<Vec<DirectorySymlink>> as ResultAdapter>::Ok>

StateDirectorySymlink property Create a stream for the StateDirectorySymlink property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn supplementary_groups(&self) -> Result<Vec<String>>

SupplementaryGroups property

pub fn cached_supplementary_groups( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

SupplementaryGroups property Get the cached value of the SupplementaryGroups property, or None if the property is not cached.

pub async fn receive_supplementary_groups_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

SupplementaryGroups property Create a stream for the SupplementaryGroups property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn symlinks(&self) -> Result<Vec<String>>

Symlinks property

pub fn cached_symlinks( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

Symlinks property Get the cached value of the Symlinks property, or None if the property is not cached.

pub async fn receive_symlinks_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

Symlinks property Create a stream for the Symlinks property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn syslog_facility(&self) -> Result<i32>

SyslogFacility property

pub fn cached_syslog_facility( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

SyslogFacility property Get the cached value of the SyslogFacility property, or None if the property is not cached.

pub async fn receive_syslog_facility_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

SyslogFacility property Create a stream for the SyslogFacility property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn syslog_identifier(&self) -> Result<String>

SyslogIdentifier property

pub fn cached_syslog_identifier( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

SyslogIdentifier property Get the cached value of the SyslogIdentifier property, or None if the property is not cached.

pub async fn receive_syslog_identifier_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

SyslogIdentifier property Create a stream for the SyslogIdentifier property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn syslog_level(&self) -> Result<i32>

SyslogLevel property

pub fn cached_syslog_level( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

SyslogLevel property Get the cached value of the SyslogLevel property, or None if the property is not cached.

pub async fn receive_syslog_level_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

SyslogLevel property Create a stream for the SyslogLevel property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn syslog_level_prefix(&self) -> Result<bool>

SyslogLevelPrefix property

pub fn cached_syslog_level_prefix( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

SyslogLevelPrefix property Get the cached value of the SyslogLevelPrefix property, or None if the property is not cached.

pub async fn receive_syslog_level_prefix_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

SyslogLevelPrefix property Create a stream for the SyslogLevelPrefix property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn syslog_priority(&self) -> Result<i32>

SyslogPriority property

pub fn cached_syslog_priority( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

SyslogPriority property Get the cached value of the SyslogPriority property, or None if the property is not cached.

pub async fn receive_syslog_priority_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

SyslogPriority property Create a stream for the SyslogPriority property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn system_call_architectures(&self) -> Result<Vec<String>>

SystemCallArchitectures property

pub fn cached_system_call_architectures( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

SystemCallArchitectures property Get the cached value of the SystemCallArchitectures property, or None if the property is not cached.

pub async fn receive_system_call_architectures_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

SystemCallArchitectures property Create a stream for the SystemCallArchitectures property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn system_call_error_number(&self) -> Result<i32>

SystemCallErrorNumber property

pub fn cached_system_call_error_number( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

SystemCallErrorNumber property Get the cached value of the SystemCallErrorNumber property, or None if the property is not cached.

pub async fn receive_system_call_error_number_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

SystemCallErrorNumber property Create a stream for the SystemCallErrorNumber property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn system_call_filter(&self) -> Result<(bool, Vec<String>)>

SystemCallFilter property

pub fn cached_system_call_filter( &self, ) -> Result<Option<<Result<(bool, Vec<String>)> as ResultAdapter>::Ok>, <Result<(bool, Vec<String>)> as ResultAdapter>::Err>

SystemCallFilter property Get the cached value of the SystemCallFilter property, or None if the property is not cached.

pub async fn receive_system_call_filter_changed( &self, ) -> PropertyStream<'p, <Result<(bool, Vec<String>)> as ResultAdapter>::Ok>

SystemCallFilter property Create a stream for the SystemCallFilter property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn system_call_log(&self) -> Result<(bool, Vec<String>)>

SystemCallLog property

pub fn cached_system_call_log( &self, ) -> Result<Option<<Result<(bool, Vec<String>)> as ResultAdapter>::Ok>, <Result<(bool, Vec<String>)> as ResultAdapter>::Err>

SystemCallLog property Get the cached value of the SystemCallLog property, or None if the property is not cached.

pub async fn receive_system_call_log_changed( &self, ) -> PropertyStream<'p, <Result<(bool, Vec<String>)> as ResultAdapter>::Ok>

SystemCallLog property Create a stream for the SystemCallLog property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn tcp_congestion(&self) -> Result<String>

TCPCongestion property

pub fn cached_tcp_congestion( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

TCPCongestion property Get the cached value of the TCPCongestion property, or None if the property is not cached.

pub async fn receive_tcp_congestion_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

TCPCongestion property Create a stream for the TCPCongestion property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn tty_columns(&self) -> Result<u16>

TTYColumns property

pub fn cached_tty_columns( &self, ) -> Result<Option<<Result<u16> as ResultAdapter>::Ok>, <Result<u16> as ResultAdapter>::Err>

TTYColumns property Get the cached value of the TTYColumns property, or None if the property is not cached.

pub async fn receive_tty_columns_changed( &self, ) -> PropertyStream<'p, <Result<u16> as ResultAdapter>::Ok>

TTYColumns property Create a stream for the TTYColumns property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn tty_path(&self) -> Result<String>

TTYPath property

pub fn cached_tty_path( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

TTYPath property Get the cached value of the TTYPath property, or None if the property is not cached.

pub async fn receive_tty_path_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

TTYPath property Create a stream for the TTYPath property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn tty_reset(&self) -> Result<bool>

TTYReset property

pub fn cached_tty_reset( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

TTYReset property Get the cached value of the TTYReset property, or None if the property is not cached.

pub async fn receive_tty_reset_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

TTYReset property Create a stream for the TTYReset property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn tty_rows(&self) -> Result<u16>

TTYRows property

pub fn cached_tty_rows( &self, ) -> Result<Option<<Result<u16> as ResultAdapter>::Ok>, <Result<u16> as ResultAdapter>::Err>

TTYRows property Get the cached value of the TTYRows property, or None if the property is not cached.

pub async fn receive_tty_rows_changed( &self, ) -> PropertyStream<'p, <Result<u16> as ResultAdapter>::Ok>

TTYRows property Create a stream for the TTYRows property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn tty_vhangup(&self) -> Result<bool>

TTYVHangup property

pub fn cached_tty_vhangup( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

TTYVHangup property Get the cached value of the TTYVHangup property, or None if the property is not cached.

pub async fn receive_tty_vhangup_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

TTYVHangup property Create a stream for the TTYVHangup property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn tty_vtd_isallocate(&self) -> Result<bool>

TTYVTDisallocate property

pub fn cached_tty_vtd_isallocate( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

TTYVTDisallocate property Get the cached value of the TTYVTDisallocate property, or None if the property is not cached.

pub async fn receive_tty_vtd_isallocate_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

TTYVTDisallocate property Create a stream for the TTYVTDisallocate property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn tasks_accounting(&self) -> Result<bool>

TasksAccounting property

pub fn cached_tasks_accounting( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

TasksAccounting property Get the cached value of the TasksAccounting property, or None if the property is not cached.

pub async fn receive_tasks_accounting_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

TasksAccounting property Create a stream for the TasksAccounting property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn tasks_current(&self) -> Result<u64>

TasksCurrent property

pub fn cached_tasks_current( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

TasksCurrent property Get the cached value of the TasksCurrent property, or None if the property is not cached.

pub async fn receive_tasks_current_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

TasksCurrent property Create a stream for the TasksCurrent property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn tasks_max(&self) -> Result<u64>

TasksMax property

pub fn cached_tasks_max( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

TasksMax property Get the cached value of the TasksMax property, or None if the property is not cached.

pub async fn receive_tasks_max_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

TasksMax property Create a stream for the TasksMax property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn temporary_file_system(&self) -> Result<Vec<(String, String)>>

TemporaryFileSystem property

pub fn cached_temporary_file_system( &self, ) -> Result<Option<<Result<Vec<(String, String)>> as ResultAdapter>::Ok>, <Result<Vec<(String, String)>> as ResultAdapter>::Err>

TemporaryFileSystem property Get the cached value of the TemporaryFileSystem property, or None if the property is not cached.

pub async fn receive_temporary_file_system_changed( &self, ) -> PropertyStream<'p, <Result<Vec<(String, String)>> as ResultAdapter>::Ok>

TemporaryFileSystem property Create a stream for the TemporaryFileSystem property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn timeout_clean_usec(&self) -> Result<u64>

TimeoutCleanUSec property

pub fn cached_timeout_clean_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

TimeoutCleanUSec property Get the cached value of the TimeoutCleanUSec property, or None if the property is not cached.

pub async fn receive_timeout_clean_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

TimeoutCleanUSec property Create a stream for the TimeoutCleanUSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn timeout_usec(&self) -> Result<u64>

TimeoutUSec property

pub fn cached_timeout_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

TimeoutUSec property Get the cached value of the TimeoutUSec property, or None if the property is not cached.

pub async fn receive_timeout_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

TimeoutUSec property Create a stream for the TimeoutUSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn timer_slack_nsec(&self) -> Result<u64>

TimerSlackNSec property

pub fn cached_timer_slack_nsec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

TimerSlackNSec property Get the cached value of the TimerSlackNSec property, or None if the property is not cached.

pub async fn receive_timer_slack_nsec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

TimerSlackNSec property Create a stream for the TimerSlackNSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn timestamping(&self) -> Result<String>

Timestamping property

pub fn cached_timestamping( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Timestamping property Get the cached value of the Timestamping property, or None if the property is not cached.

pub async fn receive_timestamping_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

Timestamping property Create a stream for the Timestamping property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn transparent(&self) -> Result<bool>

Transparent property

pub fn cached_transparent( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Transparent property Get the cached value of the Transparent property, or None if the property is not cached.

pub async fn receive_transparent_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Transparent property Create a stream for the Transparent property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn trigger_limit_burst(&self) -> Result<u32>

TriggerLimitBurst property

pub fn cached_trigger_limit_burst( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

TriggerLimitBurst property Get the cached value of the TriggerLimitBurst property, or None if the property is not cached.

pub async fn receive_trigger_limit_burst_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

TriggerLimitBurst property Create a stream for the TriggerLimitBurst property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn trigger_limit_interval_usec(&self) -> Result<u64>

TriggerLimitIntervalUSec property

pub fn cached_trigger_limit_interval_usec( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

TriggerLimitIntervalUSec property Get the cached value of the TriggerLimitIntervalUSec property, or None if the property is not cached.

pub async fn receive_trigger_limit_interval_usec_changed( &self, ) -> PropertyStream<'p, <Result<u64> as ResultAdapter>::Ok>

TriggerLimitIntervalUSec property Create a stream for the TriggerLimitIntervalUSec property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn uid(&self) -> Result<u32>

UID property

pub fn cached_uid( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

UID property Get the cached value of the UID property, or None if the property is not cached.

pub async fn receive_uid_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

UID property Create a stream for the UID property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn umask(&self) -> Result<u32>

UMask property

pub fn cached_umask( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

UMask property Get the cached value of the UMask property, or None if the property is not cached.

pub async fn receive_umask_changed( &self, ) -> PropertyStream<'p, <Result<u32> as ResultAdapter>::Ok>

UMask property Create a stream for the UMask property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn unset_environment(&self) -> Result<Vec<String>>

UnsetEnvironment property

pub fn cached_unset_environment( &self, ) -> Result<Option<<Result<Vec<String>> as ResultAdapter>::Ok>, <Result<Vec<String>> as ResultAdapter>::Err>

UnsetEnvironment property Get the cached value of the UnsetEnvironment property, or None if the property is not cached.

pub async fn receive_unset_environment_changed( &self, ) -> PropertyStream<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

UnsetEnvironment property Create a stream for the UnsetEnvironment property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn user(&self) -> Result<String>

User property

pub fn cached_user( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

User property Get the cached value of the User property, or None if the property is not cached.

pub async fn receive_user_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

User property Create a stream for the User property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn utmp_identifier(&self) -> Result<String>

UtmpIdentifier property

pub fn cached_utmp_identifier( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

UtmpIdentifier property Get the cached value of the UtmpIdentifier property, or None if the property is not cached.

pub async fn receive_utmp_identifier_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

UtmpIdentifier property Create a stream for the UtmpIdentifier property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn utmp_mode(&self) -> Result<String>

UtmpMode property

pub fn cached_utmp_mode( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

UtmpMode property Get the cached value of the UtmpMode property, or None if the property is not cached.

pub async fn receive_utmp_mode_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

UtmpMode property Create a stream for the UtmpMode property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn watchdog_signal(&self) -> Result<i32>

WatchdogSignal property

pub fn cached_watchdog_signal( &self, ) -> Result<Option<<Result<i32> as ResultAdapter>::Ok>, <Result<i32> as ResultAdapter>::Err>

WatchdogSignal property Get the cached value of the WatchdogSignal property, or None if the property is not cached.

pub async fn receive_watchdog_signal_changed( &self, ) -> PropertyStream<'p, <Result<i32> as ResultAdapter>::Ok>

WatchdogSignal property Create a stream for the WatchdogSignal property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn working_directory(&self) -> Result<String>

WorkingDirectory property

pub fn cached_working_directory( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

WorkingDirectory property Get the cached value of the WorkingDirectory property, or None if the property is not cached.

pub async fn receive_working_directory_changed( &self, ) -> PropertyStream<'p, <Result<String> as ResultAdapter>::Ok>

WorkingDirectory property Create a stream for the WorkingDirectory property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn writable(&self) -> Result<bool>

Writable property

pub fn cached_writable( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Writable property Get the cached value of the Writable property, or None if the property is not cached.

pub async fn receive_writable_changed( &self, ) -> PropertyStream<'p, <Result<bool> as ResultAdapter>::Ok>

Writable property Create a stream for the Writable property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

Trait Implementations

impl<'p> AsMut<Proxy<'p>> for SocketProxy<'p>

fn as_mut(&mut self) -> &mut Proxy<'p>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<'p> AsRef<Proxy<'p>> for SocketProxy<'p>

fn as_ref(&self) -> &Proxy<'p>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'p> Clone for SocketProxy<'p>

fn clone(&self) -> SocketProxy<'p>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'p> Debug for SocketProxy<'p>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Defaults for SocketProxy<'a>

const INTERFACE: &'static Option<InterfaceName<'static>>

const DESTINATION: &'static Option<BusName<'static>>

const PATH: &'static Option<ObjectPath<'static>>

impl<'p> From<Proxy<'p>> for SocketProxy<'p>

fn from(proxy: Proxy<'p>) -> Self

Converts to this type from the input type.

impl<'p> ProxyImpl<'p> for SocketProxy<'p>

fn builder(conn: &Connection) -> Builder<'p, Self>

Return a customizable builder for this proxy.

fn into_inner(self) -> Proxy<'p>

Consume self, returning the underlying zbus::Proxy.

fn inner(&self) -> &Proxy<'p>

The reference to the underlying zbus::Proxy.

impl<'p> Serialize for SocketProxy<'p>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'p> Type for SocketProxy<'p>

const SIGNATURE: &'static Signature

The signature for the implementing type, in parsed format.