pub enum InstanceError {
RequestFailure(reqwest::Error),
InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
UnexpectedStatus(reqwest::StatusCode),
Status504,
Status404 {
error: String,
},
Status403 {
error: String,
},
Status400 {
errors: Vec<String>,
},
Status500 {
golem_error: crate::model::GolemError,
},
Status401 {
error: String,
},
Status409 {
error: String,
},
}
impl From<reqwest::Error> for InstanceError {
fn from(error: reqwest::Error) -> InstanceError {
InstanceError::RequestFailure(error)
}
}
impl From<reqwest::header::InvalidHeaderValue> for InstanceError {
fn from(error: reqwest::header::InvalidHeaderValue) -> InstanceError {
InstanceError::InvalidHeaderValue(error)
}
}
impl InstanceError {
pub fn to_instance_endpoint_error(&self) -> Option<crate::model::InstanceEndpointError> {
match self {
InstanceError::Status500 { golem_error } => Some(crate::model::InstanceEndpointError::Golem { golem_error: golem_error.clone() }),
InstanceError::Status404 { error } => Some(crate::model::InstanceEndpointError::NotFound { error: error.clone() }),
InstanceError::Status504 => Some(crate::model::InstanceEndpointError::GatewayTimeout {}),
InstanceError::Status403 { error } => Some(crate::model::InstanceEndpointError::LimitExceeded { error: error.clone() }),
InstanceError::Status409 { error } => Some(crate::model::InstanceEndpointError::AlreadyExists { error: error.clone() }),
InstanceError::Status401 { error } => Some(crate::model::InstanceEndpointError::Unauthorized { error: error.clone() }),
InstanceError::Status400 { errors } => Some(crate::model::InstanceEndpointError::BadRequest { errors: errors.clone() }),
_ => None
}
}
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct InstanceEndpointErrorNotFoundPayload {
pub error: String,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct InstanceEndpointErrorLimitExceededPayload {
pub error: String,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct InstanceEndpointErrorBadRequestPayload {
pub errors: Vec<String>,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct InstanceEndpointErrorGolemPayload {
#[serde(rename = "golemError")]
pub golem_error: crate::model::GolemError,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct InstanceEndpointErrorUnauthorizedPayload {
pub error: String,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct InstanceEndpointErrorAlreadyExistsPayload {
pub error: String,
}
#[async_trait::async_trait]
pub trait Instance {
async fn get_instance_of_id(&self, worker_id: &str, authorization: &str) -> Result<crate::model::ComponentInstance, InstanceError>;
async fn launch_new_instance(&self, template_id: &str, field0: crate::model::WorkerCreationRequest, authorization: &str) -> Result<crate::model::ComponentInstance, InstanceError>;
async fn delete_instance(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<(), InstanceError>;
async fn get_invocation_key(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<crate::model::InvocationKey, InstanceError>;
async fn invoke_and_await_function(&self, template_id: &str, worker_name: &str, invocation_key: &str, function: &str, calling_convention: Option<&str>, field0: crate::model::InvokeParameters, authorization: &str) -> Result<crate::model::InvokeResult, InstanceError>;
async fn invoke_function(&self, template_id: &str, worker_name: &str, function: &str, field0: crate::model::InvokeParameters, authorization: &str) -> Result<(), InstanceError>;
async fn complete_instance_promise(&self, template_id: &str, worker_name: &str, field0: crate::model::CompleteParameters, authorization: &str) -> Result<bool, InstanceError>;
async fn interrupt_instance(&self, template_id: &str, worker_name: &str, recover_immediately: Option<bool>, authorization: &str) -> Result<(), InstanceError>;
async fn get_instance_metadata(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<crate::model::InstanceMetadata, InstanceError>;
}
#[derive(Clone, Debug)]
pub struct InstanceLive {
pub base_url: reqwest::Url,
}
#[async_trait::async_trait]
impl Instance for InstanceLive {
async fn get_instance_of_id(&self, worker_id: &str, authorization: &str) -> Result<crate::model::ComponentInstance, InstanceError> {
let mut url = self.base_url.clone();
url.set_path(&format!("v1/templates/workers/{worker_id}"));
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
let result = reqwest::Client::builder()
.build()?
.get(url)
.headers(headers)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = result.json::<crate::model::ComponentInstance>().await?;
Ok(body)
}
504 => Err(InstanceError::Status504),
404 => {
let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
Err(InstanceError::Status404 { error: body.error })
}
403 => {
let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
Err(InstanceError::Status403 { error: body.error })
}
400 => {
let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
Err(InstanceError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
Err(InstanceError::Status500 { golem_error: body.golem_error })
}
401 => {
let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
Err(InstanceError::Status401 { error: body.error })
}
409 => {
let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
Err(InstanceError::Status409 { error: body.error })
}
_ => Err(InstanceError::UnexpectedStatus(result.status()))
}
}
async fn launch_new_instance(&self, template_id: &str, field0: crate::model::WorkerCreationRequest, authorization: &str) -> Result<crate::model::ComponentInstance, InstanceError> {
let mut url = self.base_url.clone();
url.set_path(&format!("v1/templates/{template_id}/workers"));
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
let result = reqwest::Client::builder()
.build()?
.post(url)
.headers(headers)
.json(&field0)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = result.json::<crate::model::ComponentInstance>().await?;
Ok(body)
}
504 => Err(InstanceError::Status504),
404 => {
let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
Err(InstanceError::Status404 { error: body.error })
}
403 => {
let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
Err(InstanceError::Status403 { error: body.error })
}
400 => {
let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
Err(InstanceError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
Err(InstanceError::Status500 { golem_error: body.golem_error })
}
401 => {
let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
Err(InstanceError::Status401 { error: body.error })
}
409 => {
let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
Err(InstanceError::Status409 { error: body.error })
}
_ => Err(InstanceError::UnexpectedStatus(result.status()))
}
}
async fn delete_instance(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<(), InstanceError> {
let mut url = self.base_url.clone();
url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}"));
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
let result = reqwest::Client::builder()
.build()?
.delete(url)
.headers(headers)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = ();
Ok(body)
}
504 => Err(InstanceError::Status504),
404 => {
let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
Err(InstanceError::Status404 { error: body.error })
}
403 => {
let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
Err(InstanceError::Status403 { error: body.error })
}
400 => {
let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
Err(InstanceError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
Err(InstanceError::Status500 { golem_error: body.golem_error })
}
401 => {
let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
Err(InstanceError::Status401 { error: body.error })
}
409 => {
let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
Err(InstanceError::Status409 { error: body.error })
}
_ => Err(InstanceError::UnexpectedStatus(result.status()))
}
}
async fn get_invocation_key(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<crate::model::InvocationKey, InstanceError> {
let mut url = self.base_url.clone();
url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/key"));
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
let result = reqwest::Client::builder()
.build()?
.post(url)
.headers(headers)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = result.json::<crate::model::InvocationKey>().await?;
Ok(body)
}
504 => Err(InstanceError::Status504),
404 => {
let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
Err(InstanceError::Status404 { error: body.error })
}
403 => {
let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
Err(InstanceError::Status403 { error: body.error })
}
400 => {
let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
Err(InstanceError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
Err(InstanceError::Status500 { golem_error: body.golem_error })
}
401 => {
let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
Err(InstanceError::Status401 { error: body.error })
}
409 => {
let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
Err(InstanceError::Status409 { error: body.error })
}
_ => Err(InstanceError::UnexpectedStatus(result.status()))
}
}
async fn invoke_and_await_function(&self, template_id: &str, worker_name: &str, invocation_key: &str, function: &str, calling_convention: Option<&str>, field0: crate::model::InvokeParameters, authorization: &str) -> Result<crate::model::InvokeResult, InstanceError> {
let mut url = self.base_url.clone();
url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/invoke-and-await"));
url.query_pairs_mut().append_pair("invocation-key", &format!("{invocation_key}"));
url.query_pairs_mut().append_pair("function", &format!("{function}"));
if let Some(value) = calling_convention {
url.query_pairs_mut().append_pair("calling-convention", &format!("{value}"));
}
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
let result = reqwest::Client::builder()
.build()?
.post(url)
.headers(headers)
.json(&field0)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = result.json::<crate::model::InvokeResult>().await?;
Ok(body)
}
504 => Err(InstanceError::Status504),
404 => {
let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
Err(InstanceError::Status404 { error: body.error })
}
403 => {
let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
Err(InstanceError::Status403 { error: body.error })
}
400 => {
let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
Err(InstanceError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
Err(InstanceError::Status500 { golem_error: body.golem_error })
}
401 => {
let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
Err(InstanceError::Status401 { error: body.error })
}
409 => {
let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
Err(InstanceError::Status409 { error: body.error })
}
_ => Err(InstanceError::UnexpectedStatus(result.status()))
}
}
async fn invoke_function(&self, template_id: &str, worker_name: &str, function: &str, field0: crate::model::InvokeParameters, authorization: &str) -> Result<(), InstanceError> {
let mut url = self.base_url.clone();
url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/invoke"));
url.query_pairs_mut().append_pair("function", &format!("{function}"));
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
let result = reqwest::Client::builder()
.build()?
.post(url)
.headers(headers)
.json(&field0)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = ();
Ok(body)
}
504 => Err(InstanceError::Status504),
404 => {
let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
Err(InstanceError::Status404 { error: body.error })
}
403 => {
let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
Err(InstanceError::Status403 { error: body.error })
}
400 => {
let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
Err(InstanceError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
Err(InstanceError::Status500 { golem_error: body.golem_error })
}
401 => {
let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
Err(InstanceError::Status401 { error: body.error })
}
409 => {
let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
Err(InstanceError::Status409 { error: body.error })
}
_ => Err(InstanceError::UnexpectedStatus(result.status()))
}
}
async fn complete_instance_promise(&self, template_id: &str, worker_name: &str, field0: crate::model::CompleteParameters, authorization: &str) -> Result<bool, InstanceError> {
let mut url = self.base_url.clone();
url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/complete"));
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
let result = reqwest::Client::builder()
.build()?
.post(url)
.headers(headers)
.json(&field0)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = result.json::<bool>().await?;
Ok(body)
}
504 => Err(InstanceError::Status504),
404 => {
let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
Err(InstanceError::Status404 { error: body.error })
}
403 => {
let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
Err(InstanceError::Status403 { error: body.error })
}
400 => {
let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
Err(InstanceError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
Err(InstanceError::Status500 { golem_error: body.golem_error })
}
401 => {
let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
Err(InstanceError::Status401 { error: body.error })
}
409 => {
let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
Err(InstanceError::Status409 { error: body.error })
}
_ => Err(InstanceError::UnexpectedStatus(result.status()))
}
}
async fn interrupt_instance(&self, template_id: &str, worker_name: &str, recover_immediately: Option<bool>, authorization: &str) -> Result<(), InstanceError> {
let mut url = self.base_url.clone();
url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/interrupt"));
if let Some(value) = recover_immediately {
url.query_pairs_mut().append_pair("recover-immediately", &format!("{value}"));
}
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
let result = reqwest::Client::builder()
.build()?
.post(url)
.headers(headers)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = ();
Ok(body)
}
504 => Err(InstanceError::Status504),
404 => {
let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
Err(InstanceError::Status404 { error: body.error })
}
403 => {
let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
Err(InstanceError::Status403 { error: body.error })
}
400 => {
let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
Err(InstanceError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
Err(InstanceError::Status500 { golem_error: body.golem_error })
}
401 => {
let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
Err(InstanceError::Status401 { error: body.error })
}
409 => {
let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
Err(InstanceError::Status409 { error: body.error })
}
_ => Err(InstanceError::UnexpectedStatus(result.status()))
}
}
async fn get_instance_metadata(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<crate::model::InstanceMetadata, InstanceError> {
let mut url = self.base_url.clone();
url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}"));
let mut headers = reqwest::header::HeaderMap::new();
headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
let result = reqwest::Client::builder()
.build()?
.get(url)
.headers(headers)
.send()
.await?;
match result.status().as_u16() {
200 => {
let body = result.json::<crate::model::InstanceMetadata>().await?;
Ok(body)
}
504 => Err(InstanceError::Status504),
404 => {
let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
Err(InstanceError::Status404 { error: body.error })
}
403 => {
let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
Err(InstanceError::Status403 { error: body.error })
}
400 => {
let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
Err(InstanceError::Status400 { errors: body.errors })
}
500 => {
let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
Err(InstanceError::Status500 { golem_error: body.golem_error })
}
401 => {
let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
Err(InstanceError::Status401 { error: body.error })
}
409 => {
let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
Err(InstanceError::Status409 { error: body.error })
}
_ => Err(InstanceError::UnexpectedStatus(result.status()))
}
}
}