335 lines
9.9 KiB
Rust
335 lines
9.9 KiB
Rust
use bytes::Bytes;
|
|
use futures_util::Stream;
|
|
use log::debug;
|
|
use reqwest::Method;
|
|
use std::collections::BTreeMap as Map;
|
|
use std::fmt::Display;
|
|
use std::net::IpAddr;
|
|
|
|
pub struct Client {
|
|
base_url: String,
|
|
token: String,
|
|
http_client: reqwest::Client,
|
|
}
|
|
|
|
impl Client {
|
|
pub fn new(base_url: String, token: String) -> Self {
|
|
Self {
|
|
base_url,
|
|
token,
|
|
http_client: reqwest::Client::default(),
|
|
}
|
|
}
|
|
|
|
pub fn with_proxy(self, proxy: String) -> reqwest::Result<Self> {
|
|
let proxy = reqwest::Proxy::all(proxy)?;
|
|
Ok(Self {
|
|
http_client: reqwest::Client::builder().proxy(proxy).build()?,
|
|
..self
|
|
})
|
|
}
|
|
|
|
pub async fn clusters(&self) -> Result<Vec<String>> {
|
|
self.get_json("clusters").await
|
|
}
|
|
|
|
pub fn cluster(&self, name: String) -> Cluster<'_> {
|
|
Cluster { dls: self, name }
|
|
}
|
|
|
|
pub async fn hosts(&self) -> Result<Vec<String>> {
|
|
self.get_json("hosts").await
|
|
}
|
|
|
|
pub fn host(&self, name: String) -> Host<'_> {
|
|
Host { dls: self, name }
|
|
}
|
|
|
|
pub async fn sign_dl_set(&self, req: &DownloadSetReq) -> Result<String> {
|
|
let req = (self.req(Method::POST, "sign-download-set")?).json(req);
|
|
self.req_json(req).await
|
|
}
|
|
pub async fn fetch_dl_set(
|
|
&self,
|
|
signed_dlset: &str,
|
|
kind: &str,
|
|
name: &str,
|
|
asset: &str,
|
|
) -> Result<impl Stream<Item = reqwest::Result<Bytes>>> {
|
|
let req = self.get(format!(
|
|
"public/download-set/{kind}/{name}/{asset}?set={signed_dlset}"
|
|
))?;
|
|
let resp = do_req(req, &self.token).await?;
|
|
Ok(resp.bytes_stream())
|
|
}
|
|
|
|
pub async fn get_json<T: serde::de::DeserializeOwned>(&self, path: impl Display) -> Result<T> {
|
|
self.req_json(self.get(&path)?).await
|
|
}
|
|
pub async fn get_bytes(&self, path: impl Display) -> Result<Vec<u8>> {
|
|
let resp = do_req(self.get(&path)?, &self.token).await?;
|
|
Ok(resp.bytes().await.map_err(Error::Read)?.to_vec())
|
|
}
|
|
pub fn get(&self, path: impl Display) -> Result<reqwest::RequestBuilder> {
|
|
self.req(Method::GET, path)
|
|
}
|
|
|
|
pub async fn req_json<T: serde::de::DeserializeOwned>(
|
|
&self,
|
|
req: reqwest::RequestBuilder,
|
|
) -> Result<T> {
|
|
let req = req.header("Accept", "application/json");
|
|
let resp = do_req(req, &self.token).await?;
|
|
|
|
let body = resp.bytes().await.map_err(Error::Read)?;
|
|
serde_json::from_slice(&body).map_err(Error::Parse)
|
|
}
|
|
pub fn req(&self, method: Method, path: impl Display) -> Result<reqwest::RequestBuilder> {
|
|
let uri = format!("{}/{path}", self.base_url);
|
|
|
|
Ok((self.http_client.request(method, uri))
|
|
.header("Authorization", format!("Bearer {}", self.token)))
|
|
}
|
|
}
|
|
|
|
pub struct Cluster<'t> {
|
|
dls: &'t Client,
|
|
name: String,
|
|
}
|
|
|
|
impl<'t> Cluster<'t> {
|
|
pub async fn config(&self) -> Result<ClusterConfig> {
|
|
self.dls.get_json(format!("clusters/{}", self.name)).await
|
|
}
|
|
|
|
pub async fn ca_cert(&self, ca_name: &str) -> Result<Vec<u8>> {
|
|
self.dls
|
|
.get_bytes(format!("clusters/{}/CAs/{ca_name}/certificate", self.name))
|
|
.await
|
|
}
|
|
|
|
pub async fn token(&self, name: &str) -> Result<String> {
|
|
self.dls
|
|
.get_json(format!("clusters/{}/tokens/{name}", self.name))
|
|
.await
|
|
}
|
|
|
|
pub async fn addons(&self) -> Result<Vec<u8>> {
|
|
self.dls
|
|
.get_bytes(format!("clusters/{}/addons", self.name))
|
|
.await
|
|
}
|
|
|
|
pub async fn ssh_userca_sign(&self, sign_req: &SshSignReq) -> Result<Vec<u8>> {
|
|
let req = self.dls.req(
|
|
Method::POST,
|
|
format!("clusters/{}/ssh/user-ca/sign", self.name),
|
|
)?;
|
|
let req = req.json(sign_req);
|
|
|
|
let resp = do_req(req, &self.dls.token).await?;
|
|
Ok(resp.bytes().await.map_err(Error::Read)?.to_vec())
|
|
}
|
|
|
|
pub async fn kube_sign(&self, sign_req: &KubeSignReq) -> Result<Vec<u8>> {
|
|
let req = (self.dls).req(Method::POST, format!("clusters/{}/kube/sign", self.name))?;
|
|
let req = req.json(sign_req);
|
|
|
|
let resp = do_req(req, &self.dls.token).await?;
|
|
Ok(resp.bytes().await.map_err(Error::Read)?.to_vec())
|
|
}
|
|
}
|
|
|
|
pub struct Host<'t> {
|
|
dls: &'t Client,
|
|
name: String,
|
|
}
|
|
impl<'t> Host<'t> {
|
|
pub async fn config(&self) -> Result<HostConfig> {
|
|
self.dls.get_json(format!("hosts/{}", self.name)).await
|
|
}
|
|
|
|
pub async fn asset(
|
|
&self,
|
|
asset_name: &str,
|
|
) -> Result<impl Stream<Item = reqwest::Result<Bytes>>> {
|
|
let req = self.dls.get(format!("hosts/{}/{asset_name}", self.name))?;
|
|
let resp = do_req(req, &self.dls.token).await?;
|
|
Ok(resp.bytes_stream())
|
|
}
|
|
}
|
|
|
|
#[derive(Default, serde::Deserialize, serde::Serialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub struct Config {
|
|
#[serde(default, deserialize_with = "deserialize_null_as_default")]
|
|
pub clusters: Vec<ClusterConfig>,
|
|
#[serde(default, deserialize_with = "deserialize_null_as_default")]
|
|
pub hosts: Vec<HostConfig>,
|
|
#[serde(default, deserialize_with = "deserialize_null_as_default")]
|
|
pub host_templates: Vec<HostConfig>,
|
|
#[serde(default, rename = "SSLConfig")]
|
|
pub ssl_config: String,
|
|
}
|
|
|
|
// compensate for go's encoder pitfalls
|
|
use serde::{Deserialize, Deserializer};
|
|
fn deserialize_null_as_default<'de, D, T>(deserializer: D) -> std::result::Result<T, D::Error>
|
|
where
|
|
T: Default + Deserialize<'de>,
|
|
D: Deserializer<'de>,
|
|
{
|
|
let opt = Option::deserialize(deserializer)?;
|
|
Ok(opt.unwrap_or_default())
|
|
}
|
|
|
|
#[derive(serde::Deserialize, serde::Serialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub struct ClusterConfig {
|
|
pub name: String,
|
|
pub bootstrap_pods: String,
|
|
pub addons: String,
|
|
}
|
|
|
|
#[derive(Default, serde::Deserialize, serde::Serialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub struct HostConfig {
|
|
pub name: String,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub cluster_name: Option<String>,
|
|
|
|
#[serde(rename = "IPs")]
|
|
pub ips: Vec<IpAddr>,
|
|
|
|
#[serde(default, skip_serializing_if = "Map::is_empty")]
|
|
pub labels: Map<String, String>,
|
|
#[serde(default, skip_serializing_if = "Map::is_empty")]
|
|
pub annotations: Map<String, String>,
|
|
|
|
#[serde(rename = "IPXE", skip_serializing_if = "Option::is_none")]
|
|
pub ipxe: Option<String>,
|
|
|
|
pub initrd: String,
|
|
pub kernel: String,
|
|
pub versions: Map<String, String>,
|
|
|
|
/// initrd config template
|
|
pub bootstrap_config: String,
|
|
/// files to add to the final initrd config, with rendering
|
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
|
pub initrd_files: Vec<crate::File>,
|
|
|
|
/// system config template
|
|
pub config: String,
|
|
}
|
|
|
|
#[derive(serde::Deserialize, serde::Serialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub struct SshSignReq {
|
|
pub pub_key: String,
|
|
pub principal: String,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub validity: Option<String>,
|
|
#[serde(skip_serializing_if = "Vec::is_empty")]
|
|
pub options: Vec<String>,
|
|
}
|
|
|
|
#[derive(serde::Deserialize, serde::Serialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub struct KubeSignReq {
|
|
#[serde(rename = "CSR")]
|
|
pub csr: String,
|
|
pub user: String,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub group: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub validity: Option<String>,
|
|
}
|
|
|
|
#[derive(serde::Deserialize, serde::Serialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub struct DownloadSetReq {
|
|
pub expiry: String,
|
|
#[serde(skip_serializing_if = "Vec::is_empty")]
|
|
pub items: Vec<DownloadSetItem>,
|
|
}
|
|
|
|
#[derive(Clone, serde::Deserialize, serde::Serialize)]
|
|
#[serde(rename_all = "PascalCase")]
|
|
pub struct DownloadSetItem {
|
|
pub kind: String,
|
|
pub name: String,
|
|
#[serde(skip_serializing_if = "Vec::is_empty")]
|
|
pub assets: Vec<String>,
|
|
}
|
|
|
|
#[derive(Debug, serde::Deserialize, serde::Serialize)]
|
|
struct ServerError {
|
|
#[serde(default)]
|
|
code: u16,
|
|
message: String,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
details: Option<serde_json::Value>,
|
|
}
|
|
|
|
pub async fn do_req(req: reqwest::RequestBuilder, token: &str) -> Result<reqwest::Response> {
|
|
let (client, req) = req.build_split();
|
|
let req = req.map_err(Error::Build)?;
|
|
|
|
let method = req.method().clone();
|
|
let path = req.url().path().replace(token, "<token>"); // clone required anyway, so replace the token as we copy
|
|
|
|
debug!("request: {} {}", req.method(), req.url());
|
|
|
|
let resp = client.execute(req).await.map_err(Error::Send)?;
|
|
let status = resp.status();
|
|
|
|
if !status.is_success() {
|
|
let body = resp.bytes().await.map_err(Error::ErrorRead)?;
|
|
let srv_err: ServerError =
|
|
serde_json::from_slice(&body).map_err(|e| Error::ErrorParse {
|
|
error: e,
|
|
raw: body.to_vec(),
|
|
})?;
|
|
|
|
return Err(Error::ServerReject {
|
|
method,
|
|
path,
|
|
status,
|
|
message: srv_err.message,
|
|
details: srv_err.details,
|
|
});
|
|
}
|
|
|
|
Ok(resp)
|
|
}
|
|
|
|
pub type Result<T> = std::result::Result<T, Error>;
|
|
|
|
#[derive(thiserror::Error, Debug)]
|
|
pub enum Error {
|
|
#[error("request build failed: {0}")]
|
|
Build(reqwest::Error),
|
|
#[error("request send failed: {0}")]
|
|
Send(reqwest::Error),
|
|
#[error("response error read failed: {0}")]
|
|
ErrorRead(reqwest::Error),
|
|
#[error("response error parsing failed: {error}")]
|
|
ErrorParse {
|
|
error: serde_json::Error,
|
|
raw: Vec<u8>,
|
|
},
|
|
#[error("response read failed: {0}")]
|
|
Read(reqwest::Error),
|
|
#[error("rejected by server: {method} {path}: {} {message}", status.as_u16())]
|
|
ServerReject {
|
|
method: reqwest::Method,
|
|
path: String,
|
|
status: reqwest::StatusCode,
|
|
message: String,
|
|
details: Option<serde_json::Value>,
|
|
},
|
|
#[error("response parsing failed: {0}")]
|
|
Parse(serde_json::Error),
|
|
}
|