Struct ManagerProxyBlocking

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

Implementations

impl<'p> ManagerProxyBlocking<'p>

pub fn new(conn: &Connection) -> Result<ManagerProxyBlocking<'p>>

Creates a new proxy with the default service and path.

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 fn abandon_scope(&self, name: &str) -> Result<()>

AbandonScope method

pub fn add_dependency_unit_files( &self, files: &[&str], target: &str, type_: &str, runtime: bool, force: bool, ) -> Result<Vec<Change>>

AddDependencyUnitFiles method

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

AttachProcessesToUnit method

pub fn bind_mount_unit( &self, name: &str, source: &str, destination: &str, read_only: bool, mkdir: bool, ) -> Result<()>

BindMountUnit method

pub fn cancel_job(&self, id: u32) -> Result<()>

CancelJob method

pub fn clean_unit(&self, name: &str, mask: &[&str]) -> Result<()>

CleanUnit method

pub fn clear_jobs(&self) -> Result<()>

ClearJobs method

pub fn disable_unit_files( &self, files: &[&str], runtime: bool, ) -> Result<Vec<Change>>

DisableUnitFiles method

pub fn disable_unit_files_with_flags( &self, files: &[&str], flags: UnitFileFlags, ) -> Result<Vec<Change>>

DisableUnitFilesWithFlags method

pub fn dump(&self) -> Result<String>

Dump method

pub fn dump_by_file_descriptor(&self) -> Result<OwnedFd>

DumpByFileDescriptor method

pub fn enable_unit_files( &self, files: &[&str], runtime: bool, force: bool, ) -> Result<(bool, Vec<Change>)>

EnableUnitFiles method

pub fn enable_unit_files_with_flags( &self, files: &[&str], flags: UnitFileFlags, ) -> Result<(bool, Vec<Change>)>

EnableUnitFilesWithFlags method

pub fn enqueue_marked_jobs(&self) -> Result<Vec<OwnedObjectPath>>

EnqueueMarkedJobs method

pub fn enqueue_unit_job( &self, name: &str, job_type: &str, job_mode: Mode, ) -> Result<EnquedJob>

EnqueueUnitJob method

pub fn exit(&self) -> Result<()>

Exit method

pub fn freeze_unit(&self, name: &str) -> Result<()>

FreezeUnit method

pub fn get_default_target(&self) -> Result<String>

GetDefaultTarget method

pub fn get_dynamic_users(&self) -> Result<Vec<(u32, String)>>

GetDynamicUsers method

pub fn get_job(&self, id: u32) -> Result<OwnedObjectPath>

GetJob method

pub fn get_job_after(&self, id: u32) -> Result<Vec<Job>>

GetJobAfter method

pub fn get_job_before(&self, id: u32) -> Result<Vec<Job>>

GetJobBefore method

pub fn get_unit(&self, name: &str) -> Result<OwnedObjectPath>

GetUnit method

pub fn get_unit_by_control_group(&self, cgroup: &str) -> Result<OwnedObjectPath>

GetUnitByControlGroup method

pub fn get_unit_by_invocation_id( &self, invocation_id: &[u8], ) -> Result<OwnedObjectPath>

GetUnitByInvocationID method

pub fn get_unit_by_pid(&self, pid: u32) -> Result<OwnedObjectPath>

GetUnitByPID method

pub fn get_unit_file_links( &self, name: &str, runtime: bool, ) -> Result<Vec<String>>

GetUnitFileLinks method

pub fn get_unit_file_state(&self, file: &str) -> Result<UnitFileState>

GetUnitFileState method

pub fn get_unit_processes(&self, name: &str) -> Result<Vec<Process>>

GetUnitProcesses method

pub fn halt(&self) -> Result<()>

Halt method

pub fn kexec(&self) -> Result<()>

KExec method

pub fn kill_unit(&self, name: &str, whom: &str, signal: i32) -> Result<()>

