#![allow(unused_imports)]
#![cfg_attr(rustfmt, rustfmt_skip)]
use crate::{Client, ClientBuilder, Credentials, Retry};
use anyhow::Error;
use serde_json::Value;
use std::time::Duration;
use crate::util::urlencode;
pub struct WorkerManager (Client);
#[allow(non_snake_case)]
impl WorkerManager {
pub fn new<CB: Into<ClientBuilder>>(client_builder: CB) -> Result<Self, Error> {
Ok(Self(client_builder
.into()
.path_prefix("api/worker-manager/v1/")
.build()?))
}
pub async fn ping(&self) -> Result<(), Error> {
let method = "GET";
let (path, query) = Self::ping_details();
let body = None;
let resp = self.0.request(method, path, query, body).await?;
resp.bytes().await?;
Ok(())
}
pub fn ping_url(&self) -> Result<String, Error> {
let (path, query) = Self::ping_details();
self.0.make_url(path, query)
}
pub fn ping_signed_url(&self, ttl: Duration) -> Result<String, Error> {
let (path, query) = Self::ping_details();
self.0.make_signed_url(path, query, ttl)
}
fn ping_details<'a>() -> (&'static str, Option<Vec<(&'static str, &'a str)>>) {
let path = "ping";
let query = None;
(path, query)
}
pub async fn listProviders(&self, continuationToken: Option<&str>, limit: Option<&str>) -> Result<Value, Error> {
let method = "GET";
let (path, query) = Self::listProviders_details(continuationToken, limit);
let body = None;
let resp = self.0.request(method, path, query, body).await?;
Ok(resp.json().await?)
}
pub fn listProviders_url(&self, continuationToken: Option<&str>, limit: Option<&str>) -> Result<String, Error> {
let (path, query) = Self::listProviders_details(continuationToken, limit);
self.0.make_url(path, query)
}
pub fn listProviders_signed_url(&self, continuationToken: Option<&str>, limit: Option<&str>, ttl: Duration) -> Result<String, Error> {
let (path, query) = Self::listProviders_details(continuationToken, limit);
self.0.make_signed_url(path, query, ttl)
}
fn listProviders_details<'a>(continuationToken: Option<&'a str>, limit: Option<&'a str>) -> (&'static str, Option<Vec<(&'static str, &'a str)>>) {
let path = "providers";
let mut query = None;
if let Some(q) = continuationToken {
query.get_or_insert_with(Vec::new).push(("continuationToken", q));
}
if let Some(q) = limit {
query.get_or_insert_with(Vec::new).push(("limit", q));
}
(path, query)
}
pub async fn createWorkerPool(&self, workerPoolId: &str, payload: &Value) -> Result<Value, Error> {
let method = "PUT";
let (path, query) = Self::createWorkerPool_details(workerPoolId);
let body = Some(payload);
let resp = self.0.request(method, &path, query, body).await?;
Ok(resp.json().await?)
}
fn createWorkerPool_details<'a>(workerPoolId: &'a str) -> (String, Option<Vec<(&'static str, &'a str)>>) {
let path = format!("worker-pool/{}", urlencode(workerPoolId));
let query = None;
(path, query)
}
pub async fn updateWorkerPool(&self, workerPoolId: &str, payload: &Value) -> Result<Value, Error> {
let method = "POST";
let (path, query) = Self::updateWorkerPool_details(workerPoolId);
let body = Some(payload);
let resp = self.0.request(method, &path, query, body).await?;
Ok(resp.json().await?)
}
fn updateWorkerPool_details<'a>(workerPoolId: &'a str) -> (String, Option<Vec<(&'static str, &'a str)>>) {
let path = format!("worker-pool/{}", urlencode(workerPoolId));
let query = None;
(path, query)
}
pub async fn deleteWorkerPool(&self, workerPoolId: &str) -> Result<Value, Error> {
let method = "DELETE";
let (path, query) = Self::deleteWorkerPool_details(workerPoolId);
let body = None;
let resp = self.0.request(method, &path, query, body).await?;
Ok(resp.json().await?)
}
fn deleteWorkerPool_details<'a>(workerPoolId: &'a str) -> (String, Option<Vec<(&'static str, &'a str)>>) {
let path = format!("worker-pool/{}", urlencode(workerPoolId));
let query = None;
(path, query)
}
pub async fn workerPool(&self, workerPoolId: &str) -> Result<Value, Error> {
let method = "GET";
let (path, query) = Self::workerPool_details(workerPoolId);
let body = None;
let resp = self.0.request(method, &path, query, body).await?;
Ok(resp.json().await?)
}
pub fn workerPool_url(&self, workerPoolId: &str) -> Result<String, Error> {
let (path, query) = Self::workerPool_details(workerPoolId);
self.0.make_url(&path, query)
}
pub fn workerPool_signed_url(&self, workerPoolId: &str, ttl: Duration) -> Result<String, Error> {
let (path, query) = Self::workerPool_details(workerPoolId);
self.0.make_signed_url(&path, query, ttl)
}
fn workerPool_details<'a>(workerPoolId: &'a str) -> (String, Option<Vec<(&'static str, &'a str)>>) {
let path = format!("worker-pool/{}", urlencode(workerPoolId));
let query = None;
(path, query)
}
pub async fn listWorkerPools(&self, continuationToken: Option<&str>, limit: Option<&str>) -> Result<Value, Error> {
let method = "GET";
let (path, query) = Self::listWorkerPools_details(continuationToken, limit);
let body = None;
let resp = self.0.request(method, path, query, body).await?;
Ok(resp.json().await?)
}
pub fn listWorkerPools_url(&self, continuationToken: Option<&str>, limit: Option<&str>) -> Result<String, Error> {
let (path, query) = Self::listWorkerPools_details(continuationToken, limit);
self.0.make_url(path, query)
}
pub fn listWorkerPools_signed_url(&self, continuationToken: Option<&str>, limit: Option<&str>, ttl: Duration) -> Result<String, Error> {
let (path, query) = Self::listWorkerPools_details(continuationToken, limit);
self.0.make_signed_url(path, query, ttl)
}
fn listWorkerPools_details<'a>(continuationToken: Option<&'a str>, limit: Option<&'a str>) -> (&'static str, Option<Vec<(&'static str, &'a str)>>) {
let path = "worker-pools";
let mut query = None;
if let Some(q) = continuationToken {
query.get_or_insert_with(Vec::new).push(("continuationToken", q));
}
if let Some(q) = limit {
query.get_or_insert_with(Vec::new).push(("limit", q));
}
(path, query)
}
pub async fn reportWorkerError(&self, workerPoolId: &str, payload: &Value) -> Result<Value, Error> {
let method = "POST";
let (path, query) = Self::reportWorkerError_details(workerPoolId);
let body = Some(payload);
let resp = self.0.request(method, &path, query, body).await?;
Ok(resp.json().await?)
}
fn reportWorkerError_details<'a>(workerPoolId: &'a str) -> (String, Option<Vec<(&'static str, &'a str)>>) {
let path = format!("worker-pool-errors/{}", urlencode(workerPoolId));
let query = None;
(path, query)
}
pub async fn listWorkerPoolErrors(&self, workerPoolId: &str, continuationToken: Option<&str>, limit: Option<&str>) -> Result<Value, Error> {
let method = "GET";
let (path, query) = Self::listWorkerPoolErrors_details(workerPoolId, continuationToken, limit);
let body = None;
let resp = self.0.request(method, &path, query, body).await?;
Ok(resp.json().await?)
}
pub fn listWorkerPoolErrors_url(&self, workerPoolId: &str, continuationToken: Option<&str>, limit: Option<&str>) -> Result<String, Error> {
let (path, query) = Self::listWorkerPoolErrors_details(workerPoolId, continuationToken, limit);
self.0.make_url(&path, query)
}
pub fn listWorkerPoolErrors_signed_url(&self, workerPoolId: &str, continuationToken: Option<&str>, limit: Option<&str>, ttl: Duration) -> Result<String, Error> {
let (path, query) = Self::listWorkerPoolErrors_details(workerPoolId, continuationToken, limit);
self.0.make_signed_url(&path, query, ttl)
}
fn listWorkerPoolErrors_details<'a>(workerPoolId: &'a str, continuationToken: Option<&'a str>, limit: Option<&'a str>) -> (String, Option<Vec<(&'static str, &'a str)>>) {
let path = format!("worker-pool-errors/{}", urlencode(workerPoolId));
let mut query = None;
if let Some(q) = continuationToken {
query.get_or_insert_with(Vec::new).push(("continuationToken", q));
}
if let Some(q) = limit {
query.get_or_insert_with(Vec::new).push(("limit", q));
}
(path, query)
}
pub async fn listWorkersForWorkerGroup(&self, workerPoolId: &str, workerGroup: &str, continuationToken: Option<&str>, limit: Option<&str>) -> Result<Value, Error> {
let method = "GET";
let (path, query) = Self::listWorkersForWorkerGroup_details(workerPoolId, workerGroup, continuationToken, limit);
let body = None;
let resp = self.0.request(method, &path, query, body).await?;
Ok(resp.json().await?)
}
pub fn listWorkersForWorkerGroup_url(&self, workerPoolId: &str, workerGroup: &str, continuationToken: Option<&str>, limit: Option<&str>) -> Result<String, Error> {
let (path, query) = Self::listWorkersForWorkerGroup_details(workerPoolId, workerGroup, continuationToken, limit);
self.0.make_url(&path, query)
}
pub fn listWorkersForWorkerGroup_signed_url(&self, workerPoolId: &str, workerGroup: &str, continuationToken: Option<&str>, limit: Option<&str>, ttl: Duration) -> Result<String, Error> {
let (path, query) = Self::listWorkersForWorkerGroup_details(workerPoolId, workerGroup, continuationToken, limit);
self.0.make_signed_url(&path, query, ttl)
}
fn listWorkersForWorkerGroup_details<'a>(workerPoolId: &'a str, workerGroup: &'a str, continuationToken: Option<&'a str>, limit: Option<&'a str>) -> (String, Option<Vec<(&'static str, &'a str)>>) {
let path = format!("workers/{}:/{}", urlencode(workerPoolId), urlencode(workerGroup));
let mut query = None;
if let Some(q) = continuationToken {
query.get_or_insert_with(Vec::new).push(("continuationToken", q));
}
if let Some(q) = limit {
query.get_or_insert_with(Vec::new).push(("limit", q));
}
(path, query)
}
pub async fn worker(&self, workerPoolId: &str, workerGroup: &str, workerId: &str) -> Result<Value, Error> {
let method = "GET";
let (path, query) = Self::worker_details(workerPoolId, workerGroup, workerId);
let body = None;
let resp = self.0.request(method, &path, query, body).await?;
Ok(resp.json().await?)
}
pub fn worker_url(&self, workerPoolId: &str, workerGroup: &str, workerId: &str) -> Result<String, Error> {
let (path, query) = Self::worker_details(workerPoolId, workerGroup, workerId);
self.0.make_url(&path, query)
}
pub fn worker_signed_url(&self, workerPoolId: &str, workerGroup: &str, workerId: &str, ttl: Duration) -> Result<String, Error> {
let (path, query) = Self::worker_details(workerPoolId, workerGroup, workerId);
self.0.make_signed_url(&path, query, ttl)
}
fn worker_details<'a>(workerPoolId: &'a str, workerGroup: &'a str, workerId: &'a str) -> (String, Option<Vec<(&'static str, &'a str)>>) {
let path = format!("workers/{}:/{}/{}", urlencode(workerPoolId), urlencode(workerGroup), urlencode(workerId));
let query = None;
(path, query)
}
pub async fn createWorker(&self, workerPoolId: &str, workerGroup: &str, workerId: &str, payload: &Value) -> Result<Value, Error> {
let method = "PUT";
let (path, query) = Self::createWorker_details(workerPoolId, workerGroup, workerId);
let body = Some(payload);
let resp = self.0.request(method, &path, query, body).await?;
Ok(resp.json().await?)
}
fn createWorker_details<'a>(workerPoolId: &'a str, workerGroup: &'a str, workerId: &'a str) -> (String, Option<Vec<(&'static str, &'a str)>>) {
let path = format!("workers/{}:/{}/{}", urlencode(workerPoolId), urlencode(workerGroup), urlencode(workerId));
let query = None;
(path, query)
}
pub async fn updateWorker(&self, workerPoolId: &str, workerGroup: &str, workerId: &str, payload: &Value) -> Result<Value, Error> {
let method = "POST";
let (path, query) = Self::updateWorker_details(workerPoolId, workerGroup, workerId);
let body = Some(payload);
let resp = self.0.request(method, &path, query, body).await?;
Ok(resp.json().await?)
}
fn updateWorker_details<'a>(workerPoolId: &'a str, workerGroup: &'a str, workerId: &'a str) -> (String, Option<Vec<(&'static str, &'a str)>>) {
let path = format!("workers/{}:/{}/{}", urlencode(workerPoolId), urlencode(workerGroup), urlencode(workerId));
let query = None;
(path, query)
}
pub async fn removeWorker(&self, workerPoolId: &str, workerGroup: &str, workerId: &str) -> Result<(), Error> {
let method = "DELETE";
let (path, query) = Self::removeWorker_details(workerPoolId, workerGroup, workerId);
let body = None;
let resp = self.0.request(method, &path, query, body).await?;
resp.bytes().await?;
Ok(())
}
fn removeWorker_details<'a>(workerPoolId: &'a str, workerGroup: &'a str, workerId: &'a str) -> (String, Option<Vec<(&'static str, &'a str)>>) {
let path = format!("workers/{}/{}/{}", urlencode(workerPoolId), urlencode(workerGroup), urlencode(workerId));
let query = None;
(path, query)
}
pub async fn listWorkersForWorkerPool(&self, workerPoolId: &str, continuationToken: Option<&str>, limit: Option<&str>) -> Result<Value, Error> {
let method = "GET";
let (path, query) = Self::listWorkersForWorkerPool_details(workerPoolId, continuationToken, limit);
let body = None;
let resp = self.0.request(method, &path, query, body).await?;
Ok(resp.json().await?)
}
pub fn listWorkersForWorkerPool_url(&self, workerPoolId: &str, continuationToken: Option<&str>, limit: Option<&str>) -> Result<String, Error> {
let (path, query) = Self::listWorkersForWorkerPool_details(workerPoolId, continuationToken, limit);
self.0.make_url(&path, query)
}
pub fn listWorkersForWorkerPool_signed_url(&self, workerPoolId: &str, continuationToken: Option<&str>, limit: Option<&str>, ttl: Duration) -> Result<String, Error> {
let (path, query) = Self::listWorkersForWorkerPool_details(workerPoolId, continuationToken, limit);
self.0.make_signed_url(&path, query, ttl)
}
fn listWorkersForWorkerPool_details<'a>(workerPoolId: &'a str, continuationToken: Option<&'a str>, limit: Option<&'a str>) -> (String, Option<Vec<(&'static str, &'a str)>>) {
let path = format!("workers/{}", urlencode(workerPoolId));
let mut query = None;
if let Some(q) = continuationToken {
query.get_or_insert_with(Vec::new).push(("continuationToken", q));
}
if let Some(q) = limit {
query.get_or_insert_with(Vec::new).push(("limit", q));
}
(path, query)
}
pub async fn registerWorker(&self, payload: &Value) -> Result<Value, Error> {
let method = "POST";
let (path, query) = Self::registerWorker_details();
let body = Some(payload);
let resp = self.0.request(method, path, query, body).await?;
Ok(resp.json().await?)
}
fn registerWorker_details<'a>() -> (&'static str, Option<Vec<(&'static str, &'a str)>>) {
let path = "worker/register";
let query = None;
(path, query)
}
pub async fn reregisterWorker(&self, payload: &Value) -> Result<Value, Error> {
let method = "POST";
let (path, query) = Self::reregisterWorker_details();
let body = Some(payload);
let resp = self.0.request(method, path, query, body).await?;
Ok(resp.json().await?)
}
fn reregisterWorker_details<'a>() -> (&'static str, Option<Vec<(&'static str, &'a str)>>) {
let path = "worker/reregister";
let query = None;
(path, query)
}
}