Struct Profile 

pub struct Profile {

    pub access_key: Option<String>,
    pub secret_key: Option<String>,
    pub x509_client_cert: Option<String>,
    pub x509_client_key: Option<String>,
    pub x509_client_cert_b64: Option<String>,
    pub x509_client_key_b64: Option<String>,
    pub tls_skip_verify: bool,
    pub login: Option<String>,
    pub password: Option<String>,
    pub protocol: String,
    pub region: String,
    pub endpoints: Endpoint,
    pub backoff_params: BackoffParams,
    pub limiter_params: LimiterParams,
}

Fields

access_key: Option<String>

secret_key: Option<String>

x509_client_cert: Option<String>

x509_client_key: Option<String>

x509_client_cert_b64: Option<String>

x509_client_key_b64: Option<String>

tls_skip_verify: bool

login: Option<String>

password: Option<String>

protocol: String

region: String

endpoints: Endpoint

backoff_params: BackoffParams

limiter_params: LimiterParams

Implementations

impl Profile

pub fn builder() -> ProfileBuilder

pub fn default() -> Result<Profile>

Examples found in repository

examples/keypair.rs (line 9)

fn main() {
    let config = Profile::default().and_then(|p| p.try_into()).unwrap();

    // Example reading all keypairs
    print!("Reading all keypairs... ");
    let request = ReadKeypairsRequest::new();
    let response = match read_keypairs(&config, Some(request)) {
        Err(error) => {
            println!("Error: {:?}", error);
            return;
        }
        Ok(resp) => resp,
    };
    if let Some(keypairs) = response.keypairs {
        println!("OK -> there are {} keypairs", keypairs.len());
    }

    // Example creating a keypair
    print!("Creating new keypair... ");
    let mut rng = rand::rng();
    let keypair_name = format!("osc-sdk-rust-test-{}", rng.random::<u64>());
    let request = CreateKeypairRequest::new(keypair_name.clone());
    match create_keypair(&config, Some(request)) {
        Err(error) => {
            println!("Error: {:?}", error);
            return;
        }
        Ok(resp) => resp,
    };
    println!("OK -> created keypair {}", keypair_name);

    // Filtering on newly created keypair
    print!("Filtering on {}... ", keypair_name);
    let mut filters = FiltersKeypair::new();
    filters.keypair_names = Some(vec![keypair_name.clone()]);
    let mut request = ReadKeypairsRequest::new();
    request.filters = Some(Box::new(filters));
    if let Err(error) = read_keypairs(&config, Some(request)) {
        eprintln!("Error: {:?}", error);
        std::process::exit(1);
    }
    println!("OK");

    // Deleting a keypair
    print!("Deleting keypair {}... ", keypair_name);
    let mut request = DeleteKeypairRequest::new();
    request.keypair_name = Some(keypair_name.clone());
    if let Err(error) = delete_keypair(&config, Some(request)) {
        eprintln!("Error: {:?}", error);
        std::process::exit(1);
    }
    println!("OK");
}

examples/volume.rs (line 8)

fn main() {
    let config = Profile::default().and_then(|p| p.try_into()).unwrap();

    // Example reading all volumes
    print!("Reading all volumes... ");
    let request = ReadVolumesRequest::new();
    let response = match read_volumes(&config, Some(request)) {
        Err(error) => {
            eprintln!("Error: {:?}", error);
            std::process::exit(1);
        }
        Ok(resp) => resp,
    };
    if let Some(volumes) = response.volumes {
        println!("OK -> there are {} volumes", volumes.len());
    }

    // Example creating a volume
    print!("Creating new volume... ");
    let mut request = CreateVolumeRequest::new("eu-west-2a".to_string());
    request.volume_type = Some("gp2".to_string());
    request.size = Some(10);
    let response = match create_volume(&config, Some(request)) {
        Err(error) => {
            eprintln!("Error: {:?}", error);
            std::process::exit(1);
        }
        Ok(resp) => resp,
    };
    let volume_id = response.volume.unwrap().volume_id.unwrap();
    println!("OK -> created volume id {}", volume_id);

    // Filtering on newly created volume
    print!("Filtering on {}... ", volume_id);
    let mut filters = FiltersVolume::new();
    filters.volume_ids = Some(vec![volume_id.clone()]);
    let mut request = ReadVolumesRequest::new();
    request.filters = Some(Box::new(filters));
    if let Err(error) = read_volumes(&config, Some(request)) {
        eprintln!("Error: {:?}", error);
        std::process::exit(1);
    }
    println!("OK");

    // Deleting a volume
    print!("Deleting volume {}... ", volume_id);
    let request = DeleteVolumeRequest::new(volume_id.clone());
    if let Err(error) = delete_volume(&config, Some(request)) {
        eprintln!("Error: {:?}", error);
        std::process::exit(1);
    }
    println!("OK");
}

Trait Implementations

impl TryFrom<Profile> for Configuration

type Error = ConfigurationFileError

The type returned in the event of a conversion error.

fn try_from(value: Profile) -> Result<Self, Self::Error>

Performs the conversion.