KillUnit method

pub fn link_unit_files( &self, files: &[&str], runtime: bool, force: bool, ) -> Result<Vec<Change>>

LinkUnitFiles method

pub fn list_jobs(&self) -> Result<Vec<Job>>

ListJobs method

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

ListUnitFiles method

pub fn list_unit_files_by_patterns( &self, states: &[LoadState], patterns: &[&str], ) -> Result<Vec<(String, String)>>

ListUnitFilesByPatterns method

pub fn list_units(&self) -> Result<Vec<Unit>>

ListUnits method

pub fn list_units_by_names(&self, names: &[&str]) -> Result<Vec<Unit>>

ListUnitsByNames method

pub fn list_units_by_patterns( &self, states: &[LoadState], patterns: &[&str], ) -> Result<Vec<Unit>>

ListUnitsByPatterns method

pub fn list_units_filtered(&self, states: &[LoadState]) -> Result<Vec<Unit>>

ListUnitsFiltered method

pub fn load_unit(&self, name: &str) -> Result<OwnedObjectPath>

LoadUnit method

pub fn lookup_dynamic_user_by_name(&self, name: &str) -> Result<u32>

LookupDynamicUserByName method

pub fn lookup_dynamic_user_by_uid(&self, uid: u32) -> Result<String>

LookupDynamicUserByUID method

pub fn mask_unit_files( &self, files: &[&str], runtime: bool, force: bool, ) -> Result<Vec<Change>>

MaskUnitFiles method

pub fn mount_image_unit( &self, name: &str, source: &str, destination: &str, read_only: bool, mkdir: bool, options: &[(&str, &str)], ) -> Result<()>

MountImageUnit method

pub fn power_off(&self) -> Result<()>

PowerOff method

pub fn preset_all_unit_files( &self, mode: Mode, runtime: bool, force: bool, ) -> Result<Vec<Change>>

PresetAllUnitFiles method

pub fn preset_unit_files( &self, files: &[&str], runtime: bool, force: bool, ) -> Result<(bool, Vec<Change>)>

PresetUnitFiles method

pub fn preset_unit_files_with_mode( &self, files: &[&str], mode: Mode, runtime: bool, force: bool, ) -> Result<(bool, Vec<Change>)>

PresetUnitFilesWithMode method

pub fn reboot(&self) -> Result<()>

Reboot method

pub fn reenable_unit_files( &self, files: &[&str], runtime: bool, force: bool, ) -> Result<(bool, Vec<Change>)>

ReenableUnitFiles method

pub fn reexecute(&self) -> Result<()>

Reexecute method

pub fn ref_unit(&self, name: &str) -> Result<()>

RefUnit method

pub fn reload(&self) -> Result<()>

Reload method

pub fn reload_or_restart_unit( &self, name: &str, mode: Mode, ) -> Result<OwnedObjectPath>

ReloadOrRestartUnit method

pub fn reload_or_try_restart_unit( &self, name: &str, mode: Mode, ) -> Result<OwnedObjectPath>

ReloadOrTryRestartUnit method

pub fn reload_unit(&self, name: &str, mode: Mode) -> Result<OwnedObjectPath>

ReloadUnit method

pub fn reset_failed(&self) -> Result<()>

ResetFailed method

pub fn reset_failed_unit(&self, name: &str) -> Result<()>

ResetFailedUnit method

pub fn restart_unit(&self, name: &str, mode: Mode) -> Result<OwnedObjectPath>

RestartUnit method

pub fn revert_unit_files(&self, files: &[&str]) -> Result<Vec<Change>>

RevertUnitFiles method

pub fn set_default_target(&self, name: &str, force: bool) -> Result<Vec<Change>>

SetDefaultTarget method

pub fn set_environment(&self, assignments: &[&str]) -> Result<()>

SetEnvironment method

pub fn set_exit_code(&self, number: u8) -> Result<()>

