use std::borrow::Cow;
use std::collections::HashMap;
use std::io::Write;
use std::path::Path;
use std::path::PathBuf;
use anyhow::Context as _;
use anyhow::Result;
use anyhow::bail;
use kube::Discovery;
use kube::api::ApiResource;
use kube::api::DynamicObject;
use kube::api::GroupVersionKind;
use kube::discovery::ApiCapabilities;
use kube::discovery::Scope;
use kube::runtime::reflector::Lookup;
use planetary_db::TaskTemplateData;
use reqwest::Url;
use serde::Deserialize as _;
use serde_yaml_ng::Deserializer;
use tera::Context;
use tera::Map;
use tera::Tera;
use tera::Value;
use tes::v1::types::task::Executor;
pub const ORCHESTRATOR_LABEL: &str = "planetary/orchestrator";
pub const TASK_LABEL: &str = "planetary/task";
pub const CANCELED_LABEL: &str = "planetary/canceled";
const TEMPLATE_NAME: &str = "task.yaml";
const DEFAULT_STORAGE_SIZE: f64 = 1.07374182;
const DEFAULT_CPU: i32 = 1;
const DEFAULT_MEMORY: f64 = 0.268435455;
pub fn is_username_valid(username: &str) -> bool {
!username
.chars()
.any(|c| c.is_control() || matches!(c, '\u{2028}' | '\u{2029}'))
}
fn url_to_file_path(url: &str) -> Option<PathBuf> {
let url = Url::parse(url).ok()?;
if url.scheme() != "file" {
return None;
}
url.to_file_path().ok()
}
pub struct Template(Tera);
impl Template {
pub fn new(templates_dir: impl AsRef<Path>) -> Result<Self> {
let templates_dir = templates_dir.as_ref();
let mut templates = Tera::new();
templates.set_escape_fn(|value: &str, writer: &mut dyn Write| {
serde_json::to_writer(writer, value).map_err(std::io::Error::other)
});
templates.load_from_glob(templates_dir.join("**/*.yaml").to_str().with_context(
|| {
format!(
"templates directory `{path}` is not valid UTF-8",
path = templates_dir.display()
)
},
)?)?;
templates.autoescape_on([".yaml"]);
if !templates.get_template_names().any(|n| n == TEMPLATE_NAME) {
bail!(
"templates directory `{path}` does not contain a template named `{TEMPLATE_NAME}`",
path = templates_dir.display()
);
}
Ok(Self(templates))
}
pub fn render(
&self,
data: &TaskTemplateData,
discovery: &Discovery,
namespace: &str,
script: impl Fn(&Executor) -> Result<String>,
) -> Result<Vec<TaskResource>> {
let rendered = self.render_to_string(data, script)?;
let resources = serde_yaml_ng::Deserializer::from_str(&rendered)
.map(|de| self.deserialize_object(&data.id, discovery, namespace, de))
.collect::<Result<Vec<_>>>()?;
let mut has_pod = false;
for r in &resources {
if r.api().api_version == "v1" && r.api().kind == "Pod" {
if has_pod {
bail!("task template defines more than one pod for the task")
}
if r.object()
.data
.get("spec")
.and_then(|o| o.get("restartPolicy"))
.map(|v| v.as_str() != Some("Never"))
.unwrap_or(true)
{
bail!("task pod must have a `Never` restart policy");
}
has_pod = true;
}
}
if !has_pod {
bail!("task template does not define a pod for the task");
}
Ok(resources)
}
pub fn render_id_only(
&self,
id: impl Into<String>,
discovery: &Discovery,
namespace: &str,
) -> Result<Vec<TaskResource>> {
self.render(
&TaskTemplateData {
id: id.into(),
username: String::new(),
preemptible: false,
cpu: None,
memory: None,
disk: None,
inputs: Default::default(),
outputs: Default::default(),
volumes: Default::default(),
executors: Default::default(),
},
discovery,
namespace,
|_| Ok(String::new()),
)
}
fn render_to_string(
&self,
data: &TaskTemplateData,
script: impl Fn(&Executor) -> Result<String>,
) -> Result<String> {
self.0
.render(TEMPLATE_NAME, &Self::create_context(data, script)?)
.context("failed to render task resource template")
}
fn create_context(
data: &TaskTemplateData,
script: impl Fn(&Executor) -> Result<String>,
) -> Result<Context> {
if !is_username_valid(&data.username) {
bail!(
"username `{username}` is invalid for template rendering",
username = data.username
);
}
let mut context = Context::new();
context.insert("id", data.id.as_str());
context.insert("username", data.username.as_str());
context.insert("preemptible", &data.preemptible);
context.insert("cpu", &data.cpu.unwrap_or(DEFAULT_CPU));
context.insert(
"memory",
&format!(
"{memory}G",
memory = data.memory.unwrap_or(DEFAULT_MEMORY).ceil()
),
);
context.insert(
"disk",
&format!(
"{disk}G",
disk = data.disk.unwrap_or(0.0).max(DEFAULT_STORAGE_SIZE)
),
);
let inputs: Vec<_> = data
.inputs
.iter()
.map(|input| {
let mut value: HashMap<_, Cow<'_, str>> = HashMap::new();
value.insert("path", input.path.as_str().into());
if let Some(local_path) = input.url.as_ref().and_then(|url| {
Some(
url_to_file_path(url)?
.strip_prefix("/")
.expect("path should be absolute")
.to_str()
.expect("path should be UTF-8")
.to_string(),
)
}) {
value.insert("local_path", local_path.into());
}
value
})
.collect();
context.insert("inputs", &inputs);
let outputs: Vec<_> = data
.outputs
.iter()
.map(|output| {
let mut value: HashMap<_, Cow<'_, str>> = HashMap::new();
value.insert(
"path",
output.path_prefix.as_deref().unwrap_or(&output.path).into(),
);
if let Some(path) = url_to_file_path(&output.url) {
let local_path = path
.strip_prefix("/")
.expect("path should be absolute")
.to_str()
.expect("path should be UTF-8");
value.insert("local_path", local_path.to_string().into());
}
value
})
.collect();
context.insert("outputs", &outputs);
context.insert("volumes", &data.volumes);
let executors: Vec<_> = data
.executors
.iter()
.map(|e| {
let mut value: HashMap<_, Value> = HashMap::new();
value.insert("image", e.image.as_str().into());
value.insert("script", script(e)?.into());
value.insert("workdir", e.workdir.as_deref().unwrap_or_default().into());
if let Some(env) = e.env.as_ref() {
value.insert("env", Value::from_serializable(env));
} else {
value.insert("env", Map::new().into());
}
Ok(value)
})
.collect::<Result<_>>()?;
context.insert("executors", &executors);
Ok(context)
}
fn deserialize_object(
&self,
tes_id: &str,
discovery: &Discovery,
namespace: &str,
de: Deserializer<'_>,
) -> Result<TaskResource> {
let mut object = DynamicObject::deserialize(de)
.context("failed to deserialize task resource template")?;
let name = object
.name()
.context("task template contains a resource that has no name")?;
let meta = object.types.as_ref().with_context(|| {
format!("task resource `{name}` does not specify an object API version and kind")
})?;
let gvk = GroupVersionKind::try_from(meta).with_context(|| {
format!(
"task resource `{name}` has invalid kind: `{kind}` ({api})",
kind = meta.kind,
api = meta.api_version
)
})?;
let labels = object.metadata.labels.get_or_insert_default();
labels.insert(TASK_LABEL.to_string(), tes_id.to_string());
let (resource, capabilities) = discovery.resolve_gvk(&gvk).with_context(|| {
format!(
"task resource `{name}` has unknown resource kind `{kind}` ({api})",
name = object.name().expect("object should have a name"),
kind = meta.kind,
api = meta.api_version
)
})?;
if capabilities.scope == Scope::Cluster {
object.metadata.namespace = None;
} else {
object.metadata.namespace = Some(namespace.to_string());
}
Ok(TaskResource {
resource,
capabilities,
object,
})
}
}
pub struct TaskResource {
resource: ApiResource,
capabilities: ApiCapabilities,
object: DynamicObject,
}
impl TaskResource {
pub fn api(&self) -> &ApiResource {
&self.resource
}
pub fn capabilities(&self) -> &ApiCapabilities {
&self.capabilities
}
pub fn object(&self) -> &DynamicObject {
&self.object
}
pub fn object_mut(&mut self) -> &mut DynamicObject {
&mut self.object
}
}
#[cfg(test)]
mod tests {
use std::fs;
use pretty_assertions::assert_eq;
use tempfile::tempdir;
use super::*;
#[test]
fn it_json_encodes_strings() {
let dir = tempdir().unwrap();
let template_path = dir.path().join(TEMPLATE_NAME);
fs::write(
&template_path,
r#"
{{ id }}
{{ id | safe }}
{{ username }}
{{ memory }}
{{ disk }}
"#,
)
.unwrap();
let template = Template::new(dir.path()).unwrap();
let rendered = template
.render_to_string(
&TaskTemplateData {
id: "task\nid".into(),
username: "username".into(),
preemptible: false,
cpu: Some(1),
memory: Some(1.0),
disk: Some(10.0),
inputs: Default::default(),
outputs: Default::default(),
volumes: Default::default(),
executors: Default::default(),
},
|_| Ok(String::new()),
)
.unwrap();
assert_eq!(
rendered,
r#"
"task\nid"
task
id
"username"
"1G"
"10G"
"#
);
}
}