Struct Client

pub struct Client {
    pub vm: VmProcedures,
    pub xo: XoProcedures,
    pub token: TokenProcedures,
    pub session: SessionProcedures,
    /* private fields */
}

Client used to communicate with Xen Orchestra’s API

Example of listing all VMs with the tag Test

use std::collections::BTreeMap;
use xo_api_client::{credentials::EmailAndPassword, Client, api::vm::{Vm, VmId}};

// We dont care about any of the data under the "other" attribute
// in this example
#[derive(serde::Deserialize)]
struct OtherInfo {}

impl xo_api_client::api::vm::OtherInfo for OtherInfo {}

#[tokio::main]
async fn main() {
    let url = "ws://localhost:8080/api/";
    let email = String::from("admin@admin.net");
    let password = String::from("admin");

    let con = Client::connect(url)
        .await
        .expect("Failed to connect to server");

    con
        .session
        .sign_in(EmailAndPassword { email, password })
        .await
        .expect("Failed to sign in");

    let all_vms: BTreeMap<VmId, Vm<OtherInfo>> =
        con.xo.get_objects(None, None).await.expect("Failed to list VMs");

    let test_vms = all_vms
        .iter()
        .filter(|(_id, vm)| vm.tags.iter().any(|tag| tag == "Test"));

    println!("All VMs with the tag 'Test':");
    for (id, vm) in test_vms {
        println!("ID: {:?}, Name: {}", id, vm.name_label);
    }
}

Fields

vm: VmProcedures

xo: XoProcedures

token: TokenProcedures

session: SessionProcedures

Implementations

impl Client

pub async fn connect(url: &str) -> Result<Self, RpcError>

Connect to xo-server

Note that url is the websocket URL to the API endpoint, usually something like wss://example.com/api/ or ws://example.com/api/ for unencrypted

pub async fn subscribe_to_notification_all<T>( &self, ) -> Result<Subscription<T>, RpcError>

where T: DeserializeOwned,

Subscribe to method “all”

xo-server tends to send notifications to the client’s JSON RPC procedure “all” subscribe_to_notification_all returns a value that can be used to read those notifications