openapi_service_fabric/apis/

node_api.rs

/*
 * Service Fabric Client APIs
 *
 * Service Fabric REST Client APIs allows management of Service Fabric clusters, applications and services.
 *
 * The version of the OpenAPI document: 8.2
 *
 * Generated by: https://openapi-generator.tech
 */

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

/// struct for typed errors of method [`add_configuration_parameter_overrides`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AddConfigurationParameterOverridesError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`add_node_tags`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AddNodeTagsError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`disable_node`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DisableNodeError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`enable_node`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EnableNodeError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_configuration_overrides`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetConfigurationOverridesError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_node_health`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetNodeHealthError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_node_health_using_policy`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetNodeHealthUsingPolicyError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_node_info`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetNodeInfoError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_node_info_list`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetNodeInfoListError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_node_load_info`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetNodeLoadInfoError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`remove_configuration_overrides`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RemoveConfigurationOverridesError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`remove_node_state`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RemoveNodeStateError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`remove_node_tags`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RemoveNodeTagsError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`report_node_health`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReportNodeHealthError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`restart_node`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RestartNodeError {
    DefaultResponse(models::FabricError),
    UnknownValue(serde_json::Value),
}

/// This api allows adding all existing configuration overrides on the specified node.
pub async fn add_configuration_parameter_overrides(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    config_parameter_override_list: Vec<models::ConfigParameterOverride>,
    force: Option<bool>,
    timeout: Option<i64>,
) -> Result<(), Error<AddConfigurationParameterOverridesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_body_config_parameter_override_list = config_parameter_override_list;
    let p_query_force = force;
    let p_query_timeout = timeout;

    let uri_str = format!(
        "{}/Nodes/{nodeName}/$/AddConfigurationParameterOverrides",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref param_value) = p_query_force {
        req_builder = req_builder.query(&[("Force", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_timeout {
        req_builder = req_builder.query(&[("timeout", &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());
    }
    req_builder = req_builder.json(&p_body_config_parameter_override_list);

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<AddConfigurationParameterOverridesError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// This api allows adding tags to the specified node.
pub async fn add_node_tags(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    node_tags: Vec<String>,
) -> Result<(), Error<AddNodeTagsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_body_node_tags = node_tags;

    let uri_str = format!(
        "{}/Nodes/{nodeName}/$/AddNodeTags",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_node_tags);

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<AddNodeTagsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Deactivate a Service Fabric cluster node with the specified deactivation intent. Once the deactivation is in progress, the deactivation intent can be increased, but not decreased (for example, a node that is deactivated with the Pause intent can be deactivated further with Restart, but not the other way around. Nodes may be reactivated using the Activate a node operation any time after they are deactivated. If the deactivation is not complete, this will cancel the deactivation. A node that goes down and comes back up while deactivated will still need to be reactivated before services will be placed on that node.
pub async fn disable_node(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    deactivation_intent_description: models::DeactivationIntentDescription,
    timeout: Option<i64>,
) -> Result<(), Error<DisableNodeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_body_deactivation_intent_description = deactivation_intent_description;
    let p_query_timeout = timeout;

    let uri_str = format!(
        "{}/Nodes/{nodeName}/$/Deactivate",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref param_value) = p_query_timeout {
        req_builder = req_builder.query(&[("timeout", &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());
    }
    req_builder = req_builder.json(&p_body_deactivation_intent_description);

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<DisableNodeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Activates a Service Fabric cluster node that is currently deactivated. Once activated, the node will again become a viable target for placing new replicas, and any deactivated replicas remaining on the node will be reactivated.
pub async fn enable_node(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    timeout: Option<i64>,
) -> Result<(), Error<EnableNodeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_query_timeout = timeout;

    let uri_str = format!(
        "{}/Nodes/{nodeName}/$/Activate",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref param_value) = p_query_timeout {
        req_builder = req_builder.query(&[("timeout", &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());
    }

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<EnableNodeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// This api allows getting all existing configuration overrides on the specified node.
pub async fn get_configuration_overrides(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    timeout: Option<i64>,
) -> Result<Vec<models::ConfigParameterOverride>, Error<GetConfigurationOverridesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_query_timeout = timeout;

    let uri_str = format!(
        "{}/Nodes/{nodeName}/$/GetConfigurationOverrides",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref param_value) = p_query_timeout {
        req_builder = req_builder.query(&[("timeout", &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());
    }

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::ConfigParameterOverride&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::ConfigParameterOverride&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetConfigurationOverridesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Gets the health of a Service Fabric node. Use EventsHealthStateFilter to filter the collection of health events reported on the node based on the health state. If the node that you specify by name does not exist in the health store, this returns an error.
pub async fn get_node_health(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    events_health_state_filter: Option<i32>,
    timeout: Option<i64>,
) -> Result<models::NodeHealth, Error<GetNodeHealthError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_query_events_health_state_filter = events_health_state_filter;
    let p_query_timeout = timeout;

    let uri_str = format!(
        "{}/Nodes/{nodeName}/$/GetHealth",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref param_value) = p_query_events_health_state_filter {
        req_builder = req_builder.query(&[("EventsHealthStateFilter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_timeout {
        req_builder = req_builder.query(&[("timeout", &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());
    }

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodeHealth`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodeHealth`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetNodeHealthError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Gets the health of a Service Fabric node. Use EventsHealthStateFilter to filter the collection of health events reported on the node based on the health state. Use ClusterHealthPolicy in the POST body to override the health policies used to evaluate the health. If the node that you specify by name does not exist in the health store, this returns an error.
pub async fn get_node_health_using_policy(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    events_health_state_filter: Option<i32>,
    timeout: Option<i64>,
    cluster_health_policy: Option<models::ClusterHealthPolicy>,
) -> Result<models::NodeHealth, Error<GetNodeHealthUsingPolicyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_query_events_health_state_filter = events_health_state_filter;
    let p_query_timeout = timeout;
    let p_body_cluster_health_policy = cluster_health_policy;

    let uri_str = format!(
        "{}/Nodes/{nodeName}/$/GetHealth",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref param_value) = p_query_events_health_state_filter {
        req_builder = req_builder.query(&[("EventsHealthStateFilter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_timeout {
        req_builder = req_builder.query(&[("timeout", &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());
    }
    req_builder = req_builder.json(&p_body_cluster_health_policy);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodeHealth`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodeHealth`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetNodeHealthUsingPolicyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// The response includes the name, status, ID, health, uptime, and other details about the node.
pub async fn get_node_info(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    timeout: Option<i64>,
) -> Result<models::NodeInfo, Error<GetNodeInfoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_query_timeout = timeout;

    let uri_str = format!(
        "{}/Nodes/{nodeName}",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref param_value) = p_query_timeout {
        req_builder = req_builder.query(&[("timeout", &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());
    }

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodeInfo`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodeInfo`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetNodeInfoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// The response includes the name, status, ID, health, uptime, and other details about the nodes.
pub async fn get_node_info_list(
    configuration: &configuration::Configuration,
    api_version: &str,
    continuation_token: Option<&str>,
    node_status_filter: Option<&str>,
    max_results: Option<i64>,
    timeout: Option<i64>,
) -> Result<models::PagedNodeInfoList, Error<GetNodeInfoListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_query_continuation_token = continuation_token;
    let p_query_node_status_filter = node_status_filter;
    let p_query_max_results = max_results;
    let p_query_timeout = timeout;

    let uri_str = format!("{}/Nodes", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref param_value) = p_query_continuation_token {
        req_builder = req_builder.query(&[("ContinuationToken", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_node_status_filter {
        req_builder = req_builder.query(&[("NodeStatusFilter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_max_results {
        req_builder = req_builder.query(&[("MaxResults", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_timeout {
        req_builder = req_builder.query(&[("timeout", &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());
    }

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::PagedNodeInfoList`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::PagedNodeInfoList`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetNodeInfoListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Retrieves the load information of a Service Fabric node for all the metrics that have load or capacity defined.
pub async fn get_node_load_info(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    timeout: Option<i64>,
) -> Result<models::NodeLoadInfo, Error<GetNodeLoadInfoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_query_timeout = timeout;

    let uri_str = format!(
        "{}/Nodes/{nodeName}/$/GetLoadInformation",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref param_value) = p_query_timeout {
        req_builder = req_builder.query(&[("timeout", &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());
    }

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodeLoadInfo`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodeLoadInfo`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetNodeLoadInfoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// This api allows removing all existing configuration overrides on specified node.
pub async fn remove_configuration_overrides(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    timeout: Option<i64>,
) -> Result<(), Error<RemoveConfigurationOverridesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_query_timeout = timeout;

    let uri_str = format!(
        "{}/Nodes/{nodeName}/$/RemoveConfigurationOverrides",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref param_value) = p_query_timeout {
        req_builder = req_builder.query(&[("timeout", &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());
    }

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<RemoveConfigurationOverridesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// This implies that it is not possible to recover the persisted state of that node. This generally happens if a hard disk has been wiped clean, or if a hard disk crashes. The node has to be down for this operation to be successful. This operation lets Service Fabric know that the replicas on that node no longer exist, and that Service Fabric should stop waiting for those replicas to come back up. Do not run this cmdlet if the state on the node has not been removed and the node can come back up with its state intact. Starting from Service Fabric 6.5, in order to use this API for seed nodes, please change the seed nodes to regular (non-seed) nodes and then invoke this API to remove the node state. If the cluster is running on Azure, after the seed node goes down, Service Fabric will try to change it to a non-seed node automatically. To make this happen, make sure the number of non-seed nodes in the primary node type is no less than the number of Down seed nodes. If necessary, add more nodes to the primary node type to achieve this. For standalone cluster, if the Down seed node is not expected to come back up with its state intact, please remove the node from the cluster, see https://docs.microsoft.com/azure/service-fabric/service-fabric-cluster-windows-server-add-remove-nodes
pub async fn remove_node_state(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    timeout: Option<i64>,
) -> Result<(), Error<RemoveNodeStateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_query_timeout = timeout;

    let uri_str = format!(
        "{}/Nodes/{nodeName}/$/RemoveNodeState",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref param_value) = p_query_timeout {
        req_builder = req_builder.query(&[("timeout", &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());
    }

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<RemoveNodeStateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// This api allows removing set of tags from the specified node.
pub async fn remove_node_tags(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    node_tags: Vec<String>,
) -> Result<(), Error<RemoveNodeTagsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_body_node_tags = node_tags;

    let uri_str = format!(
        "{}/Nodes/{nodeName}/$/RemoveNodeTags",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_node_tags);

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<RemoveNodeTagsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Reports health state of the specified Service Fabric node. The report must contain the information about the source of the health report and property on which it is reported. The report is sent to a Service Fabric gateway node, which forwards to the health store. The report may be accepted by the gateway, but rejected by the health store after extra validation. For example, the health store may reject the report because of an invalid parameter, like a stale sequence number. To see whether the report was applied in the health store, run GetNodeHealth and check that the report appears in the HealthEvents section.
pub async fn report_node_health(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    health_information: models::HealthInformation,
    immediate: Option<bool>,
    timeout: Option<i64>,
) -> Result<(), Error<ReportNodeHealthError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_body_health_information = health_information;
    let p_query_immediate = immediate;
    let p_query_timeout = timeout;

    let uri_str = format!(
        "{}/Nodes/{nodeName}/$/ReportHealth",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref param_value) = p_query_immediate {
        req_builder = req_builder.query(&[("Immediate", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_timeout {
        req_builder = req_builder.query(&[("timeout", &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());
    }
    req_builder = req_builder.json(&p_body_health_information);

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<ReportNodeHealthError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Restarts a Service Fabric cluster node that is already started.
pub async fn restart_node(
    configuration: &configuration::Configuration,
    api_version: &str,
    node_name: &str,
    restart_node_description: models::RestartNodeDescription,
    timeout: Option<i64>,
) -> Result<(), Error<RestartNodeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_api_version = api_version;
    let p_path_node_name = node_name;
    let p_body_restart_node_description = restart_node_description;
    let p_query_timeout = timeout;

    let uri_str = format!(
        "{}/Nodes/{nodeName}/$/Restart",
        configuration.base_path,
        nodeName = crate::apis::urlencode(p_path_node_name)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("api-version", &p_query_api_version.to_string())]);
    if let Some(ref param_value) = p_query_timeout {
        req_builder = req_builder.query(&[("timeout", &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());
    }
    req_builder = req_builder.json(&p_body_restart_node_description);

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<RestartNodeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}