Struct Remote

pub struct Remote {

    pub agreement: Option<Box<str>>,
    pub approval_required: bool,
    pub checksum: Option<Box<str>>,
    pub enabled: bool,
    pub filename_cache: Box<str>,
    pub filename_source: Box<str>,
    pub firmware_base_uri: Option<Box<str>>,
    pub keyring: KeyringKind,
    pub kind: RemoteKind,
    pub modification_time: u64,
    pub password: Option<Box<str>>,
    pub priority: i16,
    pub remote_id: RemoteId,
    pub report_uri: Option<Box<str>>,
    pub title: Box<str>,
    pub uri: Option<Box<str>>,
    pub username: Option<Box<str>>,
}

Information about an available fwupd remote.

Fields

agreement: Option<Box<str>>

approval_required: bool

checksum: Option<Box<str>>

enabled: bool

filename_cache: Box<str>

filename_source: Box<str>

firmware_base_uri: Option<Box<str>>

keyring: KeyringKind

kind: RemoteKind

modification_time: u64

password: Option<Box<str>>

priority: i16

remote_id: RemoteId

report_uri: Option<Box<str>>

title: Box<str>

uri: Option<Box<str>>

username: Option<Box<str>>

Implementations

impl Remote

pub fn update_metadata(&self, client: &Client) -> Result<(), UpdateError>

Updates the metadata for this remote.

Examples found in repository

examples/example.rs (line 80)

fn main_() -> Result<(), Box<dyn Error>> {
    // Atomic value used to stop the background thread.
    let cancellable = Arc::new(AtomicBool::new(true));

    // Begin listening to signals in the background
    listen_in_background(cancellable.clone());

    // Create a new dbus client connection.
    let fwupd = &Client::new()?;

    println!("Version: {}", fwupd.daemon_version()?);
    println!("Status: {:?}", fwupd.status()?);
    println!("Tainted: {}", fwupd.tainted()?);
    if let Ok(percent) = fwupd.percentage() {
        println!("Percentage; {}", percent);
    }

    // Fetch a list of supported devices.
    for device in fwupd.devices()? {
        println!("Device: {:#?}", device);

        if device.is_updateable() {
            if let Ok(upgrades) = fwupd.upgrades(&device) {
                println!("  upgrades found");
                for upgrade in upgrades {
                    println!("{:#?}", upgrade);
                }
            } else {
                println!("  no updates available");
            }

            if let Ok(downgrades) = fwupd.downgrades(&device) {
                println!("  downgrades found");
                for downgrade in downgrades {
                    println!("{:#?}", downgrade);
                }
            }

            if let Ok(releases) = fwupd.releases(&device) {
                println!("   releases found");
                for release in releases {
                    println!("{:#?}", release);
                }
            }
        } else {
            println!("  device not updateable");
        }
    }

    // Fetch a list of remotes, and update them.
    for remote in fwupd.remotes()? {
        println!("{:#?}", remote);

        remote.update_metadata(fwupd)?;
    }

    loop {
        std::thread::sleep(Duration::from_secs(1));
    }

    // Stop listening to signals in the background.
    cancellable.store(true, Ordering::SeqCst);

    Ok(())
}

pub fn time_since_last_update(&self) -> Option<Duration>

Fetch the time since the last update, if such a time can be fetched.

Trait Implementations

impl AsRef<RemoteId> for Remote

fn as_ref(&self) -> &RemoteId

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

impl Clone for Remote

fn clone(&self) -> Remote

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Remote

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

Formats the value using the given formatter.

impl Default for Remote

fn default() -> Remote

Returns the “default value” for a type.

impl FromIterator<(String, Variant<Box<dyn RefArg>>)> for Remote

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = DBusEntry>,

Creates a value from an iterator.