Milestone 0.6: releases, Git mirror, code search, anchored API comments 3f4b0ea6eabf

-- Releases attach notes and assets to tags (hub spec §9). Tags themselves

-- live in the repository; assets are content addressed under <data>/assets.

CREATE TABLE releases (

    id          INTEGER PRIMARY KEY,

    repo_id     INTEGER NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,

    tag         TEXT NOT NULL,

    title       TEXT NOT NULL,

    notes       TEXT NOT NULL DEFAULT '',

    prerelease  INTEGER NOT NULL DEFAULT 0,

    author_id   INTEGER REFERENCES accounts(id) ON DELETE SET NULL,

    author      TEXT NOT NULL DEFAULT '',

    created_ms  INTEGER NOT NULL,

    UNIQUE (repo_id, tag)

);

CREATE TABLE release_assets (

    id           INTEGER PRIMARY KEY,

    release_id   INTEGER NOT NULL REFERENCES releases(id) ON DELETE CASCADE,

    name         TEXT NOT NULL,

    size         INTEGER NOT NULL,

    hash         TEXT NOT NULL,

    content_type TEXT NOT NULL DEFAULT 'application/octet-stream',

    downloads    INTEGER NOT NULL DEFAULT 0,

    created_ms   INTEGER NOT NULL,

    UNIQUE (release_id, name)

);

-- Git mirror settings per repository (hub spec §14).

ALTER TABLE repositories ADD COLUMN git_mirror INTEGER NOT NULL DEFAULT 0;

ALTER TABLE repositories ADD COLUMN git_mirror_state TEXT NOT NULL DEFAULT '';

//! Releases and their assets (hub spec §9).

use super::{now_ms, Pool};

use sqlx::FromRow;

#[derive(Clone, Debug, FromRow)]

pub struct Release {

    pub id: i64,

    pub repo_id: i64,

    pub tag: String,

    pub title: String,

    pub notes: String,

    pub prerelease: bool,

    pub author_id: Option<i64>,

    pub author: String,

    pub created_ms: i64,

}

#[derive(Clone, Debug, FromRow)]

pub struct Asset {

    pub id: i64,

    pub release_id: i64,

    pub name: String,

    pub size: i64,

    pub hash: String,

    pub content_type: String,

    pub downloads: i64,

    pub created_ms: i64,

}

pub async fn list(pool: &Pool, repo_id: i64) -> sqlx::Result<Vec<Release>> {

    sqlx::query_as("SELECT * FROM releases WHERE repo_id = ? ORDER BY created_ms DESC, id DESC").bind(repo_id).fetch_all(pool).await

}

pub async fn get(pool: &Pool, repo_id: i64, tag: &str) -> sqlx::Result<Option<Release>> {

    sqlx::query_as("SELECT * FROM releases WHERE repo_id = ? AND tag = ?").bind(repo_id).bind(tag).fetch_optional(pool).await

}

/// The newest release that is not a pre-release: the "latest" marker.

pub async fn latest(pool: &Pool, repo_id: i64) -> sqlx::Result<Option<Release>> {

    sqlx::query_as("SELECT * FROM releases WHERE repo_id = ? AND prerelease = 0 ORDER BY created_ms DESC, id DESC LIMIT 1")

        .bind(repo_id)

        .fetch_optional(pool)

        .await

}

pub async fn create(

    pool: &Pool,

    repo_id: i64,

    tag: &str,

    title: &str,

    notes: &str,

    prerelease: bool,

    author: Option<(i64, &str)>,

) -> sqlx::Result<Release> {

    sqlx::query_as("INSERT INTO releases (repo_id, tag, title, notes, prerelease, author_id, author, created_ms) VALUES (?, ?, ?, ?, ?, ?, ?, ?) RETURNING *")

        .bind(repo_id)

        .bind(tag)

        .bind(title)

        .bind(notes)

        .bind(prerelease)

        .bind(author.map(|a| a.0))

        .bind(author.map(|a| a.1).unwrap_or(""))

        .bind(now_ms())

        .fetch_one(pool)

        .await

}

pub async fn edit(pool: &Pool, id: i64, title: &str, notes: &str, prerelease: bool) -> sqlx::Result<()> {

    sqlx::query("UPDATE releases SET title = ?, notes = ?, prerelease = ? WHERE id = ?")

        .bind(title)

        .bind(notes)

        .bind(prerelease)

        .bind(id)

        .execute(pool)

        .await?;

    Ok(())

}

pub async fn delete(pool: &Pool, id: i64) -> sqlx::Result<()> {

    sqlx::query("DELETE FROM releases WHERE id = ?").bind(id).execute(pool).await?;

    Ok(())

}

pub async fn assets(pool: &Pool, release_id: i64) -> sqlx::Result<Vec<Asset>> {

    sqlx::query_as("SELECT * FROM release_assets WHERE release_id = ? ORDER BY name").bind(release_id).fetch_all(pool).await

}

pub async fn asset(pool: &Pool, release_id: i64, name: &str) -> sqlx::Result<Option<Asset>> {

    sqlx::query_as("SELECT * FROM release_assets WHERE release_id = ? AND name = ?").bind(release_id).bind(name).fetch_optional(pool).await

}

pub async fn add_asset(pool: &Pool, release_id: i64, name: &str, size: i64, hash: &str, content_type: &str) -> sqlx::Result<Asset> {

    sqlx::query_as(

        "INSERT INTO release_assets (release_id, name, size, hash, content_type, created_ms) VALUES (?, ?, ?, ?, ?, ?) \

         ON CONFLICT (release_id, name) DO UPDATE SET size = excluded.size, hash = excluded.hash, content_type = excluded.content_type, created_ms = excluded.created_ms RETURNING *",

    )

    .bind(release_id)

    .bind(name)

    .bind(size)

    .bind(hash)

    .bind(content_type)

    .bind(now_ms())

    .fetch_one(pool)

    .await

}

pub async fn delete_asset(pool: &Pool, id: i64) -> sqlx::Result<()> {

    sqlx::query("DELETE FROM release_assets WHERE id = ?").bind(id).execute(pool).await?;

    Ok(())

}

pub async fn count_download(pool: &Pool, id: i64) -> sqlx::Result<()> {

    sqlx::query("UPDATE release_assets SET downloads = downloads + 1 WHERE id = ?").bind(id).execute(pool).await?;

    Ok(())

}

/// Whether any asset of any release still names this content.

pub async fn hash_in_use(pool: &Pool, hash: &str) -> sqlx::Result<bool> {

    let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM release_assets WHERE hash = ?").bind(hash).fetch_one(pool).await?;

    Ok(n > 0)

}

