Enum Variable

pub enum Variable {
    DeviceModel(String),
    DeviceManufacturer(String),
    DeviceSerial(String),
    DeviceType(DeviceType),
    DeviceDescription(String),
    DeviceContact(String),
    DeviceLocation(String),
    DevicePart(String),
    DeviceMacAddress(String),
    DeviceUptime(Duration),
    Other((String, String)),
}

Well-known variables for NUT UPS devices.

List retrieved from: https://networkupstools.org/docs/user-manual.chunked/apcs01.html

Variants

DeviceModel(String)

Device model.

DeviceManufacturer(String)

Device manufacturer.

DeviceSerial(String)

Device serial number.

DeviceType(DeviceType)

Device type.

DeviceDescription(String)

Device description.

DeviceContact(String)

Device administrator name.

DeviceLocation(String)

Device physical location.

DevicePart(String)

Device part number.

DeviceMacAddress(String)

Device MAC address.

DeviceUptime(Duration)

Device uptime.

Other((String, String))

Any other variable. Value is a tuple of (key, value).

Implementations

impl Variable

pub fn parse(name: &str, value: String) -> Variable

Parses a variable from its key and value.

pub fn name(&self) -> &str

Returns the NUT name of the variable.

Examples found in repository

examples/blocking.rs (line 46)

fn main() -> nut_client::Result<()> {
    let host = env::var("NUT_HOST").unwrap_or_else(|_| "localhost".into());
    let port = env::var("NUT_PORT")
        .ok()
        .map(|s| s.parse::<u16>().ok())
        .flatten()
        .unwrap_or(3493);

    let username = env::var("NUT_USER").ok();
    let password = env::var("NUT_PASSWORD").ok();
    let auth = username.map(|username| Auth::new(username, password));

    let config = ConfigBuilder::new()
        .with_host((host, port).try_into().unwrap_or_default())
        .with_auth(auth)
        .with_debug(false) // Turn this on for debugging network chatter
        .build();

    let mut conn = Connection::new(&config)?;

    // Get server information
    println!("NUT server:");
    println!("\tVersion: {}", conn.get_server_version()?);
    println!("\tNetwork Version: {}", conn.get_network_version()?);

    // Print a list of all UPS devices
    println!("Connected UPS devices:");
    for (name, description) in conn.list_ups()? {
        println!("\t- Name: {}", name);
        println!("\t  Description: {}", description);
        println!("\t  Number of logins: {}", conn.get_num_logins(&name)?);

        // Get list of mutable variables
        let mutable_vars = conn.list_mutable_vars(&name)?;

        // List UPS variables (key = val)
        println!("\t  Mutable Variables:");
        for var in mutable_vars.iter() {
            println!("\t\t- {}", var);
            println!("\t\t  {:?}", conn.get_var_type(&name, var.name())?);
        }

        // List UPS immutable properties (key = val)
        println!("\t  Immutable Properties:");
        for var in conn.list_vars(&name)? {
            if mutable_vars.iter().any(|v| v.name() == var.name()) {
                continue;
            }
            println!("\t\t- {}", var);
            println!("\t\t  {:?}", conn.get_var_type(&name, var.name())?);
        }

        // List UPS commands
        println!("\t  Commands:");
        for cmd in conn.list_commands(&name)? {
            let description = conn.get_command_description(&name, &cmd)?;
            println!("\t\t- {} ({})", cmd, description);
        }
    }

    // Gracefully shut down the connection using the `LOGOUT` command
    conn.close()
}

examples/async.rs (line 50)

async fn main() -> nut_client::Result<()> {
    let host = env::var("NUT_HOST").unwrap_or_else(|_| "localhost".into());
    let port = env::var("NUT_PORT")
        .ok()
        .map(|s| s.parse::<u16>().ok())
        .flatten()
        .unwrap_or(3493);

    let username = env::var("NUT_USER").ok();
    let password = env::var("NUT_PASSWORD").ok();
    let auth = username.map(|username| Auth::new(username, password));

    let config = ConfigBuilder::new()
        .with_host((host, port).try_into().unwrap_or_default())
        .with_auth(auth)
        .with_debug(false) // Turn this on for debugging network chatter
        .build();

    let mut conn = Connection::new(&config).await?;

    // Get server information
    println!("NUT server:");
    println!("\tVersion: {}", conn.get_server_version().await?);
    println!("\tNetwork Version: {}", conn.get_network_version().await?);

    // Print a list of all UPS devices
    println!("Connected UPS devices:");
    for (name, description) in conn.list_ups().await? {
        println!("\t- Name: {}", name);
        println!("\t  Description: {}", description);
        println!(
            "\t  Number of logins: {}",
            conn.get_num_logins(&name).await?
        );

        // Get list of mutable variables
        let mutable_vars = conn.list_mutable_vars(&name).await?;

        // List UPS variables (key = val)
        println!("\t  Mutable Variables:");
        for var in mutable_vars.iter() {
            println!("\t\t- {}", var);
            println!("\t\t  {:?}", conn.get_var_type(&name, var.name()).await?);
        }

        // List UPS immutable properties (key = val)
        println!("\t  Immutable Properties:");
        for var in conn.list_vars(&name).await? {
            if mutable_vars.iter().any(|v| v.name() == var.name()) {
                continue;
            }
            println!("\t\t- {}", var);
            println!("\t\t  {:?}", conn.get_var_type(&name, var.name()).await?);
        }

        // List UPS commands
        println!("\t  Commands:");
        for cmd in conn.list_commands(&name).await? {
            let description = conn.get_command_description(&name, &cmd).await?;
            println!("\t\t- {} ({})", cmd, description);
        }
    }

    // Gracefully shut down the connection using the `LOGOUT` command
    conn.close().await
}

pub fn value(&self) -> String

Returns the value of the NUT variable.

Trait Implementations

impl Clone for Variable

fn clone(&self) -> Variable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Variable

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

Formats the value using the given formatter.

impl Display for Variable

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

Formats the value using the given formatter.

impl PartialEq for Variable

fn eq(&self, other: &Variable) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Variable

impl StructuralPartialEq for Variable