SetExitCode method

pub fn set_show_status(&self, mode: Mode) -> Result<()>

SetShowStatus method

pub fn set_unit_properties( &self, name: &str, runtime: bool, properties: &[(&str, Value<'_>)], ) -> Result<()>

SetUnitProperties method

pub fn start_transient_unit( &self, name: &str, mode: Mode, properties: &[(&str, Value<'_>)], aux: &[(&str, &[(&str, Value<'_>)])], ) -> Result<OwnedObjectPath>

StartTransientUnit method

pub fn start_unit(&self, name: &str, mode: Mode) -> Result<OwnedObjectPath>

StartUnit method

pub fn start_unit_replace( &self, old_unit: &str, new_unit: &str, mode: Mode, ) -> Result<OwnedObjectPath>

StartUnitReplace method

pub fn start_unit_with_flags( &self, name: &str, mode: Mode, flags: UnitFileFlags, ) -> Result<OwnedObjectPath>

StartUnitWithFlags method

pub fn stop_unit(&self, name: &str, mode: Mode) -> Result<OwnedObjectPath>

StopUnit method

pub fn subscribe(&self) -> Result<()>

Subscribe method

pub fn switch_root(&self, new_root: &str, init: &str) -> Result<()>

SwitchRoot method

pub fn thaw_unit(&self, name: &str) -> Result<()>

ThawUnit method

pub fn try_restart_unit( &self, name: &str, mode: Mode, ) -> Result<OwnedObjectPath>

TryRestartUnit method

pub fn unmask_unit_files( &self, files: &[&str], runtime: bool, ) -> Result<Vec<Change>>

UnmaskUnitFiles method

pub fn unref_unit(&self, name: &str) -> Result<()>

UnrefUnit method

pub fn unset_and_set_environment( &self, names: &[&str], assignments: &[&str], ) -> Result<()>

UnsetAndSetEnvironment method

pub fn unset_environment(&self, names: &[&str]) -> Result<()>

UnsetEnvironment method

pub fn unsubscribe(&self) -> Result<()>

Unsubscribe method

pub fn receive_job_new(&self) -> Result<JobNewIterator>

Create a stream that receives JobNew signals.

This a convenient wrapper around zbus::blocking::Proxy::receive_signal. JobNew signal

pub fn receive_job_new_with_args( &self, args: &[(u8, &str)], ) -> Result<JobNewIterator>

Create a stream that receives JobNew signals.

This a convenient wrapper around zbus::blocking::Proxy::receive_signal_with_args. JobNew signal

pub fn receive_job_removed(&self) -> Result<JobRemovedIterator>

Create a stream that receives JobRemoved signals.

This a convenient wrapper around zbus::blocking::Proxy::receive_signal. JobRemoved signal

pub fn receive_job_removed_with_args( &self, args: &[(u8, &str)], ) -> Result<JobRemovedIterator>

Create a stream that receives JobRemoved signals.

This a convenient wrapper around zbus::blocking::Proxy::receive_signal_with_args. JobRemoved signal

pub fn receive_reloading(&self) -> Result<ReloadingIterator>

Create a stream that receives Reloading signals.

This a convenient wrapper around zbus::blocking::Proxy::receive_signal. Reloading signal

pub fn receive_reloading_with_args( &self, args: &[(u8, &str)], ) -> Result<ReloadingIterator>

Create a stream that receives Reloading signals.

This a convenient wrapper around zbus::blocking::Proxy::receive_signal_with_args. Reloading signal

pub fn receive_startup_finished(&self) -> Result<StartupFinishedIterator>

Create a stream that receives StartupFinished signals.

This a convenient wrapper around zbus::blocking::Proxy::receive_signal. StartupFinished signal

pub fn receive_startup_finished_with_args( &self, args: &[(u8, &str)], ) -> Result<StartupFinishedIterator>

Create a stream that receives StartupFinished signals.

This a convenient wrapper around zbus::blocking::Proxy::receive_signal_with_args. StartupFinished signal

pub fn receive_unit_files_changed(&self) -> Result<UnitFilesChangedIterator>

Create a stream that receives UnitFilesChanged signals.

This a convenient wrapper around zbus::blocking::Proxy::receive_signal. UnitFilesChanged signal

pub fn receive_unit_new(&self) -> Result<UnitNewIterator>

Create a stream that receives UnitNew signals.

This a convenient wrapper around zbus::blocking::Proxy::receive_signal. UnitNew signal

pub fn receive_unit_new_with_args( &self, args: &[(u8, &str)], ) -> Result<UnitNewIterator>

Create a stream that receives UnitNew signals.

This a convenient wrapper around zbus::blocking::Proxy::receive_signal_with_args. UnitNew signal

pub fn receive_unit_removed(&self) -> Result<UnitRemovedIterator>

Create a stream that receives UnitRemoved signals.

This a convenient wrapper around zbus::blocking::Proxy::receive_signal. UnitRemoved signal

pub fn receive_unit_removed_with_args( &self, args: &[(u8, &str)], ) -> Result<UnitRemovedIterator>

Create a stream that receives UnitRemoved signals.

This a convenient wrapper around zbus::blocking::Proxy::receive_signal_with_args. UnitRemoved signal

pub fn architecture(&self) -> Result<String>

Architecture property

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

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

pub fn receive_architecture_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn confirm_spawn(&self) -> Result<bool>

ConfirmSpawn property

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

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

pub fn receive_confirm_spawn_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub 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>

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

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

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

pub fn ctrl_alt_del_burst_action(&self) -> Result<String>

CtrlAltDelBurstAction property

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

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

pub fn receive_ctrl_alt_del_burst_action_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn default_block_io_accounting(&self) -> Result<bool>

DefaultBlockIOAccounting property

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

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

pub fn receive_default_block_io_accounting_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn default_cpu_accounting(&self) -> Result<bool>

DefaultCPUAccounting property

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

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

pub fn receive_default_cpu_accounting_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn default_limit_as(&self) -> Result<u64>

DefaultLimitAS property

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

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

pub fn receive_default_limit_as_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_as_soft(&self) -> Result<u64>

DefaultLimitASSoft property

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

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

pub fn receive_default_limit_as_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_core(&self) -> Result<u64>

DefaultLimitCORE property

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

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

pub fn receive_default_limit_core_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_core_soft(&self) -> Result<u64>

DefaultLimitCORESoft property

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

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

pub fn receive_default_limit_core_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_cpu(&self) -> Result<u64>

DefaultLimitCPU property

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

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

pub fn receive_default_limit_cpu_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_cpu_soft(&self) -> Result<u64>

DefaultLimitCPUSoft property

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

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

pub fn receive_default_limit_cpu_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_data(&self) -> Result<u64>

DefaultLimitDATA property

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

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

pub fn receive_default_limit_data_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_data_soft(&self) -> Result<u64>

DefaultLimitDATASoft property

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

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

pub fn receive_default_limit_data_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_fsize(&self) -> Result<u64>

DefaultLimitFSIZE property

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

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

pub fn receive_default_limit_fsize_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_fsize_soft(&self) -> Result<u64>

DefaultLimitFSIZESoft property

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

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

pub fn receive_default_limit_fsize_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_locks(&self) -> Result<u64>

DefaultLimitLOCKS property

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

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

pub fn receive_default_limit_locks_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_locks_soft(&self) -> Result<u64>

DefaultLimitLOCKSSoft property

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

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

pub fn receive_default_limit_locks_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_memlock(&self) -> Result<u64>

DefaultLimitMEMLOCK property

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

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

pub fn receive_default_limit_memlock_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_memlock_soft(&self) -> Result<u64>

DefaultLimitMEMLOCKSoft property

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

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

pub fn receive_default_limit_memlock_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_msgqueue(&self) -> Result<u64>

DefaultLimitMSGQUEUE property

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

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

pub fn receive_default_limit_msgqueue_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_msgqueue_soft(&self) -> Result<u64>

DefaultLimitMSGQUEUESoft property

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

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

pub fn receive_default_limit_msgqueue_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_nice(&self) -> Result<u64>

DefaultLimitNICE property

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

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

pub fn receive_default_limit_nice_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_nice_soft(&self) -> Result<u64>

DefaultLimitNICESoft property

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

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

pub fn receive_default_limit_nice_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_nofile(&self) -> Result<u64>

DefaultLimitNOFILE property

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

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

pub fn receive_default_limit_nofile_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_nofile_soft(&self) -> Result<u64>

DefaultLimitNOFILESoft property

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

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

pub fn receive_default_limit_nofile_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_nproc(&self) -> Result<u64>

DefaultLimitNPROC property

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

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

pub fn receive_default_limit_nproc_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_nproc_soft(&self) -> Result<u64>

DefaultLimitNPROCSoft property

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

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

pub fn receive_default_limit_nproc_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_rss(&self) -> Result<u64>

DefaultLimitRSS property

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

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

pub fn receive_default_limit_rss_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_rss_soft(&self) -> Result<u64>

DefaultLimitRSSSoft property

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

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

pub fn receive_default_limit_rss_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_rtprio(&self) -> Result<u64>

DefaultLimitRTPRIO property

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

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

pub fn receive_default_limit_rtprio_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_rtprio_soft(&self) -> Result<u64>

DefaultLimitRTPRIOSoft property

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

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

pub fn receive_default_limit_rtprio_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_rttime(&self) -> Result<u64>

DefaultLimitRTTIME property

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

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

pub fn receive_default_limit_rttime_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_rttime_soft(&self) -> Result<u64>

DefaultLimitRTTIMESoft property

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

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

pub fn receive_default_limit_rttime_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_sigpending(&self) -> Result<u64>

DefaultLimitSIGPENDING property

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

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

pub fn receive_default_limit_sigpending_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_sigpending_soft(&self) -> Result<u64>

DefaultLimitSIGPENDINGSoft property

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

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

pub fn receive_default_limit_sigpending_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_stack(&self) -> Result<u64>

DefaultLimitSTACK property

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

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

pub fn receive_default_limit_stack_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_limit_stack_soft(&self) -> Result<u64>

DefaultLimitSTACKSoft property

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

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

pub fn receive_default_limit_stack_soft_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_memory_accounting(&self) -> Result<bool>

DefaultMemoryAccounting property

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

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

pub fn receive_default_memory_accounting_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn default_oom_policy(&self) -> Result<String>

DefaultOOMPolicy property

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

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

pub fn receive_default_oom_policy_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn default_oom_score_adjust(&self) -> Result<i32>

DefaultOOMScoreAdjust property

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

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

pub fn receive_default_oom_score_adjust_changed( &self, ) -> PropertyIterator<'p, <Result<i32> as ResultAdapter>::Ok>

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

pub fn default_restart_usec(&self) -> Result<u64>

DefaultRestartUSec property

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

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

pub fn receive_default_restart_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_standard_error(&self) -> Result<String>

DefaultStandardError property

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

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

pub fn receive_default_standard_error_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn default_standard_output(&self) -> Result<String>

DefaultStandardOutput property

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

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

pub fn receive_default_standard_output_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn default_start_limit_burst(&self) -> Result<u32>

DefaultStartLimitBurst property

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

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

pub fn receive_default_start_limit_burst_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn default_start_limit_interval_usec(&self) -> Result<u64>

DefaultStartLimitIntervalUSec property

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

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

pub fn receive_default_start_limit_interval_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_tasks_accounting(&self) -> Result<bool>

DefaultTasksAccounting property

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

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

pub fn receive_default_tasks_accounting_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn default_tasks_max(&self) -> Result<u64>

DefaultTasksMax property

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

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

pub fn receive_default_tasks_max_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_timeout_abort_usec(&self) -> Result<u64>

DefaultTimeoutAbortUSec property

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

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

pub fn receive_default_timeout_abort_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_timeout_start_usec(&self) -> Result<u64>

DefaultTimeoutStartUSec property

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

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

pub fn receive_default_timeout_start_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_timeout_stop_usec(&self) -> Result<u64>

DefaultTimeoutStopUSec property

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

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

pub fn receive_default_timeout_stop_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn default_timer_accuracy_usec(&self) -> Result<u64>

DefaultTimerAccuracyUSec property

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

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

pub fn receive_default_timer_accuracy_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub 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>

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

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

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

pub fn exit_code(&self) -> Result<u8>

ExitCode property

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

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

pub fn receive_exit_code_changed( &self, ) -> PropertyIterator<'p, <Result<u8> as ResultAdapter>::Ok>

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

pub fn features(&self) -> Result<String>

Features property

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

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

pub fn receive_features_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn finish_timestamp(&self) -> Result<u64>

FinishTimestamp property

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

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

pub fn receive_finish_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn finish_timestamp_monotonic(&self) -> Result<u64>

FinishTimestampMonotonic property

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

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

pub fn receive_finish_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn firmware_timestamp(&self) -> Result<u64>

FirmwareTimestamp property

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

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

pub fn receive_firmware_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn firmware_timestamp_monotonic(&self) -> Result<u64>

FirmwareTimestampMonotonic property

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

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

pub fn receive_firmware_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn generators_finish_timestamp(&self) -> Result<u64>

GeneratorsFinishTimestamp property

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

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

pub fn receive_generators_finish_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn generators_finish_timestamp_monotonic(&self) -> Result<u64>

GeneratorsFinishTimestampMonotonic property

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

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

pub fn receive_generators_finish_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn generators_start_timestamp(&self) -> Result<u64>

GeneratorsStartTimestamp property

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

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

pub fn receive_generators_start_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn generators_start_timestamp_monotonic(&self) -> Result<u64>

GeneratorsStartTimestampMonotonic property

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

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

pub fn receive_generators_start_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_generators_finish_timestamp(&self) -> Result<u64>

InitRDGeneratorsFinishTimestamp property

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

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

pub fn receive_initrd_generators_finish_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_generators_finish_timestamp_monotonic(&self) -> Result<u64>

InitRDGeneratorsFinishTimestampMonotonic property

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

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

pub fn receive_initrd_generators_finish_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_generators_start_timestamp(&self) -> Result<u64>

InitRDGeneratorsStartTimestamp property

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

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

pub fn receive_initrd_generators_start_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_generators_start_timestamp_monotonic(&self) -> Result<u64>

InitRDGeneratorsStartTimestampMonotonic property

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

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

pub fn receive_initrd_generators_start_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_security_finish_timestamp(&self) -> Result<u64>

InitRDSecurityFinishTimestamp property

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

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

pub fn receive_initrd_security_finish_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_security_finish_timestamp_monotonic(&self) -> Result<u64>

InitRDSecurityFinishTimestampMonotonic property

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

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

pub fn receive_initrd_security_finish_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_security_start_timestamp(&self) -> Result<u64>

InitRDSecurityStartTimestamp property

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

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

pub fn receive_initrd_security_start_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_security_start_timestamp_monotonic(&self) -> Result<u64>

InitRDSecurityStartTimestampMonotonic property

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

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

pub fn receive_initrd_security_start_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_timestamp(&self) -> Result<u64>

InitRDTimestamp property

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

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

pub fn receive_initrd_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_timestamp_monotonic(&self) -> Result<u64>

InitRDTimestampMonotonic property

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

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

pub fn receive_initrd_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_units_load_finish_timestamp(&self) -> Result<u64>

InitRDUnitsLoadFinishTimestamp property

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

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

pub fn receive_initrd_units_load_finish_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_units_load_finish_timestamp_monotonic(&self) -> Result<u64>

InitRDUnitsLoadFinishTimestampMonotonic property

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

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

pub fn receive_initrd_units_load_finish_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_units_load_start_timestamp(&self) -> Result<u64>

InitRDUnitsLoadStartTimestamp property

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

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

pub fn receive_initrd_units_load_start_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn initrd_units_load_start_timestamp_monotonic(&self) -> Result<u64>

InitRDUnitsLoadStartTimestampMonotonic property

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

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

pub fn receive_initrd_units_load_start_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn kexec_watchdog_usec(&self) -> Result<u64>

KExecWatchdogUSec property

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

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

pub fn receive_kexec_watchdog_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn set_kexec_watchdog_usec(&self, value: u64) -> Result<()>

pub fn kernel_timestamp(&self) -> Result<u64>

KernelTimestamp property

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

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

pub fn receive_kernel_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn kernel_timestamp_monotonic(&self) -> Result<u64>

KernelTimestampMonotonic property

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

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

pub fn receive_kernel_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn loader_timestamp(&self) -> Result<u64>

LoaderTimestamp property

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

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

pub fn receive_loader_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn loader_timestamp_monotonic(&self) -> Result<u64>

LoaderTimestampMonotonic property

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

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

pub fn receive_loader_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn log_level(&self) -> Result<String>

LogLevel property

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

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

pub fn receive_log_level_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn set_log_level(&self, value: &str) -> Result<()>

pub fn log_target(&self) -> Result<String>

LogTarget property

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

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

pub fn receive_log_target_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn set_log_target(&self, value: &str) -> Result<()>

pub fn n_failed_jobs(&self) -> Result<u32>

NFailedJobs property

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

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

pub fn receive_n_failed_jobs_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn n_failed_units(&self) -> Result<u32>

NFailedUnits property

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

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

pub fn receive_n_failed_units_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn n_installed_jobs(&self) -> Result<u32>

NInstalledJobs property

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

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

pub fn receive_n_installed_jobs_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn n_jobs(&self) -> Result<u32>

NJobs property

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

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

pub fn receive_n_jobs_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn n_names(&self) -> Result<u32>

NNames property

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

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

pub fn receive_n_names_changed( &self, ) -> PropertyIterator<'p, <Result<u32> as ResultAdapter>::Ok>

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

pub fn progress(&self) -> Result<f64>

Progress property

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

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

pub fn receive_progress_changed( &self, ) -> PropertyIterator<'p, <Result<f64> as ResultAdapter>::Ok>

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

pub fn reboot_watchdog_usec(&self) -> Result<u64>

RebootWatchdogUSec property

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

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

pub fn receive_reboot_watchdog_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn set_reboot_watchdog_usec(&self, value: u64) -> Result<()>

pub fn runtime_watchdog_pre_governor(&self) -> Result<String>

RuntimeWatchdogPreGovernor property

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

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

pub fn receive_runtime_watchdog_pre_governor_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn set_runtime_watchdog_pre_governor(&self, value: &str) -> Result<()>

pub fn runtime_watchdog_pre_usec(&self) -> Result<u64>

RuntimeWatchdogPreUSec property

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

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

pub fn receive_runtime_watchdog_pre_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn set_runtime_watchdog_pre_usec(&self, value: u64) -> Result<()>

pub fn runtime_watchdog_usec(&self) -> Result<u64>

RuntimeWatchdogUSec property

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

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

pub fn receive_runtime_watchdog_usec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn set_runtime_watchdog_usec(&self, value: u64) -> Result<()>

pub fn security_finish_timestamp(&self) -> Result<u64>

SecurityFinishTimestamp property

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

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

pub fn receive_security_finish_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn security_finish_timestamp_monotonic(&self) -> Result<u64>

SecurityFinishTimestampMonotonic property

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

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

pub fn receive_security_finish_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn security_start_timestamp(&self) -> Result<u64>

SecurityStartTimestamp property

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

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

pub fn receive_security_start_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn security_start_timestamp_monotonic(&self) -> Result<u64>

SecurityStartTimestampMonotonic property

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

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

pub fn receive_security_start_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn service_watchdogs(&self) -> Result<bool>

ServiceWatchdogs property

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

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

pub fn receive_service_watchdogs_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn set_service_watchdogs(&self, value: bool) -> Result<()>

pub fn show_status(&self) -> Result<bool>

ShowStatus property

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

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

pub fn receive_show_status_changed( &self, ) -> PropertyIterator<'p, <Result<bool> as ResultAdapter>::Ok>

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

pub fn system_state(&self) -> Result<String>

SystemState property

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

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

pub fn receive_system_state_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn tainted(&self) -> Result<String>

Tainted property

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

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

pub fn receive_tainted_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub 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>

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

pub fn receive_timer_slack_nsec_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

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

UnitPath property

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

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

pub fn receive_unit_path_changed( &self, ) -> PropertyIterator<'p, <Result<Vec<String>> as ResultAdapter>::Ok>

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

pub fn units_load_finish_timestamp(&self) -> Result<u64>

UnitsLoadFinishTimestamp property

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

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

pub fn receive_units_load_finish_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn units_load_finish_timestamp_monotonic(&self) -> Result<u64>

UnitsLoadFinishTimestampMonotonic property

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

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

pub fn receive_units_load_finish_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn units_load_start_timestamp(&self) -> Result<u64>

UnitsLoadStartTimestamp property

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

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

pub fn receive_units_load_start_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn units_load_start_timestamp_monotonic(&self) -> Result<u64>

UnitsLoadStartTimestampMonotonic property

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

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

pub fn receive_units_load_start_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn units_load_timestamp(&self) -> Result<u64>

UnitsLoadTimestamp property

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

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

pub fn receive_units_load_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn units_load_timestamp_monotonic(&self) -> Result<u64>

UnitsLoadTimestampMonotonic property

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

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

pub fn receive_units_load_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn userspace_timestamp(&self) -> Result<u64>

UserspaceTimestamp property

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

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

pub fn receive_userspace_timestamp_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn userspace_timestamp_monotonic(&self) -> Result<u64>

UserspaceTimestampMonotonic property

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

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

pub fn receive_userspace_timestamp_monotonic_changed( &self, ) -> PropertyIterator<'p, <Result<u64> as ResultAdapter>::Ok>

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

pub fn version(&self) -> Result<String>

Version property

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

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

pub fn receive_version_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

pub fn virtualization(&self) -> Result<String>

Virtualization property

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

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

pub fn receive_virtualization_changed( &self, ) -> PropertyIterator<'p, <Result<String> as ResultAdapter>::Ok>

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

Trait Implementations

impl<'p> AsMut<Proxy<'p>> for ManagerProxyBlocking<'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 ManagerProxyBlocking<'p>

fn as_ref(&self) -> &Proxy<'p>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'p> Clone for ManagerProxyBlocking<'p>

fn clone(&self) -> ManagerProxyBlocking<'p>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'p> Debug for ManagerProxyBlocking<'p>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Defaults for ManagerProxyBlocking<'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 ManagerProxyBlocking<'p>

fn from(proxy: Proxy<'p>) -> Self

Converts to this type from the input type.

impl<'p> ProxyImpl<'p> for ManagerProxyBlocking<'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 ManagerProxyBlocking<'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 ManagerProxyBlocking<'p>

const SIGNATURE: &'static Signature

The signature for the implementing type, in parsed format.