//! The read-only Git mirror (hub spec §14): the default bookmark exported

//! with oxy's own `git export` into `<data>/mirrors/<owner>/<name>.git`

//! after every update, and served over Git's smart HTTP by `git

//! http-backend` behind the hub's access checks. Pushing to it is refused.

use crate::auth::{self, Access};

use crate::db::{self, repos::RepoRow};

use crate::repos::RepoName;

use crate::Shared;

use axum::body::Bytes;

use axum::extract::{Path, RawQuery, State};

use axum::http::{header, HeaderMap, Method, StatusCode};

use axum::response::{IntoResponse, Response};

use std::path::PathBuf;

use tokio::io::AsyncWriteExt;

pub fn mirror_dir(app: &Shared, repo: &RepoName) -> PathBuf {

    app.config.data.join("mirrors").join(&repo.owner).join(format!("{}.git", repo.name))

}

/// Export the default bookmark into the mirror, if the mirror is on.

pub async fn refresh(app: &Shared, row: &RepoRow) {

    if !row.git_mirror {

        return;

    }

    let Some(repo) = RepoName::new(&row.owner, &row.name) else { return };

    let dir = mirror_dir(app, &repo);

    let bookmark = row.default_bookmark.clone();

    let result = app

        .repos

        .write(&repo, move |r, _| {

            let mut r = oxy_core::repo::Repo::open(r.root())?;

            r.config.bookmark = bookmark.clone();

            let report = r.git_export_as(&dir, &bookmark)?;

            // Point HEAD at the exported branch so clones check it out.

            std::fs::write(dir.join("HEAD"), format!("ref: refs/heads/{bookmark}\n"))?;

            let state = r.view()?.bookmarks.get(&bookmark).map(|s| s.to_hex()).unwrap_or_default();

            Ok((report.exported, state))

        })

        .await;

    match result {

        Ok((_, state)) => {

            db::repos::set_git_mirror_state(&app.db, row.id, &state).await.ok();

        }

        Err(e) => tracing::warn!("git mirror of {}: {e}", row.slug()),

    }

}

/// Who a Git client is: HTTP Basic with a personal access token as the

/// password (any user name), or anonymous.

async fn git_caller(app: &Shared, headers: &HeaderMap) -> Result<Option<db::accounts::Account>, StatusCode> {

    let Some(v) = headers.get(header::AUTHORIZATION).and_then(|v| v.to_str().ok()) else { return Ok(None) };

    let token = if let Some(b) = v.strip_prefix("Basic ") {

        let decoded = base64_decode(b.trim()).ok_or(StatusCode::UNAUTHORIZED)?;

        let s = String::from_utf8(decoded).map_err(|_| StatusCode::UNAUTHORIZED)?;

        s.split_once(':').map(|(_, p)| p.to_string()).ok_or(StatusCode::UNAUTHORIZED)?

    } else if let Some(t) = v.strip_prefix("Bearer ") {

        t.trim().to_string()

    } else {

        return Err(StatusCode::UNAUTHORIZED);

    };

    let tok = db::accounts::token_by_hash(&app.db, &auth::token_hash(&token)).await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    match tok {

        Some(t) if !t.expired(db::now_ms()) && (t.has_scope("repo:read") || t.has_scope("repo:write") || t.has_scope("repo:admin")) => {

            db::accounts::account_by_id(&app.db, t.account_id).await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)

        }

        _ => Err(StatusCode::UNAUTHORIZED),

    }

}

fn base64_decode(s: &str) -> Option<Vec<u8>> {

    const T: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    let mut out = Vec::new();

    let mut buf = 0u32;

    let mut bits = 0;

    for c in s.bytes().filter(|c| *c != b'=') {

        let v = T.iter().position(|x| *x == c)? as u32;

        buf = (buf << 6) | v;

        bits += 6;

        if bits >= 8 {

            bits -= 8;

            out.push((buf >> bits) as u8);

            buf &= (1 << bits) - 1;

        }

    }

    Some(out)

}

fn challenge() -> Response {

    (StatusCode::UNAUTHORIZED, [(header::WWW_AUTHENTICATE, "Basic realm=\"Oxygenhub\"")], "authentication required").into_response()

}

/// Every smart-HTTP path under `/{owner}/{name}.git/`.

pub async fn serve(

    State(app): State<Shared>,

    Path((owner, name_git, rest)): Path<(String, String, String)>,

    method: Method,

    RawQuery(query): RawQuery,

    headers: HeaderMap,

    body: Bytes,

) -> Response {

    let Some(name) = name_git.strip_suffix(".git") else { return StatusCode::NOT_FOUND.into_response() };

    let Some(repo) = RepoName::new(&owner, name) else { return StatusCode::NOT_FOUND.into_response() };

    let query = query.unwrap_or_default();

    if rest.contains("git-receive-pack") || query.contains("git-receive-pack") {

        return (StatusCode::FORBIDDEN, "This is a read-only Git mirror of an Oxygen repository; push with oxy instead.").into_response();

    }

    let row = match db::repos::get(&app.db, &owner, name).await {

        Ok(Some(r)) if r.git_mirror => r,

        _ => return StatusCode::NOT_FOUND.into_response(),

    };

    let account = match git_caller(&app, &headers).await {

        Ok(a) => a,

        Err(_) => return challenge(),

    };

    let role = auth::roles::role_for(&app.db, account.as_ref(), &row).await.ok().flatten();

    if !auth::roles::allows(role, Access::Read) {

        return if account.is_none() { challenge() } else { StatusCode::NOT_FOUND.into_response() };

    }

    let dir = mirror_dir(&app, &repo);

    if !dir.join("HEAD").exists() {

        refresh(&app, &row).await;

    }

    let root = app.config.data.join("mirrors");

    let git = std::env::var("OXYHUB_GIT").unwrap_or_else(|_| "git".into());

    let mut cmd = tokio::process::Command::new(git);

    cmd.arg("http-backend")

        .env_clear()

        .env("PATH", std::env::var("PATH").unwrap_or_default())

        .env("GIT_PROJECT_ROOT", &root)

        .env("GIT_HTTP_EXPORT_ALL", "1")

        .env("PATH_INFO", format!("/{owner}/{name_git}/{rest}"))

        .env("REQUEST_METHOD", method.as_str())

        .env("QUERY_STRING", &query)

        .env("CONTENT_TYPE", headers.get(header::CONTENT_TYPE).and_then(|v| v.to_str().ok()).unwrap_or(""))

        .env("CONTENT_LENGTH", body.len().to_string())

        .env("GIT_CONFIG_NOSYSTEM", "1")

        .env("HOME", &root)

        .stdin(std::process::Stdio::piped())

        .stdout(std::process::Stdio::piped())

        .stderr(std::process::Stdio::piped());

    if let Some(enc) = headers.get(header::CONTENT_ENCODING).and_then(|v| v.to_str().ok()) {

        cmd.env("HTTP_CONTENT_ENCODING", enc);

    }

    if let Some(p) = headers.get("git-protocol").and_then(|v| v.to_str().ok()) {

        cmd.env("GIT_PROTOCOL", p);

    }

    let mut child = match cmd.spawn() {

        Ok(c) => c,

        Err(e) => return (StatusCode::INTERNAL_SERVER_ERROR, format!("git http-backend: {e}")).into_response(),

    };

    if let Some(mut stdin) = child.stdin.take() {

        let _ = stdin.write_all(&body).await;

    }

    let out = match child.wait_with_output().await {

        Ok(o) => o,

        Err(e) => return (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()).into_response(),

    };

    cgi_response(&out.stdout)

}

