Struct Client 

pub struct Client { /* private fields */ }

Client for ip-allocator-webserver

Version: 0.1.0

Implementations

impl Client

pub fn new(baseurl: &str) -> Self

Create a new client.

baseurl is the base URL provided to the internal reqwest::Client, and should include a scheme and hostname, as well as port and a path stem if applicable.

Examples found in repository

examples/basic.rs (line 6)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new client
    let client = Client::new("http://localhost:8000");

    // Borrow an item from the freelist
    println!("🔄 Borrowing an item...");
    let borrow_result = client.handlers_ip_borrow().await?;
    println!("✅ Borrowed item: {:?}", borrow_result);

    // Return an item to the freelist
    println!("\n🔄 Returning an item...");
    let return_input = ip_allocator_client::types::ReturnInput {
        item: serde_json::json!({"ip": "192.168.1.100"}),
    };
    let return_result = client.handlers_ip_return_item(&return_input).await?;
    println!("✅ Return operation initiated: {:?}", return_result);

    // Check operation status
    println!("\n🔄 Checking operation status...");
    let status = client
        .handlers_ip_get_operation_status(&return_result.operation_id)
        .await?;
    println!("✅ Operation status: {:?}", status);

    Ok(())
}

pub fn new_with_client(baseurl: &str, client: Client) -> Self

Construct a new client with an existing reqwest::Client, allowing more control over its configuration.

baseurl is the base URL provided to the internal reqwest::Client, and should include a scheme and hostname, as well as port and a path stem if applicable.

pub fn baseurl(&self) -> &String

Get the base URL to which requests are made.

pub fn client(&self) -> &Client

Get the internal reqwest::Client used to make requests.

pub fn api_version(&self) -> &'static str

Get the version of this API.

This string is pulled directly from the source OpenAPI document and may be in any format the API selects.

impl Client

pub async fn handlers_ip_borrow<'a>( &'a self, ) -> Result<ResponseValue<BorrowOutput>, Error<()>>

Borrow an item from the freelist

Sends a GET request to /borrow

Examples found in repository

examples/basic.rs (line 10)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new client
    let client = Client::new("http://localhost:8000");

    // Borrow an item from the freelist
    println!("🔄 Borrowing an item...");
    let borrow_result = client.handlers_ip_borrow().await?;
    println!("✅ Borrowed item: {:?}", borrow_result);

    // Return an item to the freelist
    println!("\n🔄 Returning an item...");
    let return_input = ip_allocator_client::types::ReturnInput {
        item: serde_json::json!({"ip": "192.168.1.100"}),
    };
    let return_result = client.handlers_ip_return_item(&return_input).await?;
    println!("✅ Return operation initiated: {:?}", return_result);

    // Check operation status
    println!("\n🔄 Checking operation status...");
    let status = client
        .handlers_ip_get_operation_status(&return_result.operation_id)
        .await?;
    println!("✅ Operation status: {:?}", status);

    Ok(())
}

pub async fn handlers_ip_return_item<'a>( &'a self, body: &'a ReturnInput, ) -> Result<ResponseValue<OperationRef>, Error<()>>

Return an item to the freelist

Sends a POST request to /return

Examples found in repository

examples/basic.rs (line 18)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new client
    let client = Client::new("http://localhost:8000");

    // Borrow an item from the freelist
    println!("🔄 Borrowing an item...");
    let borrow_result = client.handlers_ip_borrow().await?;
    println!("✅ Borrowed item: {:?}", borrow_result);

    // Return an item to the freelist
    println!("\n🔄 Returning an item...");
    let return_input = ip_allocator_client::types::ReturnInput {
        item: serde_json::json!({"ip": "192.168.1.100"}),
    };
    let return_result = client.handlers_ip_return_item(&return_input).await?;
    println!("✅ Return operation initiated: {:?}", return_result);

    // Check operation status
    println!("\n🔄 Checking operation status...");
    let status = client
        .handlers_ip_get_operation_status(&return_result.operation_id)
        .await?;
    println!("✅ Operation status: {:?}", status);

    Ok(())
}

pub async fn handlers_ip_get_operation_status<'a>( &'a self, id: &'a str, ) -> Result<ResponseValue<OperationStatusOutput>, Error<()>>

Poll the status of an async operation

Sends a GET request to /operations/{id}

Examples found in repository

examples/basic.rs (line 24)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new client
    let client = Client::new("http://localhost:8000");

    // Borrow an item from the freelist
    println!("🔄 Borrowing an item...");
    let borrow_result = client.handlers_ip_borrow().await?;
    println!("✅ Borrowed item: {:?}", borrow_result);

    // Return an item to the freelist
    println!("\n🔄 Returning an item...");
    let return_input = ip_allocator_client::types::ReturnInput {
        item: serde_json::json!({"ip": "192.168.1.100"}),
    };
    let return_result = client.handlers_ip_return_item(&return_input).await?;
    println!("✅ Return operation initiated: {:?}", return_result);

    // Check operation status
    println!("\n🔄 Checking operation status...");
    let status = client
        .handlers_ip_get_operation_status(&return_result.operation_id)
        .await?;
    println!("✅ Operation status: {:?}", status);

    Ok(())
}

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Client

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

Formats the value using the given formatter.