Struct datadog_api_client::datadogV2::api::api_api_management::APIManagementAPI

pub struct APIManagementAPI { /* private fields */ }

Configure your API endpoints through the Datadog API.

Implementations

impl APIManagementAPI

pub fn new() -> Self

pub fn with_config(config: Configuration) -> Self

Examples found in repository

examples/v2_api-management_ListAPIs.rs (line 10)

async fn main() {
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.ListAPIs", true);
    let api = APIManagementAPI::with_config(configuration);
    let resp = api.list_apis(ListAPIsOptionalParams::default()).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_api-management_CreateOpenAPI.rs (line 11)

async fn main() {
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.CreateOpenAPI", true);
    let api = APIManagementAPI::with_config(configuration);
    let resp = api
        .create_open_api(
            CreateOpenAPIOptionalParams::default()
                .openapi_spec_file(fs::read("openapi-spec.yaml").unwrap()),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_api-management_GetOpenAPI.rs (line 12)

async fn main() {
    // there is a valid "managed_api" in the system
    let managed_api_data_id = uuid::Uuid::parse_str(&std::env::var("MANAGED_API_DATA_ID").unwrap())
        .expect("Invalid UUID");
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.GetOpenAPI", true);
    let api = APIManagementAPI::with_config(configuration);
    let resp = api.get_open_api(managed_api_data_id.clone()).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_api-management_DeleteOpenAPI.rs (line 12)

async fn main() {
    // there is a valid "managed_api" in the system
    let managed_api_data_id = uuid::Uuid::parse_str(&std::env::var("MANAGED_API_DATA_ID").unwrap())
        .expect("Invalid UUID");
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.DeleteOpenAPI", true);
    let api = APIManagementAPI::with_config(configuration);
    let resp = api.delete_open_api(managed_api_data_id.clone()).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_api-management_UpdateOpenAPI.rs (line 14)

async fn main() {
    // there is a valid "managed_api" in the system
    let managed_api_data_id = uuid::Uuid::parse_str(&std::env::var("MANAGED_API_DATA_ID").unwrap())
        .expect("Invalid UUID");
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.UpdateOpenAPI", true);
    let api = APIManagementAPI::with_config(configuration);
    let resp = api
        .update_open_api(
            managed_api_data_id.clone(),
            UpdateOpenAPIOptionalParams::default()
                .openapi_spec_file(fs::read("openapi-spec.yaml").unwrap()),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub fn with_client_and_config( config: Configuration, client: ClientWithMiddleware, ) -> Self

pub async fn create_open_api( &self, params: CreateOpenAPIOptionalParams, ) -> Result<CreateOpenAPIResponse, Error<CreateOpenAPIError>>

Create a new API from the OpenAPI specification given. See the API Catalog documentation for additional information about the possible metadata. It returns the created API ID.

Examples found in repository

examples/v2_api-management_CreateOpenAPI.rs (lines 13-16)

async fn main() {
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.CreateOpenAPI", true);
    let api = APIManagementAPI::with_config(configuration);
    let resp = api
        .create_open_api(
            CreateOpenAPIOptionalParams::default()
                .openapi_spec_file(fs::read("openapi-spec.yaml").unwrap()),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn create_open_api_with_http_info( &self, params: CreateOpenAPIOptionalParams, ) -> Result<ResponseContent<CreateOpenAPIResponse>, Error<CreateOpenAPIError>>

Create a new API from the OpenAPI specification given. See the API Catalog documentation for additional information about the possible metadata. It returns the created API ID.

pub async fn delete_open_api( &self, id: Uuid, ) -> Result<(), Error<DeleteOpenAPIError>>

Delete a specific API by ID.

Examples found in repository

examples/v2_api-management_DeleteOpenAPI.rs (line 13)

async fn main() {
    // there is a valid "managed_api" in the system
    let managed_api_data_id = uuid::Uuid::parse_str(&std::env::var("MANAGED_API_DATA_ID").unwrap())
        .expect("Invalid UUID");
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.DeleteOpenAPI", true);
    let api = APIManagementAPI::with_config(configuration);
    let resp = api.delete_open_api(managed_api_data_id.clone()).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn delete_open_api_with_http_info( &self, id: Uuid, ) -> Result<ResponseContent<()>, Error<DeleteOpenAPIError>>

Delete a specific API by ID.

pub async fn get_open_api( &self, id: Uuid, ) -> Result<Vec<u8>, Error<GetOpenAPIError>>

Retrieve information about a specific API in OpenAPI format file.

Examples found in repository

examples/v2_api-management_GetOpenAPI.rs (line 13)

async fn main() {
    // there is a valid "managed_api" in the system
    let managed_api_data_id = uuid::Uuid::parse_str(&std::env::var("MANAGED_API_DATA_ID").unwrap())
        .expect("Invalid UUID");
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.GetOpenAPI", true);
    let api = APIManagementAPI::with_config(configuration);
    let resp = api.get_open_api(managed_api_data_id.clone()).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn get_open_api_with_http_info( &self, id: Uuid, ) -> Result<ResponseContent<Vec<u8>>, Error<GetOpenAPIError>>

Retrieve information about a specific API in OpenAPI format file.

pub async fn list_apis( &self, params: ListAPIsOptionalParams, ) -> Result<ListAPIsResponse, Error<ListAPIsError>>

List APIs and their IDs.

Examples found in repository

examples/v2_api-management_ListAPIs.rs (line 11)

async fn main() {
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.ListAPIs", true);
    let api = APIManagementAPI::with_config(configuration);
    let resp = api.list_apis(ListAPIsOptionalParams::default()).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn list_apis_with_http_info( &self, params: ListAPIsOptionalParams, ) -> Result<ResponseContent<ListAPIsResponse>, Error<ListAPIsError>>

List APIs and their IDs.

pub async fn update_open_api( &self, id: Uuid, params: UpdateOpenAPIOptionalParams, ) -> Result<UpdateOpenAPIResponse, Error<UpdateOpenAPIError>>

Update information about a specific API. The given content will replace all API content of the given ID. The ID is returned by the create API, or can be found in the URL in the API catalog UI.

Examples found in repository

examples/v2_api-management_UpdateOpenAPI.rs (lines 16-20)

async fn main() {
    // there is a valid "managed_api" in the system
    let managed_api_data_id = uuid::Uuid::parse_str(&std::env::var("MANAGED_API_DATA_ID").unwrap())
        .expect("Invalid UUID");
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.UpdateOpenAPI", true);
    let api = APIManagementAPI::with_config(configuration);
    let resp = api
        .update_open_api(
            managed_api_data_id.clone(),
            UpdateOpenAPIOptionalParams::default()
                .openapi_spec_file(fs::read("openapi-spec.yaml").unwrap()),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn update_open_api_with_http_info( &self, id: Uuid, params: UpdateOpenAPIOptionalParams, ) -> Result<ResponseContent<UpdateOpenAPIResponse>, Error<UpdateOpenAPIError>>

Update information about a specific API. The given content will replace all API content of the given ID. The ID is returned by the create API, or can be found in the URL in the API catalog UI.

Trait Implementations

impl Clone for APIManagementAPI

fn clone(&self) -> APIManagementAPI

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for APIManagementAPI

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

Formats the value using the given formatter.

impl Default for APIManagementAPI

fn default() -> Self

Returns the “default value” for a type.