/// Turn CGI output (headers, blank line, body) into a response.

fn cgi_response(raw: &[u8]) -> Response {

    let split =

        raw.windows(4).position(|w| w == b"\r\n\r\n").map(|i| (i, 4)).or_else(|| raw.windows(2).position(|w| w == b"\n\n").map(|i| (i, 2)));

    let Some((at, sep)) = split else { return (StatusCode::BAD_GATEWAY, "malformed CGI output").into_response() };

    let head = String::from_utf8_lossy(&raw[..at]);

    let body = raw[at + sep..].to_vec();

    let mut status = StatusCode::OK;

    let mut builder = Response::builder();

    for line in head.lines() {

        let Some((k, v)) = line.split_once(':') else { continue };

        let (k, v) = (k.trim(), v.trim());

        if k.eq_ignore_ascii_case("status") {

            if let Some(code) = v.split_whitespace().next().and_then(|c| c.parse::<u16>().ok()) {

                status = StatusCode::from_u16(code).unwrap_or(StatusCode::OK);

            }

        } else {

            builder = builder.header(k, v);

        }

    }

    builder.status(status).body(axum::body::Body::from(body)).unwrap_or_else(|_| StatusCode::BAD_GATEWAY.into_response())

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn base64_and_cgi() {

        assert_eq!(base64_decode("dXNlcjpzM2NyZXQ=").unwrap(), b"user:s3cret");

        let r = cgi_response(b"Status: 404 Not Found\r\nContent-Type: text/plain\r\n\r\nnope");

        assert_eq!(r.status(), StatusCode::NOT_FOUND);

    }

}

//! Source archives of a state (hub spec §9): `.tar.zst` and `.zip` of the

//! materialised tree, cached by state hash since a state never changes.

use super::cache::Loaded;

use oxy_core::objects::NodeKind;

use oxy_core::repo::Repo;

use oxy_core::state::FileContent;

use std::io::Write;

use std::path::{Path, PathBuf};

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

pub enum Format {

    TarZst,

    Zip,

}

impl Format {

    pub fn parse(ext: &str) -> Option<Format> {

        match ext {

            "tar.zst" => Some(Format::TarZst),

            "zip" => Some(Format::Zip),

            _ => None,

        }

    }

    pub fn ext(self) -> &'static str {

        match self {

            Format::TarZst => "tar.zst",

            Format::Zip => "zip",

        }

    }

    pub fn mime(self) -> &'static str {

        match self {

            Format::TarZst => "application/zstd",

            Format::Zip => "application/zip",

        }

    }

}

/// One archive member: path, bytes, executable, symlink.

type Member = (String, Vec<u8>, bool, bool);

/// Every regular file and symlink of the state.

fn entries(repo: &Repo, loaded: &Loaded) -> anyhow::Result<Vec<Member>> {

    let mut out = Vec::new();

    for (path, f) in &loaded.snapshot.files {

        let bytes = match (&f.kind, &f.content) {

            (NodeKind::Dir, _) | (_, FileContent::Dir) => continue,

            (_, FileContent::Text { bytes, .. }) => bytes.clone(),

            (_, FileContent::Opaque { blobs }) => match blobs.first() {

                Some(b) => repo.read_blob(b)?,

                None => vec![],

            },

        };

        out.push((path.clone(), bytes, f.mode.exec, f.kind == NodeKind::Symlink));

    }

    Ok(out)

}

/// Write the archive of `loaded` under `prefix/` to `dest` (atomically).

pub fn build(repo: &Repo, loaded: &Loaded, prefix: &str, format: Format, dest: &Path) -> anyhow::Result<()> {

    if let Some(dir) = dest.parent() {

        std::fs::create_dir_all(dir)?;

    }

    let tmp = dest.with_extension("partial");

    let files = entries(repo, loaded)?;

    match format {

        Format::TarZst => {

            let out = std::fs::File::create(&tmp)?;

            let enc = zstd::Encoder::new(out, 19)?;

            let mut tar = tar::Builder::new(enc);

            for (path, bytes, exec, symlink) in &files {

                let name = format!("{prefix}/{path}");

                let mut h = tar::Header::new_gnu();

                h.set_mtime(0);

                if *symlink {

                    h.set_entry_type(tar::EntryType::Symlink);

                    h.set_size(0);

                    h.set_mode(0o777);

                    tar.append_link(&mut h, &name, String::from_utf8_lossy(bytes).as_ref())?;

                } else {

                    h.set_size(bytes.len() as u64);

                    h.set_mode(if *exec { 0o755 } else { 0o644 });

                    tar.append_data(&mut h, &name, bytes.as_slice())?;

                }

            }

            tar.into_inner()?.finish()?.flush()?;

        }

        Format::Zip => {

            let out = std::fs::File::create(&tmp)?;

            let mut zip = zip::ZipWriter::new(out);

            for (path, bytes, exec, symlink) in &files {

                let name = format!("{prefix}/{path}");

                let opts = zip::write::SimpleFileOptions::default()

                    .compression_method(zip::CompressionMethod::Deflated)

                    .unix_permissions(if *exec { 0o755 } else { 0o644 });

                if *symlink {

                    zip.add_symlink(name, String::from_utf8_lossy(bytes).as_ref(), opts)?;

                } else {

                    zip.start_file(name, opts)?;

                    zip.write_all(bytes)?;

                }

            }

            zip.finish()?.flush()?;

        }

    }

    std::fs::rename(&tmp, dest)?;

    Ok(())

}

/// Where the cached archive of a state lives.

