chore(release): Release v0.1.4

Signed-off-by: Release-plz <release-plz@noreply.huizinga.dev>

.release-plz.toml

@@ -1,14 +1,5 @@
 [workspace]
 pr_name = "chore(release): Release v{{ version }}"
-changelog_path = "./CHANGELOG.md"
-
-[[package]]
-name = "crete"
-changelog_include = ["ipxe"]
-
-[[package]]
-name = "ipxe"
-release = false
 
 [[package]]
 name = "xtask"

CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.4](https://git.huizinga.dev/infra/crete/compare/v0.1.3...v0.1.4) - 2026-10-04
+
+### <!-- 2 -->Bug Fixes
+
+- Pin committed action
+
+### <!-- 5 -->Miscellaneous Tasks
+
+- Migrate to rust audit fork
+
 ## [0.1.3](https://git.huizinga.dev/infra/crete/compare/v0.1.2...v0.1.3) - 2026-04-21
 
 ### <!-- 0 -->Features

Cargo.toml

@@ -1,45 +1,36 @@
 [package]
 name = "crete"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2024"
 default-run = "crete"
 publish = ["infra"]
 license = "GPL-3.0-or-later"
 
 [workspace]
-members = ["ipxe", "xtask"]
+members = ["xtask"]
 
 [workspace.dependencies]
-schemars = { version = "1.2.3", features = ["semver1"] }
+schemars = { version = "1.2.1", features = ["semver1"] }
-serde_json = "1.0.154"
+serde_json = "1.0.149"
 
 [dependencies]
-async-walkdir = "2.2.0"
+clap = { version = "4.6.0", features = ["derive"] }
-byteorder = "1.5.0"
+clap_complete = "4.6.0"
-clap = { version = "4.6.7", features = ["derive"] }
+gix-discover = { version = "0.55.0", features = ["sha1"] }
-clap_complete = "4.6.11"
+minijinja = { version = "2.18.0", features = ["json", "loader"] }
-futures = "0.3.34"
-gix-discover = { version = "0.57.0", features = ["sha1"] }
-minijinja = { version = "3.0.1", features = ["json", "serde"] }
-netascii = "0.1.0"
-num_enum = "0.7.6"
 optional_struct = "0.5.2"
-regex = "1.13.1"
+reqwest = { version = "0.13.2", default-features = false, features = [
-reqwest = { version = "0.13.5", default-features = false, features = [
+  "blocking",
+  "stream",
   "native-tls",
 ] }
 schemars = { workspace = true }
-semver = { version = "1.0.28", features = ["serde"] }
+semver = { version = "1.0.27", features = ["serde"] }
-serde = { version = "1.0.229", features = ["derive"] }
+serde = { version = "1.0.228", features = ["derive"] }
 serde_json = { workspace = true }
 serde_yaml = "0.9.34"
-thiserror = "2.0.21"
+thiserror = "2.0.18"
-tokio = { version = "1.54.0", features = ["full"] }
+walkdir = "2.5.0"
-ipxe = { path = "./ipxe" }
-axum = { version = "0.8.9", features = ["macros"] }
-socket2 = "0.6.5"
-socket-pktinfo = "0.4.1"
-serde-saphyr = "2.0.0"
 
 [lib]
 test = false

ipxe/Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-name = "ipxe"
-version = "0.1.0"
-edition = "2024"
-
-[build-dependencies]
-diffy = "0.5.2"
-gix = { version = "0.89.0", default-features = false, features = [
-  "blocking-network-client",
-  "worktree-mutation",
-  "sha1",
-  "blocking-http-transport-reqwest-rust-tls",
-] }
-
-[dependencies]
-include_dir = "0.7.4"

ipxe/build.rs

@@ -1,180 +0,0 @@
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use std::sync::atomic::AtomicBool;
-
-use diffy::apply;
-use diffy::patch_set::{FileOperation, ParseOptions, PatchSet};
-use gix::Repository;
-use gix::progress::Discard;
-
-const URL: &str = "https://github.com/ipxe/ipxe";
-const REVISION: &str = "2fa08affe9a1a1422766f54b2fb045234b571f06";
-const FILES: &[&str] = &["bin/ipxe.pxe", "bin-x86_64-efi/ipxe.efi"];
-
-const SRC_DIR: &str = "src";
-
-fn main() {
-    let manifest_dir = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
-        .canonicalize()
-        .unwrap();
-    let out_dir = PathBuf::from(std::env::var("OUT_DIR").unwrap())
-        .canonicalize()
-        .unwrap();
-    let repo_dir = out_dir.join("repo");
-
-    let repo = checkout(&out_dir, &repo_dir);
-
-    apply_patches(&repo, &manifest_dir, &repo_dir);
-    println!("cargo::rerun-if-changed=patches");
-
-    build(&manifest_dir, &repo_dir);
-    println!("cargo::rerun-if-changed=src/embed.ipxe");
-
-    copy_files(&repo_dir, &out_dir);
-}
-
-fn checkout(out_dir: &Path, repo_dir: &Path) -> Repository {
-    // Stamp file is used instead of comparing against HEAD to guard against incomplete clones
-    let stamp = out_dir.join("checkout.stamp");
-    if std::fs::read_to_string(&stamp).is_ok_and(|stamp| stamp == REVISION)
-        && let Ok(repo) = gix::open(repo_dir)
-    {
-        return repo;
-    }
-
-    // Cleanup any left-overs
-    std::fs::remove_file(&stamp).ok();
-    std::fs::remove_dir_all(repo_dir).ok();
-
-    std::fs::create_dir_all(repo_dir).unwrap();
-
-    let mut prepare = gix::prepare_clone(URL, repo_dir)
-        .unwrap()
-        .with_revision(Some(REVISION))
-        .unwrap();
-
-    let interrupt = AtomicBool::new(false);
-    let (mut checkout, _) = prepare.fetch_then_checkout(Discard, &interrupt).unwrap();
-    let (repo, _) = checkout.main_worktree(Discard, &interrupt).unwrap();
-
-    std::fs::write(&stamp, REVISION).unwrap();
-
-    repo
-}
-
-fn apply_patches(repo: &Repository, manifest_dir: &Path, repo_dir: &Path) {
-    let commit_id = gix::ObjectId::from_hex(REVISION.as_bytes()).unwrap();
-    let tree = repo.find_commit(commit_id).unwrap().tree().unwrap();
-
-    // Get all the patches and sort them based on name
-    let mut patch_files: Vec<PathBuf> = std::fs::read_dir(manifest_dir.join("patches"))
-        .unwrap()
-        .map(|e| e.unwrap().path())
-        .filter(|e| e.extension().is_some_and(|e| e == "patch"))
-        .collect();
-    patch_files.sort();
-
-    let mut patched = HashMap::new();
-    for path in patch_files {
-        let text = std::fs::read_to_string(&path).unwrap();
-        let patch_set = PatchSet::parse(&text, ParseOptions::gitdiff());
-
-        for patch in patch_set {
-            let patch = patch.unwrap();
-
-            match patch.operation().strip_prefix(1) {
-                FileOperation::Modify { original, modified } => {
-                    assert_eq!(original, modified);
-                    let path = original.to_string();
-
-                    // Either get the current in-memory patched file, otherwise get the prisine file
-                    let current = patched
-                        .remove(&path)
-                        .unwrap_or_else(|| pristine(&tree, &path));
-
-                    let new = apply(&current, patch.patch().as_text().unwrap()).unwrap();
-                    patched.insert(path, new);
-                }
-                _ => todo!(),
-            }
-        }
-    }
-
-    // If the file was previously patched, but now isn't restore the pristine file
-    for path in modified_files(repo) {
-        if !patched.contains_key(&path) {
-            std::fs::write(repo_dir.join(&path), pristine(&tree, &path)).unwrap();
-        }
-    }
-
-    // Write all the patched files
-    for (path, content) in &patched {
-        let path = repo_dir.join(path);
-        let content = content.as_bytes();
-
-        // But only if the file is actually different from the one on disk
-        // This prevents changing the mtime unnecessarily
-        if std::fs::read(&path).ok().as_deref() != Some(content) {
-            std::fs::write(path, content).unwrap();
-        }
-    }
-}
-
-fn pristine(tree: &gix::Tree<'_>, path: &str) -> String {
-    let entry = tree.lookup_entry_by_path(path).unwrap().unwrap();
-
-    String::from_utf8(entry.object().unwrap().data.clone()).unwrap()
-}
-
-fn modified_files(repo: &gix::Repository) -> Vec<String> {
-    repo.status(Discard)
-        .unwrap()
-        .untracked_files(gix::status::UntrackedFiles::None)
-        .into_index_worktree_iter(Vec::<gix::bstr::BString>::new())
-        .unwrap()
-        .map(|item| item.unwrap().rela_path().to_string())
-        .collect()
-}
-
-fn build(manifest_dir: &Path, repo_dir: &Path) {
-    let src_dir = repo_dir.join(SRC_DIR);
-
-    let mut command = Command::new("make");
-    command
-        .current_dir(&src_dir)
-        .env_remove("DEBUG")
-        .env_remove("PROFILE")
-        .arg(format!(
-            "EMBED={}",
-            manifest_dir
-                .join("src")
-                .join("embed.ipxe")
-                .to_string_lossy()
-        ))
-        .args(FILES);
-
-    if let Ok(flags) = std::env::var("CARGO_MAKEFLAGS") {
-        command.env("MAKEFLAGS", flags);
-    }
-
-    let output = command.output().unwrap();
-
-    if !output.status.success() {
-        panic!("make failed:\n{}", String::from_utf8_lossy(&output.stderr));
-    }
-}
-
-fn copy_files(repo_dir: &Path, out_dir: &Path) {
-    let src_dir = repo_dir.join(SRC_DIR);
-    let bin_dir = out_dir.join("bin");
-
-    std::fs::create_dir_all(&bin_dir).unwrap();
-    for file in FILES {
-        let file = Path::new(file);
-        let input = src_dir.join(file);
-        let output = bin_dir.join(file.file_name().unwrap());
-
-        std::fs::copy(input, output).unwrap();
-    }
-}

ipxe/patches/0001_enable_protocols.patch

@@ -1,19 +0,0 @@
-diff --git a/src/config/general.h b/src/config/general.h
-index 43858dceb..54cb1b657 100644
---- a/src/config/general.h
-+++ b/src/config/general.h
-@@ -60,10 +60,10 @@ FILE_SECBOOT ( PERMITTED );
- //#define HTTP_ENC_PEERDIST	/* PeerDist content encoding */
-
- /* Disable protocols not historically included in BIOS builds */
--#if defined ( PLATFORM_pcbios )
--  #undef DOWNLOAD_PROTO_HTTPS
--  #undef HTTP_AUTH_NTLM
--#endif
-+// #if defined ( PLATFORM_pcbios )
-+//   #undef DOWNLOAD_PROTO_HTTPS
-+//   #undef HTTP_AUTH_NTLM
-+// #endif
-
- /*****************************************************************************
-  *

ipxe/src/embed.ipxe

@@ -1,4 +0,0 @@
-#!ipxe
-
-dhcp
-chain boot.ipxe

ipxe/src/lib.rs

@@ -1,3 +0,0 @@
-use include_dir::{Dir, include_dir};
-
-pub static IPXE_DIR: Dir<'_> = include_dir!("$OUT_DIR/bin");

rust-toolchain.toml

@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2026-10-01"
+channel = "nightly-2026-03-12"
 profile = "default"
 components = ["rust-analyzer"]

src/boot.ipxe

@@ -1,19 +0,0 @@
-#!ipxe
-echo Starting ${serial}
-
-:start
-goto node_${serial} || exit
-# Default behavior (non install mode) is to exit iPXE script
-
-{% for cluster in clusters%}
-{% for _, node in cluster.nodes|items %}
-{%- if node.install.serial -%}
-# {{ cluster.name }}/{{ node.hostname }}
-:node_{{ node.install.serial }}
-imgfree
-kernel https://pxe.factory.talos.dev/image/{{ node.schematic }}/v{{ cluster.version.talos }}/kernel-{{ node.arch }} {{ node.kernelArgs|join(" ") }} {% if node.install.auto %}talos.config={{httpUrl}}/talos/{{cluster.name}}/{{node.hostname}}.yaml{% endif +%}
-initrd https://pxe.factory.talos.dev/image/{{ node.schematic }}/v{{ cluster.version.talos }}/initramfs-{{ node.arch }}.xz
-boot
-{% endif %}
-{% endfor %}
-{% endfor %}

src/cli.rs

@@ -1,4 +1,3 @@
-use std::net::IpAddr;
 use std::path::PathBuf;
 
 use clap::{Args, Parser, Subcommand};
@@ -50,11 +49,4 @@ pub enum Commands {
     Generate,
     /// Generate completions for your current shell
     ShellCompletions,
-    /// Serve config files over tftp
-    Serve {
-        #[arg(short, long, default_value = "3000")]
-        port: u16,
-        #[arg(long, default_value = "0.0.0.0")]
-        ip: IpAddr,
-    },
 }

src/cluster.rs

@@ -1,22 +1,18 @@
-use std::collections::HashMap;
 use std::net::Ipv4Addr;
 use std::path::PathBuf;
+use std::process::Command;
 use std::str::FromStr;
 
-use async_walkdir::WalkDir;
-use futures::StreamExt;
-use futures::stream::FuturesUnordered;
 use minijinja::Environment;
 use optional_struct::{Applicable, optional_struct};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use tokio::process::Command;
+use walkdir::WalkDir;
 
 use crate::environment::PathEnvironment;
 use crate::node::{Node, OptionalNodeDeserialize};
 use crate::patch::Patches;
-use crate::talosconfig::TalosConfig;
+use crate::{get_configs_path, get_talos_path};
-use crate::{get_configs_path, get_talos_path, run_command};
 
 #[optional_struct]
 #[derive(Debug, Deserialize, JsonSchema, Clone)]
@@ -72,37 +68,33 @@ struct ClusterDeserialize {
     base: Base,
 }
 
-#[derive(Debug, Serialize, Clone)]
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Cluster {
     pub(crate) name: String,
     pub(crate) version: Version,
-    nodes: HashMap<String, Node>,
+    nodes: Vec<Node>,
     cluster_env: ClusterEnv,
     pub(crate) control_plane_ip: Ipv4Addr,
     pub(crate) secrets_file: PathBuf,
 }
 
 impl Cluster {
-    pub(crate) async fn get(cluster_name: &str, env: &Environment<'static>) -> Self {
+    pub(crate) fn get(cluster_name: &str, env: &Environment) -> Self {
         let path = get_talos_path().join("clusters").join("default.yaml");
 
         let default: OptionalClusterDeserialize = if path.exists() {
-            let content = tokio::fs::read_to_string(path).await.unwrap();
+            let content = std::fs::read_to_string(path).unwrap();
-
+            serde_yaml::from_str(&content).unwrap()
-            // The deserialization makes a blocking web request
-            tokio::task::spawn_blocking(move || serde_yaml::from_str(&content).unwrap())
-                .await
-                .unwrap()
         } else {
             Default::default()
         };
 
         let mut path = get_talos_path().join("clusters").join(cluster_name);
         path.add_extension("yaml");
-        let content = tokio::fs::read_to_string(path).await.unwrap();
+        let content = std::fs::read_to_string(path).unwrap();
 
-        let mut cluster: OptionalClusterDeserialize = serde_saphyr::from_str(&content).unwrap();
+        let mut cluster: OptionalClusterDeserialize = serde_yaml::from_str(&content).unwrap();
 
         // For some reason apply on the cluster does not properly apply to the default settings...
         // So we manually apply it here first
@@ -122,32 +114,28 @@ impl Cluster {
         let cluster = Self {
             name: cluster_name.into(),
             version: cluster.version,
-            nodes: Default::default(),
+            nodes: vec![],
             cluster_env: cluster.cluster_env,
             control_plane_ip: cluster.control_plane_ip,
             secrets_file,
         };
 
-        let nodes = nodes.iter().map(|name| async {
+        let nodes = nodes
-            let node = Node::get(name, env, &cluster, &default, &base).await;
+            .iter()
-            (node.hostname().to_owned(), node)
+            .map(|name| Node::get(name, env, &cluster, &default, &base))
-        });
+            .collect();
-
-        let nodes = FuturesUnordered::from_iter(nodes).collect().await;
 
         Self { nodes, ..cluster }
     }
 
-    pub async fn get_all() -> HashMap<String, Cluster> {
+    pub fn get_all() -> Vec<Cluster> {
         let env = PathEnvironment::new_patches();
 
-        let names: Vec<_> = WalkDir::new(get_talos_path().join("clusters"))
+        WalkDir::new(get_talos_path().join("clusters"))
-            .filter_map(|e| async { e.ok() })
+            .into_iter()
-            .filter(|e| {
+            .filter_map(|e| e.ok())
-                let e = e.clone();
+            .filter(|e| e.metadata().unwrap().is_file())
-                async move { e.metadata().await.unwrap().is_file() }
+            .filter_map(|e| {
-            })
-            .filter_map(|e| async move {
                 let mut path = PathBuf::from_str(&e.file_name().to_string_lossy()).unwrap();
                 path.set_extension("");
 
@@ -157,35 +145,18 @@ impl Cluster {
                     return None;
                 }
 
-                Some(name)
+                Some(Cluster::get(&name, &env))
             })
             .collect()
-            .await;
-
-        // Get the clusters concurrently
-        FuturesUnordered::from_iter(names.iter().map(|name| {
-            let env = env.clone();
-            let name = name.clone();
-
-            async move {
-                let cluster = Cluster::get(&name, &env).await;
-
-                (name, cluster)
-            }
-        }))
-        .collect()
-        .await
     }
 
-    pub fn nodes(&self) -> impl Iterator<Item = &Node> {
+    pub fn nodes(&self) -> &[Node] {
-        self.nodes.values()
+        &self.nodes
     }
 
-    pub fn node(&self, node: &str) -> Option<&Node> {
+    pub fn talosctl_gen_config_command(&self) -> Command {
-        self.nodes.get(node)
+        let path = get_configs_path().join(&self.name).join("talosconfig");
-    }
 
-    pub async fn talosconfig(&self) -> String {
         let mut command = Command::new("talosctl");
         command.args([
             "gen",
@@ -197,59 +168,41 @@ impl Cluster {
             "--output-types",
             "talosconfig",
             "-o",
-            "-",
+            path.to_str().expect("Path should be valid utf-8"),
         ]);
 
-        run_command(command).await
+        command
     }
 
-    pub fn talosconfig_path(&self) -> PathBuf {
+    pub fn talosctl_add_endpoint_command(&self) -> Command {
-        get_configs_path().join(&self.name).join("talosconfig")
+        let path = get_configs_path().join(&self.name).join("talosconfig");
-    }
 
-    async fn talosconfig_add_endpoint(&self) {
         let mut command = Command::new("talosctl");
         command.args([
             "config",
             "--talosconfig",
-            self.talosconfig_path()
+            path.to_str().expect("Path should be valid utf-8"),
-                .to_str()
-                .expect("Path should be valid utf-8"),
             "endpoint",
             &self.control_plane_ip.to_string(),
         ]);
 
-        run_command(command).await;
+        command
     }
 
-    pub async fn talosconfig_write(&self) {
+    pub fn talosctl_merge_command(&self) -> Command {
-        let config = self.talosconfig().await;
+        let cluster_path = get_configs_path().join(&self.name).join("talosconfig");
+        let path = get_configs_path().join("talosconfig");
 
-        let path = self.talosconfig_path();
-        tokio::fs::create_dir_all(path.parent().expect("talosconfig should have parent"))
-            .await
-            .unwrap();
-
-        tokio::fs::write(path, config).await.unwrap();
-
-        self.talosconfig_add_endpoint().await
-    }
-
-    pub async fn talosconfig_merge(&self) {
         let mut command = Command::new("talosctl");
         command.args([
             "config",
             "--talosconfig",
-            TalosConfig::merged_path()
+            path.to_str().expect("Path should be valid utf-8"),
-                .to_str()
-                .expect("Path should be valid utf-8"),
             "merge",
-            self.talosconfig_path()
+            cluster_path.to_str().expect("Path should be valid utf-8"),
-                .to_str()
-                .expect("Path should be valid utf-8"),
         ]);
 
-        run_command(command).await;
+        command
     }
 }
 

src/environment.rs

@@ -2,44 +2,39 @@ use std::net::Ipv4Addr;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 
-use async_walkdir::WalkDir;
+use minijinja::value::ViaDeserialize;
-use futures::{Stream, StreamExt};
+use minijinja::{AutoEscape, Environment, path_loader};
-use minijinja::syntax::SyntaxConfig;
+use walkdir::WalkDir;
-use minijinja::{AutoEscape, Environment, path_loader, value};
 
 use crate::{get_configs_path, get_talos_path};
 
 /// Transparent wrapper around minijinja::Environment that loads templates from a path and
 /// configures better defaults. It also implements IntoIter, making it possible to iterate over all
 /// the templates.
-#[derive(Clone)]
 pub struct PathEnvironment<'a> {
     env: Environment<'a>,
     path: PathBuf,
 }
 
 fn apply_netmask(
-    ip: value::Serde<Ipv4Addr>,
+    ip: ViaDeserialize<Ipv4Addr>,
-    netmask: value::Serde<Ipv4Addr>,
+    netmask: ViaDeserialize<Ipv4Addr>,
 ) -> Result<String, minijinja::Error> {
     Ok((*ip & *netmask).to_string())
 }
 
-pub fn configure_environment(env: &mut Environment) {
+impl<'a> PathEnvironment<'a> {
+    pub fn new(path: &Path) -> Self {
+        let mut env = Environment::new();
+
         // Configure jinja
-    // Configure jinja
+        env.set_trim_blocks(true);
-    env.set_syntax(
+        env.set_lstrip_blocks(true);
-        SyntaxConfig::builder()
-            .trim_blocks(true)
-            .lstrip_blocks(true)
-            .build()
-            .expect("Syntax config should be valid"),
-    );
         env.set_undefined_behavior(minijinja::UndefinedBehavior::Strict);
         env.set_auto_escape_callback(|_| AutoEscape::None);
 
         // Add filters
-    env.add_filter("to_prefix", |netmask: value::Serde<Ipv4Addr>| {
+        env.add_filter("to_prefix", |netmask: ViaDeserialize<Ipv4Addr>| {
             let mask = netmask.to_bits();
             let prefix = mask.leading_ones();
 
@@ -68,13 +63,6 @@ pub fn configure_environment(env: &mut Environment) {
                 })
                 .collect::<Vec<_>>()
         });
-}
-
-impl<'a> PathEnvironment<'a> {
-    pub fn new(path: &Path) -> Self {
-        let mut env = Environment::new();
-
-        configure_environment(&mut env);
 
         // Add path loader
         env.set_loader(path_loader(&path));
@@ -88,23 +76,6 @@ impl<'a> PathEnvironment<'a> {
     pub(crate) fn new_patches() -> Self {
         Self::new(&get_talos_path().join("patches"))
     }
-
-    pub fn files(&self) -> impl Stream<Item = String> {
-        // Find all templates in path
-        WalkDir::new(&self.path)
-            .filter_map(|e| async { e.ok() })
-            .filter(|e| {
-                let e = e.clone();
-                async move { e.metadata().await.unwrap().is_file() }
-            })
-            .map(move |e| {
-                e.path()
-                    .strip_prefix(&self.path)
-                    .expect("All paths should have prefix")
-                    .to_string_lossy()
-                    .to_string()
-            })
-    }
 }
 
 // Make PathEnvironment act like a normal Environment transparently
@@ -115,3 +86,25 @@ impl<'a> Deref for PathEnvironment<'a> {
         &self.env
     }
 }
+
+// Iterate over all the files in the path
+impl<'a, 'b> IntoIterator for &'b PathEnvironment<'a> {
+    type Item = String;
+
+    type IntoIter = impl Iterator<Item = Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        // Find all templates in path
+        WalkDir::new(&self.path)
+            .into_iter()
+            .filter_map(|e| e.ok())
+            .filter(|e| e.metadata().unwrap().is_file())
+            .map(|e| {
+                e.path()
+                    .strip_prefix(&self.path)
+                    .expect("All paths should have prefix")
+                    .to_string_lossy()
+                    .to_string()
+            })
+    }
+}

src/error.rs

@@ -1,10 +0,0 @@
-use crete::tftp::ServerError;
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum Error {
-    #[error("No clusters where found")]
-    NoClustersFound,
-    #[error("Server error: {0}")]
-    ServerError(#[from] ServerError),
-}

src/file.rs

@@ -1,55 +0,0 @@
-use crete::cluster::Cluster;
-use crete::environment::configure_environment;
-use ipxe::IPXE_DIR;
-use minijinja::{Environment, context, value};
-use regex::regex;
-
-pub async fn get_file(
-    filename: impl ToString,
-    http_url: impl ToString,
-) -> Option<(Vec<u8>, &'static str)> {
-    let re = regex!(r"^talos/(?<cluster>.+)/(?<node>.+)\.ya?ml$");
-
-    let filename: String = filename.to_string();
-    let re = re.clone();
-
-    const IPXE_PATTERN: &str = "ipxe/";
-    if filename == format!("{IPXE_PATTERN}boot.ipxe") {
-        let mut env = Environment::new();
-
-        configure_environment(&mut env);
-
-        let template = env
-            .template_from_str(include_str!("./boot.ipxe"))
-            .expect("Template should be valid");
-
-        let clusters = Cluster::get_all().await;
-        let content = template
-            .render(context! {
-                clusters => value::Serde(clusters.values().collect::<Vec<_>>()),
-                httpUrl => http_url.to_string()
-            })
-            .unwrap();
-
-        Some((content.into(), "text/plain; charset=utf-8"))
-    } else if let Some(filename) = filename.strip_prefix(IPXE_PATTERN) {
-        Some((
-            IPXE_DIR.get_file(filename)?.contents().to_owned(),
-            "application/octet-stream",
-        ))
-    } else if let Some(caps) = re.captures(&filename) {
-        let cluster = &caps["cluster"];
-        let node = &caps["node"];
-
-        let clusters = Cluster::get_all().await;
-        let cluster = clusters.get(cluster)?;
-
-        let node = cluster.node(node)?;
-
-        let config = node.config(cluster).await;
-
-        Some((config.into(), "application/yaml; charset=utf-8"))
-    } else {
-        None
-    }
-}

src/http.rs

@@ -1,46 +0,0 @@
-use std::path::PathBuf;
-
-use axum::debug_handler;
-use axum::extract::Request;
-use axum::http::Uri;
-use axum::response::IntoResponse;
-use reqwest::{StatusCode, header};
-
-use crate::file::get_file;
-
-#[debug_handler]
-pub async fn handler(req: Request) -> impl IntoResponse {
-    let uri: Uri = req
-        .headers()
-        .iter()
-        .find(|(name, _)| header::HOST.eq(name))
-        .map(|(_, value)| value)
-        .expect("Host header should exist")
-        .to_str()
-        .expect("Header value should be valid ASCII")
-        .parse()
-        .expect("Host should be valid Uri");
-
-    let host = uri.host().expect("Uri should have host");
-    let port = uri.port().map(|port| port.as_u16()).unwrap_or(80);
-
-    let Some(path) = req.uri().path().strip_prefix("/") else {
-        return StatusCode::BAD_REQUEST.into_response();
-    };
-
-    let Some((file, content_type)) = get_file(path, format!("http://{host}:{port}")).await else {
-        return StatusCode::NOT_FOUND.into_response();
-    };
-
-    let path = PathBuf::from(path);
-    let filename = path.file_name().unwrap();
-    let filename = filename.to_str().unwrap();
-
-    let content_type = [(header::CONTENT_TYPE, content_type)];
-    let disposition = [(
-        header::CONTENT_DISPOSITION,
-        format!("inline; filename=\"{filename}\""),
-    )];
-
-    (content_type, disposition, file).into_response()
-}

src/lib.rs

@@ -1,17 +1,13 @@
-#![feature(path_absolute_method)]
+#![feature(impl_trait_in_assoc_type, path_absolute_method)]
 use std::path::{Path, PathBuf};
 use std::sync::OnceLock;
 
-use tokio::process::Command;
-
 pub mod cluster;
 pub mod environment;
 pub mod node;
 pub mod patch;
 pub mod schematic;
 pub mod secret;
-pub mod talosconfig;
-pub mod tftp;
 
 pub(crate) static REPO_PATH: OnceLock<PathBuf> = OnceLock::new();
 
@@ -32,14 +28,3 @@ pub fn get_talos_path() -> PathBuf {
 pub fn get_configs_path() -> PathBuf {
     get_repo_path().join("configs")
 }
-
-pub async fn run_command(mut command: Command) -> String {
-    let output = command.output().await.unwrap();
-    if !output.stderr.is_empty() {
-        println!("{}", String::from_utf8_lossy(&output.stderr).trim_end());
-    }
-
-    String::from_utf8_lossy(&output.stdout)
-        .trim_end()
-        .to_owned()
-}

src/main.rs

@@ -1,126 +1,95 @@
 mod cli;
-mod error;
-mod file;
-mod http;
 
-use std::net::SocketAddr;
+use std::process::Command;
-use std::pin::pin;
 
-use axum::Router;
-use axum::routing::get;
 use clap::{CommandFactory, Parser};
 use clap_complete::{Shell, generate as generate_complete};
 use crete::cluster::Cluster;
 use crete::environment::PathEnvironment;
-use crete::talosconfig::{get_current_context, set_context};
+use crete::{get_configs_path, get_repo_path, set_repo_path};
-use crete::{get_configs_path, get_repo_path, set_repo_path, tftp};
+use minijinja::context;
-use futures::StreamExt;
+use thiserror::Error;
-use futures::future::join_all;
-use minijinja::{context, value};
 
 use crate::cli::{Cli, Commands, GlobalOpts};
-use crate::error::Error;
-use crate::file::get_file;
-use crate::http::handler;
 
-async fn generate(opts: &GlobalOpts) -> Result<(), Error> {
+#[derive(Debug, Error)]
-    let clusters = Cluster::get_all().await;
+enum Error {
+    #[error("No clusters where found")]
+    NoClustersFound,
+}
+
+fn run_command(mut command: Command) {
+    let output = command.output().unwrap();
+    if !output.stdout.is_empty() {
+        println!("{}", String::from_utf8_lossy(&output.stdout).trim_end());
+    }
+    if !output.stderr.is_empty() {
+        println!("{}", String::from_utf8_lossy(&output.stderr).trim_end());
+    }
+}
+
+fn generate(opts: &GlobalOpts) -> Result<(), Error> {
+    set_repo_path(&opts.repo);
+
+    let clusters = Cluster::get_all();
 
     if clusters.is_empty() {
         return Err(Error::NoClustersFound);
     }
 
     let path = opts.repo.join("rendered");
-    // We don't really care if this fails, as that likely mean that the directory did not exist
+    if path.exists() {
-    tokio::fs::remove_dir_all(&path).await.ok();
+        std::fs::remove_dir_all(&path).unwrap();
-    tokio::fs::create_dir_all(&path).await.unwrap();
+    }
+    std::fs::create_dir(&path).unwrap();
 
     // Render templates
     let template_env = PathEnvironment::new(&get_repo_path().join("templates"));
-
+    for template_name in &template_env {
-    let mut stream = pin!(template_env.files());
-    while let Some(template_name) = stream.next().await {
         let template = template_env.get_template(&template_name).unwrap();
 
         let content = template
             .render(context! {
-                clusters => value::Serde(clusters.values().collect::<Vec<_>>()),
+                clusters,
-                root => value::Serde(&opts.repo)
+                root => opts.repo
             })
             .unwrap();
 
-        tokio::fs::write(path.join(template_name), content)
+        std::fs::write(path.join(template_name), content).unwrap();
-            .await
-            .unwrap();
     }
 
-    let context = get_current_context().await;
-
     // Remove existing config files and create output directory
     let path = get_configs_path();
-    tokio::fs::remove_dir_all(&path).await.ok();
+    if path.exists() {
-    tokio::fs::create_dir_all(&path).await.unwrap();
+        std::fs::remove_dir_all(&path).unwrap();
+    }
+    std::fs::create_dir(&path).unwrap();
 
     // Generate config files
-    join_all(clusters.values().map(|cluster| async move {
+    for cluster in clusters {
-        join_all(cluster.nodes().map(|node| {
+        for node in cluster.nodes() {
-            let cluster = cluster.clone();
+            run_command(node.talosctl_gen_config_command(&cluster));
-            async move {
-                node.config_write(&cluster).await;
-            }
-        }))
-        .await;
-
-        // Run these commands in parallel with the the node commands
-        // NOTE: These do need to happen in the correct order
-        cluster.talosconfig_write().await;
-    }))
-    .await;
-
-    // Merge all the cluster talosconfig files into a single file
-    // Since this all modifies the same output file this has to happen sequentially
-    for (_, cluster) in clusters {
-        cluster.talosconfig_merge().await;
         }
 
-    if let Some(context) = context {
+        run_command(cluster.talosctl_gen_config_command());
-        set_context(context).await;
+        run_command(cluster.talosctl_add_endpoint_command());
+        run_command(cluster.talosctl_merge_command());
     }
 
     Ok(())
 }
 
-#[tokio::main]
+fn main() -> Result<(), Error> {
-async fn main() -> Result<(), Error> {
     let cli = Cli::parse();
 
-    set_repo_path(&cli.global_opts.repo);
-
     match cli.command {
-        Commands::Generate => generate(&cli.global_opts).await?,
+        Commands::Generate => generate(&cli.global_opts)?,
         Commands::ShellCompletions => generate_complete(
             Shell::from_env().unwrap_or(Shell::Bash),
             &mut Cli::command(),
             "crete",
             &mut std::io::stdout(),
         ),
-        Commands::Serve { port, ip } => {
-            tokio::spawn(async move {
-                let app = Router::new().fallback_service(get(handler));
-                let addr: SocketAddr = (ip, port).into();
-                let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
-
-                println!("Http server started on {addr}");
-                axum::serve(listener, app).await.unwrap();
-            });
-
-            tftp::serve(ip, move |filename, ip| async move {
-                get_file(filename, format!("http://{ip}:{port}"))
-                    .await
-                    .map(|(file, _)| file)
-            })
-            .await?;
-        }
     };
 
     Ok(())

src/node.rs

@@ -1,17 +1,16 @@
 use std::net::Ipv4Addr;
-use std::path::PathBuf;
+use std::process::Command;
 
 use minijinja::Environment;
 use optional_struct::{Applicable, optional_struct};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use tokio::process::Command;
 
 use crate::cluster::{Base, Cluster};
 use crate::patch::{OptionalPatches, OptionalPatchesString, Patches};
 use crate::schematic::Schematic;
 use crate::secret::Secret;
-use crate::{get_configs_path, get_talos_path, run_command};
+use crate::{get_configs_path, get_talos_path};
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema, Clone, Copy, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
@@ -91,7 +90,7 @@ pub(crate) struct NodeDeserialize {
     sops: Secret,
 }
 
-#[derive(Debug, Serialize, Clone)]
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Node {
     hostname: String,
@@ -102,14 +101,14 @@ pub struct Node {
     ntp: String,
     install: Install,
     kernel_args: Vec<String>,
-    patches: Patches<serde_json::Value>,
+    patches: Patches<serde_yaml::Value>,
     sops: Secret,
 }
 
 impl Node {
-    pub(crate) async fn get(
+    pub(crate) fn get(
         node_name: &str,
-        env: &Environment<'static>,
+        env: &Environment,
         cluster: &Cluster,
         default: &OptionalNodeDeserialize,
         base: &Base,
@@ -122,9 +121,9 @@ impl Node {
             .to_string();
 
         path.add_extension("yaml");
-        let content = tokio::fs::read_to_string(path).await.unwrap();
+        let content = std::fs::read_to_string(path).unwrap();
 
-        let node: OptionalNodeDeserialize = serde_saphyr::from_str(&content).unwrap();
+        let node: OptionalNodeDeserialize = serde_yaml::from_str(&content).unwrap();
 
         // We want all vectors to be empty vectors by default
         // Sadly we have to this manually
@@ -173,16 +172,15 @@ impl Node {
         };
 
         // Render patches
-        let patches = patches.render(env, cluster, &node).await;
+        let patches = patches.render(env, cluster, &node);
 
         Node { patches, ..node }
     }
 
-    pub fn hostname(&self) -> &str {
+    pub fn talosctl_gen_config_command(&self, cluster: &Cluster) -> Command {
-        &self.hostname
+        let mut path = get_configs_path().join(&cluster.name).join(&self.hostname);
-    }
+        path.add_extension("yaml");
 
-    pub async fn config(&self, cluster: &Cluster) -> String {
         let mut command = Command::new("talosctl");
         command.args([
             "gen",
@@ -206,7 +204,7 @@ impl Node {
             "--with-docs=false",
             "--with-examples=false",
             "-o",
-            "-",
+            path.to_str().expect("Path should be valid utf-8"),
         ]);
 
         for patch in &self.patches.all {
@@ -220,25 +218,7 @@ impl Node {
             ]);
         }
 
-        run_command(command).await
+        command
-    }
-
-    pub fn config_path(&self, cluster: &Cluster) -> PathBuf {
-        let mut path = get_configs_path().join(&cluster.name).join(&self.hostname);
-        path.add_extension("yaml");
-
-        path
-    }
-
-    pub async fn config_write(&self, cluster: &Cluster) {
-        let config = self.config(cluster).await;
-
-        let path = self.config_path(cluster);
-        tokio::fs::create_dir_all(path.parent().expect("config should have parent"))
-            .await
-            .unwrap();
-
-        tokio::fs::write(path, config).await.unwrap();
     }
 }
 

src/patch.rs

@@ -1,4 +1,4 @@
-use minijinja::{Environment, context, value};
+use minijinja::{Environment, context};
 use optional_struct::optional_struct;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -16,36 +16,27 @@ pub(crate) struct Patches<T> {
 
 pub(crate) type OptionalPatchesString = OptionalPatches<String>;
 
-async fn render(
+fn render(
     patches: Vec<String>,
-    env: &Environment<'static>,
+    env: &Environment,
     cluster: &Cluster,
     node: &Node,
-) -> Vec<serde_json::Value> {
+) -> Vec<serde_yaml::Value> {
-    let env = env.clone();
-    let cluster = cluster.clone();
-    let node = node.clone();
-
-    // Minijinja will still have blocking I/O internally
-    tokio::task::spawn_blocking(move || {
     patches
         .into_iter()
-            .map(move |name| {
+        .map(|name| {
             let content = env
                 .get_template(&name)
                 .unwrap()
                 .render(context! {
-                        node => value::Serde(&node),
+                    node,
-                        cluster => value::Serde(&cluster)
+                    cluster
                 })
                 .unwrap();
 
-                serde_saphyr::from_str(&content).unwrap()
+            serde_yaml::from_str(&content).unwrap()
         })
         .collect()
-    })
-    .await
-    .unwrap()
 }
 
 impl Patches<String> {
@@ -59,15 +50,15 @@ impl Patches<String> {
         }
     }
 
-    pub(crate) async fn render(
+    pub(crate) fn render(
         self,
-        env: &Environment<'static>,
+        env: &Environment,
         cluster: &Cluster,
         node: &Node,
-    ) -> Patches<serde_json::Value> {
+    ) -> Patches<serde_yaml::Value> {
         Patches {
-            all: render(self.all.clone(), env, cluster, node).await,
+            all: render(self.all.clone(), env, cluster, node),
-            control_plane: render(self.control_plane.clone(), env, cluster, node).await,
+            control_plane: render(self.control_plane.clone(), env, cluster, node),
         }
     }
 }

src/schematic.rs

@@ -1,6 +1,5 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Deserializer, Serialize};
-use tokio::runtime::Handle;
 
 use crate::get_talos_path;
 
@@ -12,7 +11,7 @@ where
     let path = get_talos_path().join("schematics").join(name);
     let content = std::fs::read_to_string(path).unwrap().trim().to_owned();
 
-    let client = reqwest::ClientBuilder::new()
+    let client = reqwest::blocking::ClientBuilder::new()
         .user_agent(format!(
             "{}/{}",
             std::env!("CARGO_PKG_NAME"),
@@ -21,30 +20,20 @@ where
         .build()
         .unwrap();
 
+    let res = client
+        .post("https://factory.talos.dev/schematics")
+        .body(content)
+        .send()
+        .map_err(serde::de::Error::custom)?;
+
     #[derive(Debug, Deserialize)]
     struct Response {
         id: String,
     }
 
-    // We can't use async directly inside a custom deserializer, and using the blocking client also
+    let response: Response = serde_json::from_str(&res.text().map_err(serde::de::Error::custom)?)
-    // does not work as it will try to start tokio inside of tokio.
-    // So we have do this to work around it.
-    // NOTE: This requires that the deserialization happens inside spawn_blocking
-    let response = Handle::current().block_on(async {
-        let res = client
-            .post("https://factory.talos.dev/schematics")
-            .body(content)
-            .send()
-            .await
         .map_err(serde::de::Error::custom)?;
 
-        let response: Response =
-            serde_json::from_str(&res.text().await.map_err(serde::de::Error::custom)?)
-                .map_err(serde::de::Error::custom)?;
-
-        Ok(response)
-    })?;
-
     Ok(response.id)
 }
 

src/talosconfig.rs

@@ -1,40 +0,0 @@
-use std::path::PathBuf;
-
-use serde::Deserialize;
-use tokio::process::Command;
-
-use crate::{get_configs_path, run_command};
-
-#[derive(Debug, Deserialize)]
-pub struct TalosConfig {
-    context: String,
-}
-
-impl TalosConfig {
-    pub fn merged_path() -> PathBuf {
-        get_configs_path().join("talosconfig")
-    }
-}
-
-pub async fn get_current_context() -> Option<String> {
-    tokio::fs::read(&TalosConfig::merged_path())
-        .await
-        .ok()
-        .and_then(|config| serde_saphyr::from_slice(&config).ok())
-        .map(|config: TalosConfig| config.context)
-}
-
-pub async fn set_context(context: String) {
-    let mut command = Command::new("talosctl");
-    command.args([
-        "config",
-        "--talosconfig",
-        TalosConfig::merged_path()
-            .to_str()
-            .expect("Path should be valid utf-8"),
-        "context",
-        &context,
-    ]);
-
-    run_command(command).await;
-}

src/tftp/error.rs

@@ -1,20 +0,0 @@
-use std::io;
-use std::string::FromUtf8Error;
-
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum Error {
-    #[error("Invalid op code '{0}'")]
-    InvalidOpCode(u16),
-    #[error("Invalid error code '{0}'")]
-    InvalidErrorCode(u16),
-    #[error("Invalid mode '{0}'")]
-    InvalidMode(String),
-    #[error("String contains invalid characters")]
-    InvalidString(#[from] FromUtf8Error),
-    #[error("Unterminated string")]
-    UnterminatedString,
-    #[error("Io error: {0}")]
-    Io(#[from] io::Error),
-}

src/tftp/mod.rs

@@ -1,7 +0,0 @@
-mod error;
-mod packet;
-mod server;
-
-pub use error::Error;
-pub use packet::Packet;
-pub use server::{Error as ServerError, serve};

src/tftp/packet.rs

@@ -1,355 +0,0 @@
-use std::io::{BufRead, BufReader, BufWriter, Cursor, Read, Write};
-use std::net::SocketAddr;
-
-use byteorder::{NetworkEndian, ReadBytesExt, WriteBytesExt};
-use num_enum::{IntoPrimitive, TryFromPrimitive};
-use tokio::net::UdpSocket;
-
-use crate::tftp::Error;
-
-// 2 bytes op code + 2 bytes block number + max 512 bytes data
-pub(crate) const PACKET_SIZE: usize = 2 + 2 + 512;
-
-fn decode_null_terminated<R>(reader: &mut BufReader<R>) -> Result<String, Error>
-where
-    R: Read + ?Sized,
-{
-    let mut text = Vec::new();
-    reader.read_until(0, &mut text)?;
-
-    // Make sure we ended with a null terminator
-    match text.pop() {
-        Some(0) => {}
-        None | Some(_) => return Err(Error::UnterminatedString),
-    }
-
-    Ok(String::from_utf8(text)?)
-}
-
-fn encode_null_terminated<W>(writer: &mut BufWriter<W>, text: impl AsRef<str>) -> Result<(), Error>
-where
-    W: Write + ?Sized,
-{
-    let text = text.as_ref().as_bytes();
-    writer.write_all(text)?;
-
-    // Add null terminator
-    writer.write_u8(0)?;
-
-    Ok(())
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Mode {
-    NetAscii,
-    Octet,
-    Mail,
-}
-
-impl Mode {
-    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
-    where
-        R: Read + ?Sized,
-    {
-        let mut mode = decode_null_terminated(reader)?;
-        mode.make_ascii_lowercase();
-        let mode = mode;
-
-        Ok(match mode.as_str() {
-            "netascii" => Self::NetAscii,
-            "octet" => Self::Octet,
-            "mail" => Self::Mail,
-            _ => return Err(Error::InvalidMode(mode)),
-        })
-    }
-
-    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
-    where
-        W: Write + ?Sized,
-    {
-        let mode = match &self {
-            Mode::NetAscii => "netascii",
-            Mode::Octet => "octet",
-            Mode::Mail => "mail",
-        };
-
-        encode_null_terminated(writer, mode)?;
-
-        Ok(())
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct Request {
-    filename: String,
-    mode: Mode,
-}
-
-impl Request {
-    pub fn filename(&self) -> &str {
-        &self.filename
-    }
-
-    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
-    where
-        R: Read + ?Sized,
-    {
-        let filename = decode_null_terminated(reader)?;
-        let mode = Mode::decode(reader)?;
-
-        Ok(Self { filename, mode })
-    }
-
-    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
-    where
-        W: Write + ?Sized,
-    {
-        encode_null_terminated(writer, &self.filename)?;
-        self.mode.encode(writer)?;
-
-        Ok(())
-    }
-
-    pub fn mode(&self) -> Mode {
-        self.mode
-    }
-}
-
-#[derive(Debug)]
-pub struct Data {
-    block: u16,
-    data: Vec<u8>,
-}
-
-impl Data {
-    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
-    where
-        R: Read + ?Sized,
-    {
-        let block = reader.read_u16::<NetworkEndian>()?;
-
-        let mut data = Vec::new();
-        reader.read_to_end(&mut data)?;
-
-        Ok(Self { data, block })
-    }
-
-    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
-    where
-        W: Write + ?Sized,
-    {
-        writer.write_u16::<NetworkEndian>(self.block)?;
-        writer.write_all(&self.data)?;
-
-        Ok(())
-    }
-}
-
-#[derive(Debug)]
-pub struct Ack(u16);
-
-impl Ack {
-    pub fn block(&self) -> u16 {
-        self.0
-    }
-
-    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
-    where
-        R: Read + ?Sized,
-    {
-        let number = reader.read_u16::<NetworkEndian>()?;
-
-        Ok(Self(number))
-    }
-
-    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
-    where
-        W: Write + ?Sized,
-    {
-        writer.write_u16::<NetworkEndian>(self.0)?;
-
-        Ok(())
-    }
-}
-
-#[derive(Debug, TryFromPrimitive, IntoPrimitive, Clone, Copy)]
-#[repr(u16)]
-pub enum ErrorCode {
-    NotDefined,
-    FileNotFound,
-    AccessViolation,
-    DiskFull,
-    Illegal,
-    UnknownTransferId,
-    FileAlreadyExists,
-    NoSuchUser,
-}
-
-impl ErrorCode {
-    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
-    where
-        R: Read + ?Sized,
-    {
-        let code = reader.read_u16::<NetworkEndian>()?;
-        Self::try_from_primitive(code).map_err(|err| Error::InvalidErrorCode(err.number))
-    }
-
-    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
-    where
-        W: Write + ?Sized,
-    {
-        let code: u16 = (*self).into();
-
-        writer.write_u16::<NetworkEndian>(code)?;
-
-        Ok(())
-    }
-}
-
-#[derive(Debug)]
-pub struct ErrorMessage {
-    code: ErrorCode,
-    message: String,
-}
-
-impl ErrorMessage {
-    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
-    where
-        R: Read + ?Sized,
-    {
-        let code = ErrorCode::decode(reader)?;
-        let message = decode_null_terminated(reader)?;
-
-        Ok(Self { code, message })
-    }
-
-    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
-    where
-        W: Write + ?Sized,
-    {
-        self.code.encode(writer)?;
-
-        encode_null_terminated(writer, &self.message)?;
-
-        Ok(())
-    }
-}
-
-#[derive(Debug)]
-pub enum Packet {
-    Read(Request),
-    Write(Request),
-    Data(Data),
-    Ack(Ack),
-    Error(ErrorMessage),
-}
-
-impl Packet {
-    pub fn data(block: u16, data: &[u8]) -> Self {
-        Self::Data(Data {
-            block,
-            data: data.into(),
-        })
-    }
-
-    pub fn ack(block: u16) -> Self {
-        Self::Ack(Ack(block))
-    }
-
-    pub fn error(code: ErrorCode, message: impl Into<String>) -> Self {
-        Self::Error(ErrorMessage {
-            code,
-            message: message.into(),
-        })
-    }
-
-    fn decode<R>(reader: &mut BufReader<R>) -> Result<Self, Error>
-    where
-        R: Read + ?Sized,
-    {
-        let op_code = reader.read_u16::<NetworkEndian>()?;
-
-        Ok(match op_code {
-            1 => Self::Read(Request::decode(reader)?),
-            2 => Self::Write(Request::decode(reader)?),
-            3 => Self::Data(Data::decode(reader)?),
-            4 => Self::Ack(Ack::decode(reader)?),
-            5 => Self::Error(ErrorMessage::decode(reader)?),
-            _ => return Err(Error::InvalidOpCode(op_code)),
-        })
-    }
-
-    fn encode<W>(&self, writer: &mut BufWriter<W>) -> Result<(), Error>
-    where
-        W: Write + ?Sized,
-    {
-        match &self {
-            Self::Read(inner) => {
-                writer.write_u16::<NetworkEndian>(1)?;
-                inner.encode(writer)?;
-            }
-            Self::Write(inner) => {
-                writer.write_u16::<NetworkEndian>(2)?;
-                inner.encode(writer)?;
-            }
-            Self::Data(inner) => {
-                writer.write_u16::<NetworkEndian>(3)?;
-                inner.encode(writer)?;
-            }
-            Self::Ack(inner) => {
-                writer.write_u16::<NetworkEndian>(4)?;
-                inner.encode(writer)?;
-            }
-            Self::Error(inner) => {
-                writer.write_u16::<NetworkEndian>(5)?;
-                inner.encode(writer)?;
-            }
-        };
-
-        Ok(())
-    }
-
-    pub async fn recv_from(socket: &UdpSocket) -> Result<(Self, SocketAddr), Error> {
-        let mut buf = [0u8; PACKET_SIZE];
-        let (_, src) = socket.recv_from(&mut buf).await?;
-
-        let packet = buf.try_into()?;
-
-        Ok((packet, src))
-    }
-
-    pub async fn send_to(&self, socket: &UdpSocket, src: &SocketAddr) -> Result<(), Error> {
-        let buf: Vec<_> = self.try_into()?;
-        socket.send_to(&buf, src).await?;
-
-        Ok(())
-    }
-}
-
-impl TryFrom<&Packet> for Vec<u8> {
-    type Error = Error;
-
-    fn try_from(packet: &Packet) -> Result<Self, Self::Error> {
-        let mut buf = Vec::with_capacity(PACKET_SIZE);
-        let mut writer = BufWriter::new(Cursor::new(&mut buf));
-        packet.encode(&mut writer)?;
-
-        // Normally the writer would get dropped after we return, but since it has a mutable
-        // borrow in buf we have to drop it first.
-        drop(writer);
-
-        Ok(buf)
-    }
-}
-
-impl TryFrom<[u8; PACKET_SIZE]> for Packet {
-    type Error = Error;
-
-    fn try_from(
-        buf: [u8; PACKET_SIZE],
-    ) -> Result<Self, <Packet as TryFrom<[u8; PACKET_SIZE]>>::Error> {
-        let mut reader = BufReader::new(Cursor::new(buf));
-
-        Packet::decode(&mut reader)
-    }
-}

src/tftp/server.rs

@@ -1,191 +0,0 @@
-use std::io;
-use std::net::{IpAddr, SocketAddr};
-use std::time::Duration;
-
-use socket_pktinfo::{PktInfo, PktInfoUdpSocket};
-use socket2::Domain;
-use thiserror::Error;
-use tokio::io::unix::{AsyncFd, AsyncFdRegisterError};
-use tokio::net::UdpSocket;
-
-use crate::tftp::packet::{ErrorCode, Mode, PACKET_SIZE};
-use crate::tftp::{self, Packet};
-
-#[derive(Debug, Error)]
-pub enum Error {
-    #[error("{0}")]
-    Tftp(#[from] tftp::Error),
-    #[error("Io error: {0}")]
-    Io(#[from] io::Error),
-    #[error("Unsupported operation: {0:#?}")]
-    UnsupportedOperation(Packet),
-    #[error("File not found: {0}")]
-    FileNotFound(String),
-    #[error("Unsupported mode: {0:?}")]
-    UnsupportedMode(Mode),
-    #[error("Source changed: {0}")]
-    SourceChanged(SocketAddr),
-    #[error("UnexpectedPacket: {0:#?}")]
-    UnexpectedPacket(Packet),
-    #[error("Timeout")]
-    Timeout,
-    #[error("AsyncFd: {0}")]
-    AsyncFd(#[from] AsyncFdRegisterError<PktInfoUdpSocket>),
-}
-
-pub async fn handle_connection<F, Fut>(
-    info: PktInfo,
-    packet: Packet,
-    callback: F,
-) -> Result<(), Error>
-where
-    F: Fn(String, IpAddr) -> Fut,
-    Fut: Future<Output = Option<Vec<u8>>>,
-{
-    let src = info.addr_src;
-    let socket = UdpSocket::bind((info.addr_dst, 0)).await?;
-    println!(
-        "{}: Connecting back from {}",
-        src,
-        socket.local_addr().expect("Local addr should be set")
-    );
-
-    let Packet::Read(request) = packet else {
-        Packet::error(ErrorCode::NotDefined, "Operation not supported")
-            .send_to(&socket, &info.addr_src)
-            .await?;
-
-        return Err(Error::UnsupportedOperation(packet));
-    };
-
-    let filename = request.filename();
-    println!("{src}: {filename} [{:?}]", request.mode());
-
-    let Some(data) = callback(filename.to_string(), info.addr_dst).await else {
-        Packet::error(ErrorCode::FileNotFound, "Unknown file")
-            .send_to(&socket, &src)
-            .await?;
-
-        return Err(Error::FileNotFound(filename.into()));
-    };
-
-    let mode = request.mode();
-    let data = match mode {
-        // In case of netascii mode we need to re-encode to escape certain sequences
-        Mode::NetAscii => netascii::Netascii::from_bytes(data).collect(),
-        Mode::Octet => data,
-        _ => {
-            Packet::error(
-                ErrorCode::NotDefined,
-                format!("Mode {mode:?} is not supported"),
-            )
-            .send_to(&socket, &src)
-            .await?;
-
-            return Err(Error::UnsupportedMode(mode));
-        }
-    };
-
-    let mut chunks = data.chunks(512).enumerate();
-    let mut chunk = chunks.next();
-
-    let mut timeout = 0;
-
-    loop {
-        // Send the first chunk
-        if let Some((index, chunk)) = chunk {
-            Packet::data((index + 1) as u16, chunk)
-                .send_to(&socket, &src)
-                .await?;
-        }
-
-        tokio::select! {
-            recv = Packet::recv_from(&socket) => {
-                timeout = 0;
-                let (packet, new_src) = recv?;
-
-                // I think this is might technically be possible and fine, but I don't
-                // really know how to test it properly so we don't support it.
-                if new_src != src {
-                    Packet::error(ErrorCode::Illegal, "Source changed")
-                        .send_to(&socket, &src)
-                        .await?;
-
-                    return Err(Error::SourceChanged(new_src));
-                }
-
-                match packet {
-                    Packet::Ack(ack) => {
-                        // If we receive an ack for the current chunk go to the next one
-                        if let Some((index, _)) = chunk
-                            && (index + 1) as u16 == ack.block()
-                        {
-                            chunk = chunks.next();
-                        }
-
-                        if chunk.is_none() {
-                            break;
-                        }
-                    }
-                    _ => {
-                        Packet::error(ErrorCode::Illegal, "Unexpected packet")
-                            .send_to(&socket, &src)
-                            .await?;
-
-
-                        return Err(Error::UnexpectedPacket(packet));
-                    }
-                }
-            },
-            _ = tokio::time::sleep(Duration::from_secs(1)) => {
-                timeout += 1;
-
-                if timeout == 5 {
-                    return Err(Error::Timeout);
-                }
-            }
-        }
-    }
-
-    println!("{src}: Transmission complete");
-
-    Ok(())
-}
-
-pub async fn serve<F, Fut>(ip: IpAddr, callback: F) -> Result<!, Error>
-where
-    F: Fn(String, IpAddr) -> Fut + Clone + Send + 'static,
-    Fut: Future<Output = Option<Vec<u8>>> + Send + 'static,
-{
-    let socket = PktInfoUdpSocket::new(Domain::IPV4)?;
-    socket.set_nonblocking(true)?;
-
-    let addr: SocketAddr = (ip, 69).into();
-    socket.bind(&addr.into())?;
-
-    let async_fd = unsafe { AsyncFd::register(socket)? };
-
-    let mut buf = [0u8; PACKET_SIZE];
-
-    println!("Tftp server started on {addr}");
-    loop {
-        let mut guard = async_fd.readable().await?;
-
-        let (packet, info) = match guard.try_io(|inner| inner.get_ref().recv(&mut buf)) {
-            Ok(Ok((_, info))) => (buf.try_into()?, info),
-            Ok(Err(e)) => return Err(e)?,
-            // Socket was not ready
-            Err(_would_block) => continue,
-        };
-
-        let callback = callback.clone();
-        let src = info.addr_src;
-        tokio::spawn({
-            async move {
-                if let Err(err) = handle_connection(info, packet, callback).await {
-                    println!("{src}: {err}")
-                }
-            }
-        });
-    }
-}

typos.toml

@@ -1,2 +0,0 @@
-[default.extend-words]
-rela = "rela"

xtask/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-repo_path = "1.4.1"
+repo_path = "1.2.4"
 schemars = { workspace = true }
 serde_json = { workspace = true }
 crete = { path = ".." }