Struct Config

pub struct Config {
    devices: RefCell<HashMap<String, DeviceConfig>>,
    config_settings: ConfigSettings,
}

A configuration for NetHSM devices

Tracks a set of DeviceConfigs hashed by label.

Fields

devices: RefCell<HashMap<String, DeviceConfig>>

config_settings: ConfigSettings

Implementations

impl Config

pub fn new( config_settings: ConfigSettings, path: Option<&Path>, ) -> Result<Self, Error>

Loads the configuration

If path is Some, the configuration is loaded from a specific file. If path is None, a default location is assumed. The default location depends on the chosen app_name and the OS platform. Assuming app_name is "my_app" on Linux the default location is ~/.config/my_app/config.toml.

If the targeted configuration file does not yet exist, an empty default Config is assumed.

Errors

Returns an Error::Load if loading the configuration file fails.

Examples

use nethsm_config::{Config, ConfigInteractivity, ConfigSettings};

let config_settings = ConfigSettings::new(
    "my_app".to_string(),
    ConfigInteractivity::NonInteractive,
    None,
);
let config_from_default = Config::new(config_settings.clone(), None)?;

let tmpfile = testdir::testdir!().join("my_app_new.conf");
let config_from_file = Config::new(config_settings, Some(&tmpfile))?;

fn set_config_settings(&mut self, config_settings: ConfigSettings)

pub fn add_device( &self, label: String, url: Url, tls_security: ConnectionSecurity, ) -> Result<(), Error>

Adds a DeviceConfig

A device is defined by its label, the url to connect to and the chosen tls_security for the connection.

Errors

Returns an Error::DeviceExists if a DeviceConfig with the same label exists already.

Examples

use nethsm::ConnectionSecurity;
use nethsm_config::{Config, ConfigInteractivity, ConfigSettings};

config.add_device(
    "device1".to_string(),
    "https://example.org/api/v1".parse()?,
    ConnectionSecurity::Unsafe,
)?;

// adding the same device again leads to error
assert!(
    config
        .add_device(
            "device1".to_string(),
            "https://example.org/api/v1".parse()?,
            ConnectionSecurity::Unsafe,
        )
        .is_err()
);

pub fn delete_device(&self, label: &str) -> Result<(), Error>

Deletes a DeviceConfig identified by label

Errors

Returns an Error::DeviceMissing if no DeviceConfig with a matching label exists.

Examples

use nethsm::ConnectionSecurity;
use nethsm_config::{Config, ConfigInteractivity, ConfigSettings};

config.add_device(
    "device1".to_string(),
    "https://example.org/api/v1".parse()?,
    ConnectionSecurity::Unsafe,
)?;

config.delete_device("device1")?;

// deleting a non-existent device leads to error
assert!(config.delete_device("device1",).is_err());

pub fn get_device(&self, label: Option<&str>) -> Result<DeviceConfig, Error>

Returns a single DeviceConfig from the Config based on an optional label

If label is Some, a specific DeviceConfig is retrieved. If label is None and only one device is defined in the config, then the DeviceConfig for that device is returned.

Errors

Returns an Error::DeviceMissing if label is Some but it can not be found in the Config. Returns an Error::NoDevice, if label is None but the Config has no devices. Returns an Error::NoDevice, if label is None and the Config has more than one device.

Examples

use nethsm::ConnectionSecurity;
use nethsm_config::{Config, ConfigInteractivity, ConfigSettings};

config.add_device(
    "device1".to_string(),
    "https://example.org/api/v1".parse()?,
    ConnectionSecurity::Unsafe,
)?;

config.get_device(Some("device1"))?;

// this fails because the device does not exist
assert!(config.get_device(Some("device2")).is_err());

config.add_device(
    "device2".to_string(),
    "https://example.org/other/api/v1".parse()?,
    ConnectionSecurity::Unsafe,
)?;
// this fails because there is more than one device
assert!(config.get_device(None).is_err());

config.delete_device("device1")?;
config.delete_device("device2")?;
// this fails because there is no device
assert!(config.get_device(None).is_err());

pub fn get_single_device_label(&self) -> Result<String, Error>

Returns a single DeviceConfig label from the Config

Errors

Returns an error if not exactly one DeviceConfig is present.

Examples

use nethsm::ConnectionSecurity;
use nethsm_config::{Config, ConfigInteractivity, ConfigSettings};

config.add_device(
    "device1".to_string(),
    "https://example.org/api/v1".parse()?,
    ConnectionSecurity::Unsafe,
)?;

assert_eq!(config.get_single_device_label()?, "device1".to_string());

config.add_device(
    "device2".to_string(),
    "https://example.org/other/api/v1".parse()?,
    ConnectionSecurity::Unsafe,
)?;
// this fails because there is more than one device
assert!(config.get_single_device_label().is_err());