pub fn cache_path(data: &Path, state: &str, prefix: &str, format: Format) -> PathBuf {

    data.join("cache").join("archives").join(format!("{state}-{prefix}.{}", format.ext()))

}

//! Code search (hub spec §11): substring or regular expression over the

//! text files of one state, with a time budget and a result cap. Results

//! are cached by state hash and query, since a state never changes.

use super::cache::Loaded;

use oxy_core::state::FileContent;

use std::collections::HashMap;

use std::sync::Mutex;

use std::time::{Duration, Instant};

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

pub struct Hit {

    pub path: String,

    /// 1-based; 0 for a match on the path itself.

    pub line: usize,

    pub text: String,

}

#[derive(Clone, Debug, Default)]

pub struct Results {

    pub hits: Vec<Hit>,

    pub files: usize,

    /// The budget or the cap stopped the search early.

    pub truncated: bool,

}

pub struct Query<'a> {

    pub text: &'a str,

    pub regex: bool,

    pub case_sensitive: bool,

    /// Only paths starting with this.

    pub path_prefix: &'a str,

}

pub const MAX_HITS: usize = 300;

pub const BUDGET: Duration = Duration::from_secs(2);

pub fn run(loaded: &Loaded, q: &Query<'_>) -> Result<Results, String> {

    let pattern = if q.regex { q.text.to_string() } else { regex::escape(q.text) };

    let re = regex::RegexBuilder::new(&pattern)

        .case_insensitive(!q.case_sensitive)

        .size_limit(1 << 20)

        .build()

        .map_err(|e| format!("not a valid regular expression: {e}"))?;

    let started = Instant::now();

    let mut out = Results::default();

    for (path, f) in &loaded.snapshot.files {

        if !path.starts_with(q.path_prefix) {

            continue;

        }

        if started.elapsed() > BUDGET || out.hits.len() >= MAX_HITS {

            out.truncated = true;

            break;

        }

        let mut found = false;

        if re.is_match(path) {

            out.hits.push(Hit { path: path.clone(), line: 0, text: String::new() });

            found = true;

        }

        let FileContent::Text { bytes, .. } = &f.content else { continue };

        if bytes.len() > 1 << 20 || bytes.contains(&0) {

            continue;

        }

        let text = String::from_utf8_lossy(bytes);

        for (i, line) in text.lines().enumerate() {

            if re.is_match(line) {

                out.hits.push(Hit { path: path.clone(), line: i + 1, text: line.chars().take(300).collect() });

                found = true;

                if out.hits.len() >= MAX_HITS {

                    out.truncated = true;

                    break;

                }

            }

        }

        if found {

            out.files += 1;

        }

    }

    Ok(out)

}

/// A small cache of results by (state, query).

#[derive(Default)]

pub struct SearchCache {

    inner: Mutex<HashMap<String, Results>>,

}

impl SearchCache {

    pub fn get(&self, key: &str) -> Option<Results> {

        self.inner.lock().unwrap().get(key).cloned()

    }

    pub fn put(&self, key: String, r: Results) {

        let mut m = self.inner.lock().unwrap();

        if m.len() > 256 {

            m.clear();

        }

        m.insert(key, r);

    }

}

//! Releases (hub spec §9): notes and assets on a tag, generated notes from

//! the changes since the previous release, source archives of any state.

use super::settings::{csrf, require};

use super::{filters, lookup, lookup_role, Error, Page, RepoShell, Shell};

use crate::auth::{Access, Viewer};

use crate::db::{self, accounts, releases as rdb};

use crate::repos::archive::{self, Format};

use crate::repos::{view, RepoName};

use crate::Shared;

use askama::Template;

use axum::extract::{Form, Multipart, Path, Query, State};

use axum::http::header;

use axum::response::{IntoResponse, Redirect, Response};

use oxy_core::hash::ChangeHash;

use serde::Deserialize;

use std::collections::HashMap;

/// A release as the pages and the API show it.

pub struct ReleaseView {

    pub r: rdb::Release,

    pub notes_html: String,

    pub assets: Vec<rdb::Asset>,

    pub heads: Vec<String>,

    pub signer: Option<String>,

    pub latest: bool,

}

async fn views(app: &Shared, repo: &RepoName, row: &db::repos::RepoRow) -> Result<Vec<ReleaseView>, sqlx::Error> {

    let list = rdb::list(&app.db, row.id).await?;

    let latest = rdb::latest(&app.db, row.id).await?.map(|r| r.id);

    let tags: HashMap<String, (Vec<String>, Option<String>)> = app

        .repos

        .read(repo, |r, _| Ok(view::tags(r)?.into_iter().map(|t| (t.name, (t.heads, t.signer))).collect()))

        .await

        .unwrap_or_default();

    let mut out = Vec::new();

    for r in list {

        let assets = rdb::assets(&app.db, r.id).await?;

        let (heads, signer) = tags.get(&r.tag).cloned().unwrap_or_default();

        let notes_html = super::issues::markdown(app, row.id, &format!("/{}", row.slug()), &r.notes).await;

        out.push(ReleaseView { latest: Some(r.id) == latest, r, notes_html, assets, heads, signer });

    }

    Ok(out)

}

#[derive(Template)]

#[template(path = "releases.html")]

pub struct ReleasesPage {

    shell: Shell,

    repo: RepoShell,

    releases: Vec<ReleaseView>,

    unreleased: Vec<String>,

    one: bool,

}

pub async fn list(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

) -> Result<Page<ReleasesPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/releases"), &viewer);

    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let releases = views(&app, &repo, &row).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let tags: Vec<String> =

        app.repos.read(&repo, |r, _| Ok(view::tags(r)?.into_iter().map(|t| t.name).collect())).await.unwrap_or_default();

    let unreleased = tags.into_iter().filter(|t| !releases.iter().any(|r| &r.r.tag == t)).collect();

    Ok(Page(ReleasesPage { shell, repo: RepoShell::new(&app, &row, "releases").with_role(role), releases, unreleased, one: false }))

}

pub async fn show(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, tag)): Path<(String, String, String)>,

) -> Result<Page<ReleasesPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/releases/tag/{tag}"), &viewer);

    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let releases: Vec<ReleaseView> =

        views(&app, &repo, &row).await.map_err(|e| Error::from_db(shell.clone(), e))?.into_iter().filter(|r| r.r.tag == tag).collect();

    if releases.is_empty() {

        return Err(Error::not_found(shell));

    }

    Ok(Page(ReleasesPage { shell, repo: RepoShell::new(&app, &row, "releases").with_role(role), releases, unreleased: vec![], one: true }))

}

