tembo_api_client/apis/

instance_api.rs

/*
 * Tembo Cloud
 *
 * Platform API for Tembo Cloud             </br>             </br>             To find a Tembo Data API, please find it here:             </br>             </br>             [AWS US East 1](https://api.data-1.use1.tembo.io/swagger-ui/)
 *
 * The version of the OpenAPI document: v1.0.0
 *
 * Generated by: https://openapi-generator.tech
 */

use super::{configuration, Error};
use crate::{apis::ResponseContent, models};
use reqwest;
use serde::{Deserialize, Serialize};

/// struct for typed errors of method [`create_instance`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateInstanceError {
    Status400(models::ErrorResponseSchema),
    Status401(String),
    Status403(models::ErrorResponseSchema),
    Status409(models::ErrorResponseSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_instance`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteInstanceError {
    Status400(models::ErrorResponseSchema),
    Status401(models::ErrorResponseSchema),
    Status403(models::ErrorResponseSchema),
    Status409(models::ErrorResponseSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_all`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetAllError {
    Status400(models::ErrorResponseSchema),
    Status401(models::ErrorResponseSchema),
    Status403(models::ErrorResponseSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_instance`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetInstanceError {
    Status400(models::ErrorResponseSchema),
    Status401(models::ErrorResponseSchema),
    Status403(models::ErrorResponseSchema),
    Status404(models::ErrorResponseSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_instance_history`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetInstanceHistoryError {
    Status401(models::ErrorResponseSchema),
    Status403(models::ErrorResponseSchema),
    Status404(models::ErrorResponseSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_instance_toml`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetInstanceTomlError {
    Status401(models::ErrorResponseSchema),
    Status403(serde_json::Value),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_schema`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSchemaError {
    Status401(models::ErrorResponseSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`instance_event`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InstanceEventError {
    Status401(models::ErrorResponseSchema),
    Status403(models::ErrorResponseSchema),
    Status409(models::ErrorResponseSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_instance`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchInstanceError {
    Status400(models::ErrorResponseSchema),
    Status401(String),
    Status403(models::ErrorResponseSchema),
    Status409(models::ErrorResponseSchema),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`restore_instance`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RestoreInstanceError {
    Status400(models::ErrorResponseSchema),
    Status401(String),
    Status403(models::ErrorResponseSchema),
    Status409(models::ErrorResponseSchema),
    UnknownValue(serde_json::Value),
}

/// Create a new Tembo instance
pub async fn create_instance(
    configuration: &configuration::Configuration,
    org_id: &str,
    create_instance: models::CreateInstance,
) -> Result<models::Instance, Error<CreateInstanceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_org_id = org_id;
    let p_create_instance = create_instance;

    let uri_str = format!(
        "{}/api/v1/orgs/{org_id}/instances",
        configuration.base_path,
        org_id = crate::apis::urlencode(p_org_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_create_instance);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateInstanceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Delete an existing Tembo instance
pub async fn delete_instance(
    configuration: &configuration::Configuration,
    org_id: &str,
    instance_id: &str,
) -> Result<models::Instance, Error<DeleteInstanceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_org_id = org_id;
    let p_instance_id = instance_id;

    let uri_str = format!(
        "{}/api/v1/orgs/{org_id}/instances/{instance_id}",
        configuration.base_path,
        org_id = crate::apis::urlencode(p_org_id),
        instance_id = crate::apis::urlencode(p_instance_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteInstanceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get all Tembo instances in an organization
pub async fn get_all(
    configuration: &configuration::Configuration,
    org_id: &str,
) -> Result<Vec<models::Instance>, Error<GetAllError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_org_id = org_id;

    let uri_str = format!(
        "{}/api/v1/orgs/{org_id}/instances",
        configuration.base_path,
        org_id = crate::apis::urlencode(p_org_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAllError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get an existing Tembo instance
pub async fn get_instance(
    configuration: &configuration::Configuration,
    org_id: &str,
    instance_id: &str,
) -> Result<models::Instance, Error<GetInstanceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_org_id = org_id;
    let p_instance_id = instance_id;

    let uri_str = format!(
        "{}/api/v1/orgs/{org_id}/instances/{instance_id}",
        configuration.base_path,
        org_id = crate::apis::urlencode(p_org_id),
        instance_id = crate::apis::urlencode(p_instance_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetInstanceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get historical information for a given instance
pub async fn get_instance_history(
    configuration: &configuration::Configuration,
    org_id: &str,
    instance_id: &str,
    field: &str,
    start: Option<String>,
    end: Option<String>,
    page: Option<i32>,
    limit: Option<i32>,
) -> Result<models::HistoryPage, Error<GetInstanceHistoryError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_org_id = org_id;
    let p_instance_id = instance_id;
    let p_field = field;
    let p_start = start;
    let p_end = end;
    let p_page = page;
    let p_limit = limit;

    let uri_str = format!(
        "{}/api/v1/orgs/{org_id}/instances/{instance_id}/history/{field}",
        configuration.base_path,
        org_id = crate::apis::urlencode(p_org_id),
        instance_id = crate::apis::urlencode(p_instance_id),
        field = crate::apis::urlencode(p_field)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_start {
        req_builder = req_builder.query(&[("start", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_end {
        req_builder = req_builder.query(&[("end", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetInstanceHistoryError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Generate text for Tembo.toml
pub async fn get_instance_toml(
    configuration: &configuration::Configuration,
    org_id: &str,
    instance_id: &str,
) -> Result<serde_json::Value, Error<GetInstanceTomlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_org_id = org_id;
    let p_instance_id = instance_id;

    let uri_str = format!(
        "{}/api/v1/orgs/{org_id}/instances/{instance_id}/toml",
        configuration.base_path,
        org_id = crate::apis::urlencode(p_org_id),
        instance_id = crate::apis::urlencode(p_instance_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetInstanceTomlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get the json-schema for an instance
pub async fn get_schema(
    configuration: &configuration::Configuration,
) -> Result<models::ErrorResponseSchema, Error<GetSchemaError>> {
    let uri_str = format!("{}/api/v1/orgs/instances/schema", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSchemaError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Lifecycle events for a Tembo instance  Currently only supports restart
pub async fn instance_event(
    configuration: &configuration::Configuration,
    org_id: &str,
    event_type: models::InstanceEvent,
    instance_id: &str,
) -> Result<models::Instance, Error<InstanceEventError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_org_id = org_id;
    let p_event_type = event_type;
    let p_instance_id = instance_id;

    let uri_str = format!(
        "{}/api/v1/orgs/{org_id}/instances/{instance_id}",
        configuration.base_path,
        org_id = crate::apis::urlencode(p_org_id),
        instance_id = crate::apis::urlencode(p_instance_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("event_type", &p_event_type.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<InstanceEventError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Update attributes on an existing Tembo instance
pub async fn patch_instance(
    configuration: &configuration::Configuration,
    org_id: &str,
    instance_id: &str,
    patch_instance: models::PatchInstance,
) -> Result<models::Instance, Error<PatchInstanceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_org_id = org_id;
    let p_instance_id = instance_id;
    let p_patch_instance = patch_instance;

    let uri_str = format!(
        "{}/api/v1/orgs/{org_id}/instances/{instance_id}",
        configuration.base_path,
        org_id = crate::apis::urlencode(p_org_id),
        instance_id = crate::apis::urlencode(p_instance_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_patch_instance);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<PatchInstanceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Restore a Tembo instance
pub async fn restore_instance(
    configuration: &configuration::Configuration,
    org_id: &str,
    restore_instance: models::RestoreInstance,
) -> Result<models::Instance, Error<RestoreInstanceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_org_id = org_id;
    let p_restore_instance = restore_instance;

    let uri_str = format!(
        "{}/api/v1/orgs/{org_id}/restore",
        configuration.base_path,
        org_id = crate::apis::urlencode(p_org_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_restore_instance);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<RestoreInstanceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}