checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"

[[package]]

name = "bitflags"

version = "2.10.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"

[[package]]

name = "futures-channel"

version = "0.3.31"

source = "registry+https://github.com/rust-lang/crates.io-index"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"

dependencies = [

"futures-core",

"futures-io",

"futures-macro",

]

[[package]]

name = "prost"

version = "0.14.3"

source = "registry+https://github.com/rust-lang/crates.io-index"

]

[[package]]

name = "quote"

version = "1.0.43"

source = "registry+https://github.com/rust-lang/crates.io-index"

]

[[package]]

name = "raw-cpuid"

version = "11.6.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"

[[package]]

name = "ryu"

version = "1.0.22"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"

[[package]]

name = "unicase"

version = "2.9.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"

[[package]]

name = "walkdir"

version = "2.5.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

name = "zorian"

version = "0.1.0"

dependencies = [

"axum",

"axum-extra",

"axum-server",

"cargo-deny",

"chrono",

"crc32fast",

"hex",

"http-body-util",

"hyper",

"opentelemetry-otlp",

"opentelemetry-semantic-conventions",

"opentelemetry_sdk",

"rust-embed",

"rustls",

"sd-notify",

"semver",

"serde",

"sqlx",

"tempfile",

"thiserror 2.0.17",

"tokio",

"toml",

"tonic",

"tower",

repository = "https://github.com/mrdimidium/Zorian"

[dependencies]

axum = { version = "0.8", features = ["http2", "macros", "multipart"] }

axum-extra = "0.12"

axum-server = { version = "0.8", features = ["tls-rustls-no-provider"] }

bytesize = { version = "2.3", features = ["serde"] }

chrono = { version = "0.4", features = ["serde"] }

crc32fast = "1.5"

hex = "0.4"

http-body-util = "0.1"

hyper = "1.8"

] }

semver = "1.0"

serde = { version = "1.0", features = ["derive"] }

sqlx = { version = "0.8", features = [

"sqlite",

"runtime-tokio",

] }

thiserror = "2.0"

tokio = { version = "1.49", features = ["full"] }

toml = "0.9"

tonic = "0.14"

tower = { version = "0.5", features = ["full"] }

tower-http = { version = "0.6", features = ["full"] }

tower_governor = { version = "0.8", features = ["axum", "tracing"] }

uuid = { version = "1.19", features = ["v4", "v5"] }

# telemetry

[dev-dependencies]

cargo-deny = "0.19"

tempfile = "3.24"

body {

margin: 0 auto;

padding: 1.5em 2em;

}

}

h1, h2, h3, h4, h5, h6 {

font-weight: 700;

line-height: 1.2;

text-wrap: balance;

}

h1 {

margin-top: 0;

}

text-wrap: pretty;

}

text-align: start;

}

h3 a {

// SPDX-FileCopyrightText: 2026 Nikolay Govorov <me@govorov.online>

// SPDX-License-Identifier: AGPL-3.0-or-later

use thiserror::Error;

#[derive(Debug, Clone, Deserialize)]

#[serde(default)]

pub struct GoConfig {

pub enabled: bool,

}

impl Default for GoConfig {

fn default() -> Self {

Self {

enabled: true,

}

}

}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

enum ReleaseType {

Stable,

}

#[derive(Debug, Clone, PartialEq, Eq, Error)]

#[derive(Debug, Clone, PartialEq, Eq)]

struct GoVersion {

release_type: ReleaseType,

}

/// Describes a single file stored at `dl.google.com/go/`.

#[derive(Debug, Clone, PartialEq, Eq)]

filename: &'a str,

version: GoVersion,

archive: Archive,

sha256: bool,

}

pub fn parse(filename: &'a str) -> Result<Self, ParseError> {

let mut buffer = filename;

let mut sha256 = false;

}

// Split by dots: "1.25.6.linux-amd64" -> ["1", "25", "6", "linux-amd64"]

let parts: Vec<&str> = buffer.split('.').collect();

if parts.len() < 3 {

return Err(ParseError);

}

} else if let Some((os, arch)) = remainder.split_once('-') {

} else {

return Err(ParseError);

};

filename,

archive,

sha256,

})

}

/// Builds the upstream URL for this tarball.

}

}

#[cfg(test)]

use super::*;

#[test]

fn test_parse_stable_binary() {

assert_eq!(t.version.major, 1);

assert_eq!(t.version.minor, 25);

assert_eq!(t.version.patch, Some(6));

assert!(matches!(t.version.release_type, ReleaseType::Stable));

assert_eq!(t.archive, Archive::TarGz);

assert!(!t.sha256);

}

#[test]