/// Notes drafted from the changes in `tag`'s state that the previous

/// release's state lacks: one line per change, newest first.

async fn generated_notes(app: &Shared, repo: &RepoName, repo_id: i64, tag: &str) -> String {

    let previous = rdb::list(&app.db, repo_id).await.unwrap_or_default().into_iter().find(|r| r.tag != tag).map(|r| r.tag);

    let tag = tag.to_string();

    app.repos

        .read(repo, move |r, cache| {

            let Some(heads) = r.tag_heads(&tag)? else { return Ok(String::new()) };

            let now = cache.load(r, &heads)?;

            let before: Vec<ChangeHash> = match &previous {

                Some(p) => r.tag_heads(p)?.unwrap_or_default(),

                None => vec![],

            };

            let then = cache.load(r, &before)?;

            let mut added: Vec<_> = now

                .state

                .changes()

                .filter(|(h, _)| !then.state.contains(h))

                .map(|(h, m)| (m.hlc, *h, m.message.clone(), m.author))

                .collect();

            added.sort_by_key(|a| std::cmp::Reverse(a.0));

            let mut out = match &previous {

                Some(p) => format!("Changes since {p}:\n\n"),

                None => "Changes:\n\n".to_string(),

            };

            for (_, h, message, author) in added {

                let who = view::author(r, &author, &message).name;

                out.push_str(&format!("- {} ({}, {})\n", message.lines().next().unwrap_or(""), &h.to_hex()[..12], who));

            }

            Ok(out)

        })

        .await

        .unwrap_or_default()

}

#[derive(Template)]

#[template(path = "release_new.html")]

pub struct NewReleasePage {

    shell: Shell,

    repo: RepoShell,

    tags: Vec<String>,

    tag: String,

    notes: String,

    error: Option<String>,

}

#[derive(Deserialize)]

pub struct NewQuery {

    tag: Option<String>,

}

pub async fn new_form(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Query(q): Query<NewQuery>,

) -> Result<Page<NewReleasePage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/releases/new"), &viewer);

    require(&viewer, &shell)?;

    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

    let tags: Vec<String> = app

        .repos

        .read(&repo, |r, _| Ok(view::tags(r)?.into_iter().map(|t| t.name).collect()))

        .await

        .map_err(|e| Error::from_repo(shell.clone(), e))?;

    let tag = q.tag.filter(|t| tags.contains(t)).or_else(|| tags.first().cloned()).unwrap_or_default();

    let notes = if tag.is_empty() { String::new() } else { generated_notes(&app, &repo, row.id, &tag).await };

    Ok(Page(NewReleasePage { shell, repo: RepoShell::new(&app, &row, "releases").with_role(role), tags, tag, notes, error: None }))

}

#[derive(Deserialize)]

pub struct NewForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    tag: String,

    title: String,

    #[serde(default)]

    notes: String,

    #[serde(default)]

    prerelease: Option<String>,

}

/// Create a release for an existing tag; shared by the form and the API.

#[allow(clippy::too_many_arguments)]

pub async fn create_release(

    app: &Shared,

    repo: &RepoName,

    row: &db::repos::RepoRow,

    me: &accounts::Account,

    tag: &str,

    title: &str,

    notes: Option<String>,

    prerelease: bool,

) -> Result<rdb::Release, String> {

    let exists = app

        .repos

        .read(repo, {

            let t = tag.to_string();

            move |r, _| Ok(r.tag_heads(&t)?.is_some())

        })

        .await

        .map_err(|e| e.to_string())?;

    if !exists {

        return Err(format!("there is no tag {tag}; create it with oxy tag create and push it"));

    }

    if rdb::get(&app.db, row.id, tag).await.map_err(|e| e.to_string())?.is_some() {

        return Err(format!("{tag} already has a release"));

    }

    let notes = match notes {

        Some(n) => n,

        None => generated_notes(app, repo, row.id, tag).await,

    };

    let title = if title.trim().is_empty() { tag.to_string() } else { title.trim().to_string() };

    let r = rdb::create(&app.db, row.id, tag, &title, notes.trim(), prerelease, Some((me.id, &me.username)))

        .await

        .map_err(|e| e.to_string())?;

    accounts::audit(&app.db, Some(me), "release.published", &format!("{}@{tag}", row.slug()), "").await.ok();

    crate::hooks::emit(

        app,

        row,

        "release.published",

        &me.username,

        serde_json::json!({ "tag": tag, "title": title, "prerelease": prerelease }),

    )

    .await;

    crate::notify::deliver(

        app,

        crate::notify::Event {

            kind: "release",

            title: format!("{} released {title}", row.slug()),

            url: format!("/{}/releases/tag/{tag}", row.slug()),

            actor: me,

            repo_id: row.id,

            thread: None,

            mention_text: "",

            direct: vec![],

        },

    )

    .await;

    Ok(r)

}

pub async fn create(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<NewForm>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/releases/new"), &viewer);

    let me = require(&viewer, &shell)?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

    match create_release(&app, &repo, &row, &me.account, &f.tag, &f.title, Some(f.notes.clone()), f.prerelease.is_some()).await {

        Ok(r) => Ok(Redirect::to(&format!("/{owner}/{name}/releases/tag/{}", r.tag)).into_response()),

        Err(msg) => {

            let tags = app.repos.read(&repo, |r, _| Ok(view::tags(r)?.into_iter().map(|t| t.name).collect())).await.unwrap_or_default();

            Ok(Page(NewReleasePage {

                shell,

                repo: RepoShell::new(&app, &row, "releases").with_role(role),

                tags,

                tag: f.tag,

                notes: f.notes,

                error: Some(msg),

            })

            .into_response())

        }

    }

}

#[derive(Deserialize)]

pub struct EditForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    #[serde(default)]

    title: String,

    #[serde(default)]

    notes: String,

    #[serde(default)]

    prerelease: Option<String>,

    #[serde(default)]

    action: String,

    #[serde(default)]

    asset: Option<i64>,

}

