Struct Client 

pub struct Client { /* private fields */ }

Client for ip-allocator-webserver

Version: 0.2.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...");
    // Pass None for immediate return, or Some(seconds) to wait for availability
    // Example: client.handlers_ip_borrow(Some(30)).await? // Wait up to 30 seconds
    let borrow_result = client.handlers_ip_borrow(None).await?;
    println!("✅ Borrowed item: {:?}", borrow_result.item);
    println!("🎟️  Borrow token: {}", borrow_result.borrow_token);

    // Return the borrowed item to the freelist
    println!("\n🔄 Returning the item...");
    let return_input = ip_allocator_client::types::ReturnInput {
        item: borrow_result.item.clone(),
        borrow_token: borrow_result.borrow_token.clone(),
    };
    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, wait: Option<u64>, ) -> Result<ResponseValue<BorrowOutput>, Error<()>>

Borrow an item from the freelist

Returns an item along with a borrow_token that must be provided when returning the item. Optional query parameter wait specifies the maximum number of seconds to wait for an item to become available. If not specified, returns immediately. If specified, the request will block until an item becomes available or the timeout is reached.

Sends a GET request to /borrow

Examples found in repository

examples/basic.rs (line 12)

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...");
    // Pass None for immediate return, or Some(seconds) to wait for availability
    // Example: client.handlers_ip_borrow(Some(30)).await? // Wait up to 30 seconds
    let borrow_result = client.handlers_ip_borrow(None).await?;
    println!("✅ Borrowed item: {:?}", borrow_result.item);
    println!("🎟️  Borrow token: {}", borrow_result.borrow_token);

    // Return the borrowed item to the freelist
    println!("\n🔄 Returning the item...");
    let return_input = ip_allocator_client::types::ReturnInput {
        item: borrow_result.item.clone(),
        borrow_token: borrow_result.borrow_token.clone(),
    };
    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

Requires the borrow_token that was provided when the item was borrowed. This prevents accidentally returning an item currently borrowed by someone else.

Sends a POST request to /return

Examples found in repository

examples/basic.rs (line 22)

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...");
    // Pass None for immediate return, or Some(seconds) to wait for availability
    // Example: client.handlers_ip_borrow(Some(30)).await? // Wait up to 30 seconds
    let borrow_result = client.handlers_ip_borrow(None).await?;
    println!("✅ Borrowed item: {:?}", borrow_result.item);
    println!("🎟️  Borrow token: {}", borrow_result.borrow_token);

    // Return the borrowed item to the freelist
    println!("\n🔄 Returning the item...");
    let return_input = ip_allocator_client::types::ReturnInput {
        item: borrow_result.item.clone(),
        borrow_token: borrow_result.borrow_token.clone(),
    };
    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 28)

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...");
    // Pass None for immediate return, or Some(seconds) to wait for availability
    // Example: client.handlers_ip_borrow(Some(30)).await? // Wait up to 30 seconds
    let borrow_result = client.handlers_ip_borrow(None).await?;
    println!("✅ Borrowed item: {:?}", borrow_result.item);
    println!("🎟️  Borrow token: {}", borrow_result.borrow_token);

    // Return the borrowed item to the freelist
    println!("\n🔄 Returning the item...");
    let return_input = ip_allocator_client::types::ReturnInput {
        item: borrow_result.item.clone(),
        borrow_token: borrow_result.borrow_token.clone(),
    };
    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.