Enum Connection

pub enum Connection {
    Tcp(TcpConnection),
}

An async NUT client connection.

Variants

Tcp(TcpConnection)

A TCP connection.

Implementations

impl Connection

pub async fn new(config: &Config) -> Result<Self>

Initializes a connection to a NUT server (upsd).

Examples found in repository

examples/async.rs (line 26)

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 async fn close(self) -> Result<()>

Gracefully closes the connection.

Examples found in repository

examples/async.rs (line 72)

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
}

impl Connection

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

Queries a list of UPS devices.

Examples found in repository

examples/async.rs (line 35)

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 async fn list_clients(&mut self, ups_name: &str) -> Result<Vec<String>>

Queries the list of client IP addresses connected to the given device.

pub async fn list_vars(&mut self, ups_name: &str) -> Result<Vec<Variable>>

Queries the list of variables for a UPS device.

Examples found in repository

examples/async.rs (line 55)

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 async fn list_mutable_vars( &mut self, ups_name: &str, ) -> Result<Vec<Variable>>

Queries the list of mutable variables for a UPS device.

Examples found in repository

examples/async.rs (line 44)

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 async fn list_commands(&mut self, ups_name: &str) -> Result<Vec<String>>

Queries the list of commands available for the given device.

Examples found in repository

examples/async.rs (line 65)

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 async fn list_var_range( &mut self, ups_name: &str, variable: &str, ) -> Result<Vec<VariableRange>>

Queries the possible ranges of a UPS variable.

pub async fn list_var_enum( &mut self, ups_name: &str, variable: &str, ) -> Result<Vec<String>>

Queries the possible enum values of a UPS variable.

impl Connection

pub async fn get_var( &mut self, ups_name: &str, variable: &str, ) -> Result<Variable>

Queries one variable for a UPS device.

pub async fn get_var_description( &mut self, ups_name: &str, variable: &str, ) -> Result<String>

Queries the description of a UPS variable.

pub async fn get_var_type( &mut self, ups_name: &str, variable: &str, ) -> Result<VariableDefinition>

Queries the type of a UPS variable.

Examples found in repository

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 async fn get_command_description( &mut self, ups_name: &str, variable: &str, ) -> Result<String>

Queries the description of a UPS command.

Examples found in repository

examples/async.rs (line 66)

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 async fn get_ups_description(&mut self, ups_name: &str) -> Result<String>

Queries the description of a UPS device.

pub async fn get_num_logins(&mut self, ups_name: &str) -> Result<i32>

Queries the number of logins to the specified UPS.

Examples found in repository

examples/async.rs (line 40)

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
}

impl Connection

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

Queries the network protocol version.

Examples found in repository

examples/async.rs (line 31)

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 async fn get_server_version(&mut self) -> Result<String>

Queries the server NUT version.

Examples found in repository

examples/async.rs (line 30)

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
}