pub async fn edit(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, id)): Path<(String, String, i64)>,

    Form(f): Form<EditForm>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/releases"), &viewer);

    let me = require(&viewer, &shell)?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let (_, row, _) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

    let e = |e| Error::from_db(shell.clone(), e);

    let Some(r) = rdb::list(&app.db, row.id).await.map_err(e)?.into_iter().find(|r| r.id == id) else {

        return Err(Error::not_found(shell));

    };

    match f.action.as_str() {

        "delete" => {

            let assets = rdb::assets(&app.db, r.id).await.map_err(e)?;

            rdb::delete(&app.db, r.id).await.map_err(e)?;

            for a in assets {

                remove_blob_if_unused(&app, &a.hash).await;

            }

            accounts::audit(&app.db, Some(&me.account), "release.deleted", &format!("{owner}/{name}@{}", r.tag), "").await.ok();

            return Ok(Redirect::to(&format!("/{owner}/{name}/releases")).into_response());

        }

        "delete_asset" => {

            if let Some(a) = rdb::assets(&app.db, r.id).await.map_err(e)?.into_iter().find(|a| Some(a.id) == f.asset) {

                rdb::delete_asset(&app.db, a.id).await.map_err(e)?;

                remove_blob_if_unused(&app, &a.hash).await;

            }

        }

        _ => rdb::edit(

            &app.db,

            r.id,

            if f.title.trim().is_empty() { &r.tag } else { f.title.trim() },

            f.notes.trim(),

            f.prerelease.is_some(),

        )

        .await

        .map_err(e)?,

    }

    Ok(Redirect::to(&format!("/{owner}/{name}/releases/tag/{}", r.tag)).into_response())

}

fn blob_path(app: &Shared, hash: &str) -> std::path::PathBuf {

    app.config.data.join("assets").join(&hash[..2]).join(hash)

}

async fn remove_blob_if_unused(app: &Shared, hash: &str) {

    if !rdb::hash_in_use(&app.db, hash).await.unwrap_or(true) {

        tokio::fs::remove_file(blob_path(app, hash)).await.ok();

    }

}

/// Store an uploaded asset by content and attach it to a release.

pub async fn store_asset(app: &Shared, release_id: i64, name: &str, content_type: &str, bytes: &[u8]) -> Result<rdb::Asset, String> {

    let name = name.rsplit(['/', '\\']).next().unwrap_or(name).trim();

    if name.is_empty() || name.starts_with('.') || name.len() > 200 {

        return Err("give the asset a file name".into());

    }

    if bytes.len() as u64 > app.config.limits.asset_limit.0 {

        return Err("the asset is larger than this hub allows".into());

    }

    let hash = hex::encode(blake3::hash(bytes).as_bytes());

    let path = blob_path(app, &hash);

    if !path.exists() {

        tokio::fs::create_dir_all(path.parent().unwrap()).await.map_err(|e| e.to_string())?;

        let tmp = path.with_extension("partial");

        tokio::fs::write(&tmp, bytes).await.map_err(|e| e.to_string())?;

        tokio::fs::rename(&tmp, &path).await.map_err(|e| e.to_string())?;

    }

    let ct = if content_type.is_empty() { "application/octet-stream" } else { content_type };

    rdb::add_asset(&app.db, release_id, name, bytes.len() as i64, &hash, ct).await.map_err(|e| e.to_string())

}

pub async fn upload(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, id)): Path<(String, String, i64)>,

    mut multipart: Multipart,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/releases"), &viewer);

    require(&viewer, &shell)?;

    let (_, row, _) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

    let Some(r) = rdb::list(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?.into_iter().find(|r| r.id == id) else {

        return Err(Error::not_found(shell));

    };

    let mut token = String::new();

    let mut files: Vec<(String, String, Vec<u8>)> = vec![];

    while let Ok(Some(field)) = multipart.next_field().await {

        match field.name() {

            Some("_csrf") => token = field.text().await.unwrap_or_default(),

            Some("asset") => {

                let fname = field.file_name().unwrap_or("").to_string();

                let ct = field.content_type().unwrap_or("").to_string();

                let bytes = field.bytes().await.map_err(|e| Error::bad(shell.clone(), e.to_string()))?;

                if !fname.is_empty() {

                    files.push((fname, ct, bytes.to_vec()));

                }

            }

            _ => {}

        }

    }

    csrf(&viewer, &token, &shell)?;

    for (fname, ct, bytes) in files {

        store_asset(&app, r.id, &fname, &ct, &bytes).await.map_err(|m| Error::bad(shell.clone(), m))?;

    }

    Ok(Redirect::to(&format!("/{owner}/{name}/releases/tag/{}", r.tag)).into_response())

}

pub async fn download(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, id, file)): Path<(String, String, i64, String)>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/releases"), &viewer);

    let (_, row, _) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let e = |e| Error::from_db(shell.clone(), e);

    let asset: Option<rdb::Asset> =

        sqlx::query_as("SELECT a.* FROM release_assets a JOIN releases r ON r.id = a.release_id WHERE a.id = ? AND r.repo_id = ?")

            .bind(id)

            .bind(row.id)

            .fetch_optional(&app.db)

            .await

            .map_err(e)?;

    let Some(a) = asset.filter(|a| a.name == file) else { return Err(Error::not_found(shell)) };

    let bytes = tokio::fs::read(blob_path(&app, &a.hash)).await.map_err(|_| Error::not_found(shell.clone()))?;

    rdb::count_download(&app.db, a.id).await.ok();

    Ok((

        [

            (header::CONTENT_TYPE, a.content_type.clone()),

            (header::CONTENT_DISPOSITION, format!("attachment; filename=\"{}\"", a.name.replace('"', ""))),

            (header::X_CONTENT_TYPE_OPTIONS, "nosniff".to_string()),

            (header::CACHE_CONTROL, "public, max-age=31536000, immutable".to_string()),

        ],

        bytes,

    )

        .into_response())

}

#[derive(Deserialize)]

pub struct ArchiveQuery {

    #[serde(rename = "ref")]

    r: String,

    format: String,

}

/// `GET /{owner}/{name}/archive?ref=v1.0&format=tar.zst`: built once per

/// state and served from the cache after.