config.delete_device("device1")?;
config.delete_device("device2")?;
// this fails because there is no device
assert!(config.get_single_device_label().is_err());

pub fn add_credentials( &self, label: String, credentials: ConfigCredentials, ) -> Result<(), Error>

Adds new credentials for a DeviceConfig

Using a label that identifies a DeviceConfig, new credentials tracking a [UserRole], a name and optionally a passphrase are added to it.

Errors

Returns an Error::DeviceMissing if the targeted DeviceConfig does not exist. Returns an Error::CredentialsExist if the ConfigCredentials identified by name exist already.

Examples

use nethsm::{ConnectionSecurity, UserRole};
use nethsm_config::{Config, ConfigCredentials, ConfigInteractivity, ConfigSettings};

// this fails because the targeted device does not yet exist
assert!(
    config
        .add_credentials(
            "device1".to_string(),
            ConfigCredentials::new(
                UserRole::Operator,
                "user1".parse()?,
                Some("my-passphrase".to_string()),
            ),
        )
        .is_err()
);

config.add_device(
    "device1".to_string(),
    "https://example.org/api/v1".parse()?,
    ConnectionSecurity::Unsafe,
)?;

config.add_credentials(
    "device1".to_string(),
    ConfigCredentials::new(
        UserRole::Operator,
        "user1".parse()?,
        Some("my-passphrase".to_string()),
    ),
)?;

// this fails because the credentials exist already
assert!(
    config
        .add_credentials(
            "device1".to_string(),
            ConfigCredentials::new(
                UserRole::Operator,
                "user1".parse()?,
                Some("my-passphrase".to_string()),
            ),
        )
        .is_err()
);

pub fn delete_credentials( &self, label: &str, name: &UserId, ) -> Result<(), Error>

Deletes credentials from a DeviceConfig

The label identifies the DeviceConfig and the name the name of the credentials.

Errors

Returns an Error::DeviceMissing if the targeted DeviceConfig does not exist. Returns an Error::CredentialsMissing if the targeted ConfigCredentials do not exist.

Examples

use nethsm::{ConnectionSecurity, UserRole};
use nethsm_config::{Config, ConfigCredentials, ConfigInteractivity, ConfigSettings};

// this fails because the targeted device does not yet exist
assert!(
    config
        .delete_credentials("device1", &"user1".parse()?)
        .is_err()
);

config.add_device(
    "device1".to_string(),
    "https://example.org/api/v1".parse()?,
    ConnectionSecurity::Unsafe,
)?;

// this fails because the targeted credentials does not yet exist
assert!(
    config
        .delete_credentials("device1", &"user1".parse()?)
        .is_err()
);

config.add_credentials(
    "device1".to_string(),
    ConfigCredentials::new(
        UserRole::Operator,
        "user1".parse()?,
        Some("my-passphrase".to_string()),
    ),
)?;

config.delete_credentials("device1", &"user1".parse()?)?;

pub fn get_config_settings(&self) -> ConfigSettings

Returns the ConfigSettings of the Config

Examples

use nethsm_config::{Config, ConfigInteractivity, ConfigSettings};
let config_settings = ConfigSettings::new(
    "my_app".to_string(),
    ConfigInteractivity::NonInteractive,
    None,
);
let config = Config::new(
    config_settings.clone(),
    Some(&testdir::testdir!().join("my_app_get_config_settings.conf")),
)?;

println!("{:?}", config.get_config_settings());

pub fn get_default_config_file_path(&self) -> Result<PathBuf, Error>

Returns the default config file location

Errors

Returns an Error::ConfigFileLocation if the config file location can not be retrieved.

Examples

use nethsm_config::{Config, ConfigInteractivity, ConfigSettings};
let config = Config::new(
    ConfigSettings::new(
        "my_app".to_string(),
        ConfigInteractivity::NonInteractive,
        None,
    ),
    Some(&testdir::testdir!().join("my_app_get_default_config_file_path.conf")),
)?;

println!("{:?}", config.get_default_config_file_path()?);

pub fn store(&self, path: Option<&Path>) -> Result<(), Error>

Writes the configuration to file

Errors

Returns an Error::Store if the configuration can not be written to file.

Examples

use nethsm::ConnectionSecurity;
use nethsm_config::{Config, ConfigInteractivity, ConfigSettings};

let config_file = testdir::testdir!().join("my_app_store.conf");
config.store(Some(&config_file))?;

// this fails because we can not write the configuration to a directory
assert!(config.store(Some(&testdir::testdir!())).is_err());

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Config

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

Formats the value using the given formatter.

impl Default for Config

fn default() -> Config

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Config

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Config

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.