fn test_parse_first_minor_release() {

assert_eq!(t.version.major, 1);

assert_eq!(t.version.minor, 25);

assert_eq!(t.version.patch, None);

#[test]

fn test_parse_rc() {

assert_eq!(t.version.major, 1);

assert_eq!(t.version.minor, 26);

assert_eq!(t.version.patch, None);

#[test]

fn test_parse_beta() {

assert_eq!(t.version.major, 1);

assert_eq!(t.version.minor, 26);

assert!(matches!(t.version.release_type, ReleaseType::Beta(1)));

#[test]

fn test_parse_source() {

assert_eq!(t.version.patch, Some(6));

}

#[test]

fn test_parse_windows_zip() {

assert_eq!(t.archive, Archive::Zip);

}

#[test]

fn test_parse_msi() {

assert_eq!(t.archive, Archive::Msi);

}

#[test]

fn test_parse_pkg() {

assert_eq!(t.archive, Archive::Pkg);

}

#[test]

fn test_parse_sha256() {

assert!(t.sha256);

assert_eq!(t.archive, Archive::TarGz);

assert_eq!(t.version.patch, Some(6));

#[test]

fn test_upstream_url() {

assert_eq!(

);

}

#[test]

fn test_invalid_prefix() {

}

#[test]

fn test_invalid_extension() {

}

}

pub mod go;

pub mod zig;

pub use go::{GoBackend, GoConfig};

pub use zig::{ZigBackend, ZigConfig};

pub trait Backend: Send + Sync + 'static {

/// Fixed unique identifier for storage

const ID: &'static str;

}

// SPDX-FileCopyrightText: 2026 Nikolay Govorov <me@govorov.online>

// SPDX-License-Identifier: AGPL-3.0-or-later

use thiserror::Error;

#[derive(Debug, Clone, Deserialize)]

#[serde(default)]

pub struct ZigConfig {

pub enabled: bool,

}

impl Default for ZigConfig {

fn default() -> Self {

Self {

enabled: true,

}

}

}

}

}

}

}

#[derive(Debug, Clone, PartialEq, Eq, Error)]

#[error("invalid tarball filename")]

struct ParseError;

/// we standardize the files, but for the reverse operation

/// (getting a string from a tarball), we preserve the original path.

#[derive(Debug, Clone, PartialEq, Eq)]

filename: &'a str,

minisig: bool,

archive: Archive,

development: bool,

}

pub fn parse(filename: &'a str) -> Result<Self, ParseError> {

let mut buffer = filename;

let mut minisig = false;

let archive;

// (?:|-bootstrap|-[a-zA-Z0-9_]+-[a-zA-Z0-9_]+)-(

// \d+\.\d+\.\d+(?:-dev\.\d+\+[0-9a-f]+)?

let development = last.starts_with("dev");

let version = if !development {

} else {

let semver = it.next().ok_or(ParseError)?;

let devver = last;

let version_str = format!("{}-{}", semver, devver);

};

if payload == "bootstrap" {

} else {

// Version 0.14.0 is the last one to use the OS-ARCH format in names; newer versions use ARCH-OS.

} else {

}

} else {

if it.next().is_some() {

return Err(ParseError);

}

filename,

minisig,

archive,

version,

}

/// Builds the upstream URL for this tarball.

}

}

}

use thiserror::Error;

use crate::backends::{GoConfig, ZigConfig};

#[derive(Debug, Error)]

pub enum ConfigError {

/// Rate limit: burst size (max requests allowed in a burst) per client IP

pub rate_limit_burst_size: u32,

}