pub async fn source_archive(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Query(q): Query<ArchiveQuery>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/archive"), &viewer);

    let (repo, _, _) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let format = Format::parse(&q.format).ok_or_else(|| Error::bad(shell.clone(), "format is tar.zst or zip"))?;

    let label: String = q.r.chars().map(|c| if c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_') { c } else { '-' }).collect();

    let prefix = format!("{name}-{}", label.trim_matches('-'));

    let data = app.config.data.clone();

    let spec = q.r.clone();

    let p = prefix.clone();

    let path = app

        .repos

        .read(&repo, move |r, cache| {

            let target = view::resolve(r, cache, &spec)?;

            let loaded = cache.load(r, &target.heads)?;

            let state = oxy_core::objects::StateObject::new(loaded.heads.clone()).hash().to_hex();

            let dest = archive::cache_path(&data, &state, &p, format);

            if !dest.exists() {

                archive::build(r, &loaded, &p, format, &dest)

                    .map_err(|e| crate::repos::RepoError::Oxy(oxy_core::repo::RepoError::Msg(e.to_string())))?;

            }

            Ok(dest)

        })

        .await

        .map_err(|e| Error::from_repo(shell.clone(), e))?;

    let bytes = tokio::fs::read(&path).await.map_err(|_| Error::not_found(shell.clone()))?;

    Ok((

        [

            (header::CONTENT_TYPE, format.mime().to_string()),

            (header::CONTENT_DISPOSITION, format!("attachment; filename=\"{prefix}.{}\"", format.ext())),

        ],

        bytes,

    )

        .into_response())

}

/// API shape of a release.

pub fn to_api(app: &Shared, row: &db::repos::RepoRow, v: &ReleaseView) -> hub_api::Release {

    let base = format!("{}/{}", app.config.base_url(), row.slug());

    hub_api::Release {

        tag: v.r.tag.clone(),

        title: v.r.title.clone(),

        notes: v.r.notes.clone(),

        prerelease: v.r.prerelease,

        latest: v.latest,

        author: v.r.author.clone(),

        heads: v.heads.clone(),

        signer: v.signer.clone(),

        assets: v

            .assets

            .iter()

            .map(|a| hub_api::ReleaseAsset {

                name: a.name.clone(),

                size: a.size,

                hash: a.hash.clone(),

                content_type: a.content_type.clone(),

                downloads: a.downloads,

                url: format!("{base}/asset/{}/{}", a.id, a.name),

            })

            .collect(),

        archives: ["tar.zst", "zip"].iter().map(|f| format!("{base}/archive?ref={}&format={f}", v.r.tag)).collect(),

        created_ms: v.r.created_ms,

        url: format!("{base}/releases/tag/{}", v.r.tag),

    }

}

pub async fn api_views(app: &Shared, repo: &RepoName, row: &db::repos::RepoRow) -> Result<Vec<hub_api::Release>, sqlx::Error> {

    Ok(views(app, repo, row).await?.iter().map(|v| to_api(app, row, v)).collect())

}

//! The rest of milestone 0.6: releases with generated notes, assets and

//! source archives; the read-only Git mirror cloned with real git; code

//! search; anchored proposal comments through the API.

use axum::body::Body;

use axum::http::{header, Request, StatusCode};

use http_body_util::BodyExt;

use oxy_core::repo::{IdentityScope, Repo};

use oxygenhub::config::Config;

use oxygenhub::db;

use oxygenhub::repos::RepoName;

use oxygenhub::Shared;

use std::io::Read;

use std::path::Path;

use tower::ServiceExt;

fn hermetic() {

    static ONCE: std::sync::Once = std::sync::Once::new();

    static DIR: std::sync::OnceLock<tempfile::TempDir> = std::sync::OnceLock::new();

    ONCE.call_once(|| {

        let d = tempfile::tempdir().unwrap();

        std::env::set_var("OXY_HOME", d.path());

        DIR.set(d).ok();

    });

}

fn write(root: &Path, rel: &str, content: &[u8]) {

    let p = root.join(rel);

    std::fs::create_dir_all(p.parent().unwrap()).unwrap();

    std::fs::write(p, content).unwrap();

}

struct Res {

    status: StatusCode,

    body: Vec<u8>,

    cookie: Option<String>,

    location: Option<String>,

}

impl Res {

    fn text(&self) -> String {

        String::from_utf8_lossy(&self.body).into_owned()

    }

}

async fn send(

    app: &Shared,

    method: &str,

    path: &str,

    cookie: Option<&str>,

    bearer: Option<&str>,

    ctype: Option<&str>,

    body: Vec<u8>,

) -> Res {

    let mut req = Request::builder().method(method).uri(path);

    if let Some(c) = cookie {

        req = req.header(header::COOKIE, format!("oxyhub={c}"));

    }

    if let Some(b) = bearer {

        req = req.header(header::AUTHORIZATION, format!("Bearer {b}"));

    }

    if let Some(t) = ctype {

        req = req.header(header::CONTENT_TYPE, t);

    }

    let res = oxygenhub::router(app.clone()).oneshot(req.body(Body::from(body)).unwrap()).await.unwrap();

    let status = res.status();

    let cookie = res

        .headers()

        .get(header::SET_COOKIE)

        .and_then(|v| v.to_str().ok())

        .and_then(|v| v.split(';').next())

        .and_then(|kv| kv.split_once('='))

        .map(|(_, v)| v.to_string());

    let location = res.headers().get(header::LOCATION).and_then(|v| v.to_str().ok()).map(String::from);

    let body = res.into_body().collect().await.unwrap().to_bytes().to_vec();

    Res { status, body, cookie, location }

}

async fn form(app: &Shared, path: &str, cookie: &str, f: &str) -> Res {

    send(app, "POST", path, Some(cookie), None, Some("application/x-www-form-urlencoded"), f.as_bytes().to_vec()).await

}

fn csrf_of(page: &str) -> String {

    let i = page.find("name=\"_csrf\" value=\"").expect("csrf field") + "name=\"_csrf\" value=\"".len();

    page[i..].split('"').next().unwrap().to_string()

}

#[tokio::test(flavor = "multi_thread")]

async fn releases_mirror_search_and_anchors() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let mut config = Config::load(dir.path()).unwrap();

    config.auth.push_tokens = vec!["site".into()];

    config.registration.mode = "open".into();

    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();

    let port = listener.local_addr().unwrap().port();

    config.server.base_url = format!("http://127.0.0.1:{port}");

    let app = oxygenhub::build(config).await.unwrap();

    let router = oxygenhub::router(app.clone());

    tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });

    let base = format!("http://127.0.0.1:{port}");

    let app = &app;

    let andy = send(

        app,

        "POST",

        "/register",

        None,

        None,

        Some("application/x-www-form-urlencoded"),

        b"username=andy&email=a%40example.com&password=correct-horse-battery".to_vec(),

    )

    .await

    .cookie

    .unwrap();

    let repo = RepoName::parse("andy/demo").unwrap();

    app.repos.create(&repo, None).unwrap();

    db::repos::create(&app.db, "andy", "demo", "", hub_api::Visibility::Public).await.unwrap();

    // Two signed changes, a signed tag on the first, and a second tag later.

    let work = tempfile::tempdir().unwrap();

    let mut client = Repo::init(work.path()).unwrap();

    client.create_identity("Andy", "[email protected]", IdentityScope::Repo).unwrap();

    client.config.set("core.sign", "change").unwrap();

    client.config.set("remote.origin.url", &format!("{base}/andy/demo")).unwrap();

    client.config.set("remote.origin.token", "site").unwrap();

    client.save_config().unwrap();

    write(work.path(), "src/main.rs", b"fn main() {\n    println!(\"hello flux\");\n}\n");

    write(work.path(), "run.sh", b"#!/bin/sh\necho run\n");

    std::fs::set_permissions(work.path().join("run.sh"), std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();

    client.snapshot("t").unwrap();

    let c1 = client.commit("First light", &[]).unwrap();

    client.tag_create("v0.1", &[c1], "First release").unwrap();

    write(work.path(), "README.md", b"# Demo\n");

    client.snapshot("t").unwrap();

    let c2 = client.commit("Add a README", &[]).unwrap();

    client.tag_create("v0.2", &[c2], "Second").unwrap();

    assert!(client.push("origin", false).unwrap().iter().all(|r| r.ok));

    // Releases: generated notes list the changes since the previous release.

    let page = send(app, "GET", "/andy/demo/releases/new?tag=v0.1", Some(&andy), None, None, vec![]).await.text();

    assert!(page.contains("First light"), "{page}");

    let csrf = csrf_of(&page);

    let r = form(app, "/andy/demo/releases/new", &andy, &format!("_csrf={csrf}&tag=v0.1&title=Zero+one&notes=First")).await;

    assert_eq!(r.location.as_deref(), Some("/andy/demo/releases/tag/v0.1"), "{}", r.text());

    let (st, v) = {

        let r = send(

            app,

            "POST",

            "/api/v1/repos/andy/demo/releases",

            None,

            Some("site"),

            Some("application/json"),

            br#"{"tag":"v0.2","title":"Zero two"}"#.to_vec(),

        )

        .await;

        (r.status, serde_json::from_slice::<serde_json::Value>(&r.body).unwrap())

    };

    assert_eq!(st, StatusCode::CREATED, "{v}");

    assert!(

        v["notes"].as_str().unwrap().contains("Add a README") && !v["notes"].as_str().unwrap().contains("First light"),

        "notes since v0.1: {v}"

    );

    assert_eq!(v["latest"], true);

    assert_eq!(v["signer"], "Andy");

    let r = send(

        app,

        "POST",

        "/api/v1/repos/andy/demo/releases",

        None,

        Some("site"),

        Some("application/json"),

        br#"{"tag":"nope","title":"x"}"#.to_vec(),

    )

    .await;

    assert_eq!(r.status, StatusCode::BAD_REQUEST);

    // An asset through the API; download it back; the page lists it.

    let r = send(

        app,

        "POST",

        "/api/v1/repos/andy/demo/releases/v0.2/assets?name=demo-linux.bin",

        None,

        Some("site"),

        Some("application/octet-stream"),

        b"\x7fELF binary".to_vec(),

    )

    .await;

    assert_eq!(r.status, StatusCode::CREATED, "{}", r.text());

    let v: serde_json::Value = serde_json::from_slice(&r.body).unwrap();

    let url = v["assets"][0]["url"].as_str().unwrap().replace(&base, "");

    assert_eq!(v["assets"][0]["hash"], hex::encode(blake3::hash(b"\x7fELF binary").as_bytes()));

    let got = send(app, "GET", &url, None, None, None, vec![]).await;

    assert_eq!(got.body, b"\x7fELF binary");

    let list = send(app, "GET", "/andy/demo/releases", None, None, None, vec![]).await.text();

    assert!(list.contains("Zero two") && list.contains("demo-linux.bin") && list.contains("latest"), "{list}");

    // Source archives: tar.zst with the exec bit, and zip.

    let tz = send(app, "GET", "/andy/demo/archive?ref=v0.1&format=tar.zst", None, None, None, vec![]).await;

    assert_eq!(tz.status, StatusCode::OK);

    let mut tar = tar::Archive::new(zstd::Decoder::new(tz.body.as_slice()).unwrap());

    let mut seen = vec![];

    for e in tar.entries().unwrap() {

        let mut e = e.unwrap();

        let path = e.path().unwrap().to_string_lossy().into_owned();

        let mode = e.header().mode().unwrap();

        let mut s = String::new();

        e.read_to_string(&mut s).unwrap();

        seen.push((path, mode, s));

    }

    assert!(seen.iter().any(|(p, _, s)| p == "demo-v0.1/src/main.rs" && s.contains("hello flux")), "{seen:?}");

    assert!(seen.iter().any(|(p, m, _)| p == "demo-v0.1/run.sh" && m & 0o111 != 0), "exec bit kept: {seen:?}");

    assert!(!seen.iter().any(|(p, _, _)| p.ends_with("README.md")), "v0.1 predates the README");

    let zp = send(app, "GET", "/andy/demo/archive?ref=main&format=zip", None, None, None, vec![]).await;

    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(zp.body)).unwrap();

    let mut readme = String::new();

    zip.by_name("demo-main/README.md").unwrap().read_to_string(&mut readme).unwrap();

    assert_eq!(readme, "# Demo\n");

    // Code search: substring and regex, with path matches.

    let s = send(app, "GET", "/andy/demo/search?q=flux", None, None, None, vec![]).await.text();

    assert!(s.contains("src/main.rs:2"), "{s}");

    let s = send(app, "GET", "/andy/demo/search?q=print%5Cw%2B&re=1", None, None, None, vec![]).await.text();

    assert!(s.contains("src/main.rs:2"), "{s}");

    let s = send(app, "GET", "/andy/demo/search?q=%28&re=1", None, None, None, vec![]).await.text();

    assert!(s.contains("not a valid regular expression"), "{s}");

    assert!(send(app, "GET", "/andy/demo/search?q=README", None, None, None, vec![]).await.text().contains("path matches"));

    // The Git mirror: off by default, on from settings, cloned with git, push refused.

    assert_eq!(

        send(app, "GET", "/andy/demo.git/info/refs?service=git-upload-pack", None, None, None, vec![]).await.status,

        StatusCode::NOT_FOUND

    );

    let settings = send(app, "GET", "/andy/demo/settings", Some(&andy), None, None, vec![]).await.text();

    let r = form(app, "/andy/demo/settings/mirror", &andy, &format!("_csrf={}&enabled=1", csrf_of(&settings))).await;

    assert!(r.text().contains("mirror is on"), "{}", r.text());

    let clone_dir = tempfile::tempdir().unwrap();

    let url = format!("{base}/andy/demo.git");

    let target = clone_dir.path().join("demo");

    let out = tokio::task::spawn_blocking(move || {

        std::process::Command::new("git")

            .args(["clone", "-q", &url, target.to_str().unwrap()])

            .env("GIT_TERMINAL_PROMPT", "0")

            .output()