impl Default for ServerConfig {

fn default() -> Self {

Self {

/// Path to TLS private key file (PEM format). If set, tls_crt must also be set.

pub tls_key: Option<PathBuf>,

}

impl Default for ListenerConfig {

fn default() -> Self {

Self {

/// HTTP headers for authentication

pub headers: HashMap<String, String>,

}

impl Default for OtelcolConfig {

fn default() -> Self {

Self {

use axum::{Router, body, extract, http, response, routing};

use tracing::error;

use crate::proxy;

use crate::storage;

/// Generic controller for backend HTTP handling.

pub struct BackendController<B: Backend> {

storage: Arc<storage::StorageService>,

upstream: Arc<proxy::ProxyService>,

}

impl<B: Backend> BackendController<B> {

pub fn new(

storage: Arc<storage::StorageService>,

upstream: Arc<proxy::ProxyService>,

) -> Self {

extract::State(controller): extract::State<Arc<Self>>,

extract::Path(filename): extract::Path<String>,

) -> Result<response::Response, http::StatusCode> {

return Err(http::StatusCode::NOT_FOUND);

}

};

match controller.storage.get(B::ID, &filename).await {

.body(body::Body::from(bytes))

.unwrap()

}

}

use axum::http::{HeaderValue, Method, Request, Response, StatusCode, header};

use axum::{extract, routing};

use chrono::{DateTime, Utc};

use rust_embed::Embed;

use sqlx::types::chrono;

use tower::{Layer, Service};

use tracing::error;

#[derive(Embed)]

#[folder = "src/assets/"]

struct Assets;

const CSP: &str = "default-src 'self'; base-uri 'none'; img-src 'self'; font-src 'self'; style-src 'self'; script-src 'self'; object-src 'none'; frame-ancestors 'none'";

/// Handles html pages rendering and static files

impl WebController {

pub fn router(self: Arc<Self>) -> axum::Router {

.layer(tower_http::set_header::SetResponseHeaderLayer::overriding(

header::CACHE_CONTROL,

HeaderValue::from_static("no-cache"),

let assets = axum::Router::new().route("/assets/{*path}", routing::get(Self::assets));

header::CONTENT_SECURITY_POLICY,

HeaderValue::from_static(CSP),

))

}

async fn assets(extract::Path(path): extract::Path<String>) -> Response<Body> {

}

}

html! {

(maud::DOCTYPE)

a href="#zig" { "Zig" }

}

p {

"Read more about community mirrors in the " a href="https://ziglang.org/download/community-mirrors/" { "blog post" } ". "

"Information on how to deploy your own mirror is available " a href="https://github.com/ziglang/www.ziglang.org/blob/main/MIRRORS.md" { "in the documentation" } "."

li { "unpack archive:" br; code { "tar -xf 'zig-x86_64-linux-0.15.1.tar.xz'" } ";" }

li { "check installed zig:" br; code { "./zig-x86_64-linux-0.15.1/zig --version" } ";" }

}

}

h3 id="go" { a href="#go" { "Go" } }

li { "download go dist file:" br; code { "wget https://pkg.earth/go/go1.23.0.linux-amd64.tar.gz" } ";" }

li { "download go sha256 file:" br; code { "wget https://pkg.earth/go/go1.23.0.linux-amd64.tar.gz.sha256" } ";" }

li { "check archive integrity:" br; code { "sha256sum -c go1.23.0.linux-amd64.tar.gz.sha256" } ";" }

li { "unpack archive:" br; code { "tar -xzf go1.23.0.linux-amd64.tar.gz" } ";" }

li { "check installed go:" br; code { "./go/bin/go version" } ";" }

}

h2 { "Privacy policy" }

mod proxy;

mod storage;

mod telemetry;

mod controller_backend;

mod controller_web;

use tracing::{error, info, trace};

use tracing_subscriber::registry::LookupSpan;

use crate::controller_backend::BackendController;

use crate::controller_web::WebController;

const VERSION: &str = env!("CARGO_PKG_VERSION");

const HELP: &str = "\

Usage: zorian [--config=<path>]

let storage = Arc::new(storage::StorageService::new(config.clone()).await.unwrap());

let upstream = Arc::new(proxy::ProxyService::new());

let source = format!("zorian:{}", config.appname());

let backends = config.backends();

const REQUEST_ID_HEADER: http::HeaderName = http::HeaderName::from_static("x-request-id");

let trace_layer = tower_http::trace::TraceLayer::new_for_http()

.finish()

.unwrap();

let mut app = axum::Router::new().merge(web_controller.router());

let ctrl = Arc::new(BackendController::new(

storage.clone(),

upstream.clone(),

));

app = app.nest("/zig", ctrl.router());

}

let ctrl = Arc::new(BackendController::new(

storage.clone(),

upstream.clone(),

));

);

}

#[cfg(target_os = "linux")]

if sd_notify::booted().unwrap_or(false) {

#[cfg(target_os = "linux")]

sd_notify::notify(false, &[NotifyState::Stopping]).ok();

handle.graceful_shutdown(None);

let shutdown_result = tokio::time::timeout(config.server().shutdown_timeout, async {

while let Some(result) = tasks.join_next().await {

if let Err(e) = result {

error!("listener task failed: {e}");

}

}

})

.await;

if shutdown_result.is_err() {

error!(

config.server().shutdown_timeout,

);

tasks.abort_all();

} else {

info!("shutdown complete");

}

use hyper_tls::HttpsConnector;

use hyper_util::client::legacy::{Client, connect::HttpConnector};

use hyper_util::rt::TokioExecutor;

#[derive(Clone)]

pub struct DownloadRequest {

}

#[derive(Clone)]

pub async fn fetch(&self, request: DownloadRequest) -> Result<File, http::StatusCode> {

let request = Request::builder()

.method(http::Method::GET)

.header(http::header::USER_AGENT, "zorian/0.1")

.body(Empty::<Bytes>::new())

.unwrap();

Ok(storage)

}

/// Synchronously traverses the tree and removes temporary files.

/// Must run before the application starts.

async fn doctor(&self) -> Result<(), StorageError> {