Files
codecraft/server/src/factory_version.rs
T

620 lines
28 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Versions, tags and releases of factory repositories.
//!
//! Every merged factory issue gets a version (`MAJOR.MINOR.PATCH`): the patch number goes up with each
//! issue, the minor number when the issue completes a milestone (`M1.3` was the last open `M1.x`
//! issue); the patch restarts at 0. A version is a commit with a `VERSION` file on the default branch
//! plus the tag `vX.Y.Z` on it. Major versions are only made by a manual release, which also builds
//! the Docker image and the downloads described in `.factory/release.json`.
use crate::app::App;
use crate::factory::{Forge, RepoCfg, bot_comment, checkout, git, issue_no, notify};
use crate::store::User;
use anyhow::{Context, Result, bail};
use serde::Deserialize;
use serde_json::{Value, json};
use std::collections::{HashMap, HashSet};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex, OnceLock};
use std::time::Duration;
pub type Ver = (u64, u64, u64);
pub fn parse_version(s: &str) -> Option<Ver> {
let mut it = s.trim().trim_start_matches('v').split('.');
let v = (it.next()?.parse().ok()?, it.next()?.parse().ok()?, it.next()?.parse().ok()?);
it.next().is_none().then_some(v)
}
pub fn fmt(v: Ver) -> String {
format!("{}.{}.{}", v.0, v.1, v.2)
}
/// Milestone of an issue title: `M1.3 – x` → (1, Some(3)), `M1 – x` → (1, None).
pub fn milestone_of(title: &str) -> Option<(u64, Option<u64>)> {
let t = title.trim();
let rest = t.strip_prefix('M').or_else(|| t.strip_prefix('m'))?;
let digits: String = rest.chars().take_while(|c| c.is_ascii_digit()).collect();
let k: u64 = digits.parse().ok()?;
let after = &rest[digits.len()..];
if let Some(a) = after.strip_prefix('.') {
let d: String = a.chars().take_while(|c| c.is_ascii_digit()).collect();
if !d.is_empty() {
return Some((k, Some(d.parse().ok()?)));
}
}
match after.chars().next() {
None | Some(' ') | Some('–') | Some('-') | Some(':') => Some((k, None)),
_ => None,
}
}
#[derive(Debug, PartialEq, Clone, Copy)]
pub enum Bump {
Patch,
Minor,
}
/// How an issue raises the version, given the titles of the *other* open issues of the repository.
pub fn bump_for(title: &str, other_open: &[String]) -> Bump {
match milestone_of(title) {
Some((_, None)) => Bump::Minor,
Some((k, Some(_))) => {
if other_open.iter().any(|t| matches!(milestone_of(t), Some((k2, Some(_))) if k2 == k)) {
Bump::Patch
} else {
Bump::Minor
}
}
None => Bump::Patch,
}
}
pub fn next_version(cur: Ver, b: Bump) -> Ver {
match b {
Bump::Patch => (cur.0, cur.1, cur.2 + 1),
Bump::Minor => (cur.0, cur.1 + 1, 0),
}
}
// --- git helpers ---------------------------------------------------------------------------
/// Highest `vX.Y.Z` tag of the remote (0.0.0 when there is none).
async fn tags_version(cfg: &RepoCfg, dir: &Path) -> Ver {
// The remote is the truth: a local checkout keeps tags that were deleted on the forge.
let remote = git(cfg, dir, &["ls-remote", "--tags", "--refs", "origin", "v[0-9]*"]).await;
let names: Vec<String> = match remote {
Ok(out) => out.lines().filter_map(|l| l.split("refs/tags/").nth(1)).map(str::to_string).collect(),
Err(_) => {
let _ = git(cfg, dir, &["fetch", "--tags", "--force", "origin"]).await;
git(cfg, dir, &["tag", "-l", "v[0-9]*"]).await.unwrap_or_default().lines().map(str::to_string).collect()
}
};
names.iter().filter_map(|t| parse_version(t)).max().unwrap_or((0, 0, 0))
}
/// `git pull --ff-only` of the default branch in the main checkout, so everything that was merged
/// (also by others) is on disk for the reviews. Does nothing harmful: with local changes or a
/// diverged branch it reports an error and leaves the checkout alone.
pub async fn sync_default(cfg: &RepoCfg, dir: &Path) -> Result<()> {
let base = base_branch(cfg, dir).await;
let current = git(cfg, dir, &["rev-parse", "--abbrev-ref", "HEAD"]).await.unwrap_or_default();
if current != base {
if !git(cfg, dir, &["status", "--porcelain"]).await.unwrap_or_default().is_empty() {
bail!("the checkout has local changes and is on '{current}', not on {base}");
}
git(cfg, dir, &["checkout", "-q", &base]).await?;
}
git(cfg, dir, &["merge", "--ff-only", "-q", &format!("origin/{base}")]).await?;
Ok(())
}
async fn base_branch(cfg: &RepoCfg, repo: &Path) -> String {
git(cfg, repo, &["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]).await.ok().and_then(|s| s.strip_prefix("origin/").map(String::from)).unwrap_or_else(|| "main".to_string())
}
/// A throw-away detached worktree of the default branch below `<owner>/<sub>/<name>`.
async fn fresh_worktree(cfg: &RepoCfg, repo: &Path, sub: &str, name: &str, base: &str) -> Result<PathBuf> {
let work = repo.parent().context("no parent folder")?.join(sub).join(name);
std::fs::create_dir_all(work.parent().unwrap())?;
if work.exists() {
let _ = git(cfg, repo, &["worktree", "remove", "--force", &work.display().to_string()]).await;
let _ = std::fs::remove_dir_all(&work);
}
let _ = git(cfg, repo, &["worktree", "prune"]).await;
git(cfg, repo, &["worktree", "add", "--detach", &work.display().to_string(), &format!("origin/{base}")]).await?;
Ok(work)
}
async fn drop_worktree(cfg: &RepoCfg, repo: &Path, work: &Path) {
let _ = git(cfg, repo, &["worktree", "remove", "--force", &work.display().to_string()]).await;
let _ = std::fs::remove_dir_all(work);
}
const IDENT: [&str; 4] = ["-c", "user.name=CodeCraft Factory", "-c", "user.email=factory@codecraft.invalid"];
/// Write `VERSION` and commit it locally (nothing is pushed yet).
async fn commit_version(cfg: &RepoCfg, work: &Path, ver: &str, msg: &str) -> Result<()> {
std::fs::write(work.join("VERSION"), format!("{ver}\n"))?;
git(cfg, work, &["add", "VERSION"]).await?;
if !git(cfg, work, &["diff", "--cached", "--name-only"]).await?.is_empty() {
let mut args = IDENT.to_vec();
args.extend(["commit", "-m", msg]);
git(cfg, work, &args).await?;
}
Ok(())
}
/// Tag the commit and push default branch and tag. Returns a warning when the branch could not be
/// pushed (e.g. protected): then the tag goes onto the commit already on the branch.
async fn publish_version(cfg: &RepoCfg, work: &Path, base: &str, ver: &str, msg: &str) -> Result<String> {
let mut warn = String::new();
let target = format!("HEAD:refs/heads/{base}");
let mut pushed = git(cfg, work, &["push", "origin", &target]).await;
if pushed.is_err() {
// The branch moved meanwhile: put the version commit on top and try once more.
let _ = git(cfg, work, &["fetch", "origin"]).await;
let upstream = format!("origin/{base}");
let mut args = IDENT.to_vec();
args.extend(["rebase", &upstream]);
if git(cfg, work, &args).await.is_ok() {
pushed = git(cfg, work, &["push", "origin", &target]).await;
} else {
let _ = git(cfg, work, &["rebase", "--abort"]).await;
}
}
if let Err(e) = pushed {
warn = format!("the VERSION commit could not be pushed to {base} ({e:#}); the tag points to the branch head instead");
git(cfg, work, &["reset", "--hard", &format!("origin/{base}")]).await?;
}
let tag = format!("v{ver}");
let mut args = IDENT.to_vec();
args.extend(["tag", "-a", "-f", &tag, "-m", msg]);
git(cfg, work, &args).await?;
git(cfg, work, &["push", "origin", &format!("refs/tags/{tag}")]).await?;
Ok(warn)
}
// --- version of merged issues -----------------------------------------------------------------
static BUSY: OnceLock<Mutex<HashSet<String>>> = OnceLock::new();
/// Keeps two passes (poller and manual poll) from versioning the same repository at once.
struct Busy(String);
fn busy(repo: &str) -> Option<Busy> {
let set = BUSY.get_or_init(Default::default);
set.lock().unwrap().insert(repo.to_string()).then(|| Busy(repo.to_string()))
}
impl Drop for Busy {
fn drop(&mut self) {
if let Some(set) = BUSY.get() {
set.lock().unwrap().remove(&self.0);
}
}
}
fn pr_number(url: &str) -> u64 {
url.trim_end_matches('/').rsplit('/').next().and_then(|n| n.parse().ok()).unwrap_or(0)
}
/// Give every merged, accepted issue its version. The first pass over a repository only
/// sets the baseline: issues that were done before are not versioned.
pub async fn version_pass(app: &Arc<App>, user: &User, cfg: &RepoCfg) -> Result<()> {
let Some(_guard) = busy(&cfg.url) else { return Ok(()) };
let rows: Vec<Value> = app.store.factory_issues(&user.id)?.into_iter().filter(|r| r["repo"].as_str() == Some(cfg.url.as_str())).collect();
let pending = |r: &&Value| matches!(r["state"].as_str(), Some("done") | Some("closed")) && r["version"].as_str() == Some("") && !r["pr_url"].as_str().unwrap_or("").is_empty();
if app.store.factory_version(&cfg.url)?.is_none() {
let dir = checkout(app, user, cfg).await?;
let cur = tags_version(cfg, &dir).await;
for r in rows.iter().filter(|r| matches!(r["state"].as_str(), Some("done") | Some("closed")) && r["version"].as_str() == Some("")) {
app.store.factory_issue_set(&cfg.url, issue_no(r), &[("version", json!("-"))])?;
}
app.store.factory_version_set(&cfg.url, &fmt(cur))?;
return Ok(());
}
let mut todo: Vec<&Value> = rows.iter().filter(pending).collect();
if todo.is_empty() {
return Ok(());
}
todo.sort_by_key(|r| issue_no(r));
let g = Forge::new(cfg)?;
for r in todo {
let n = issue_no(r);
let pr_n = pr_number(r["pr_url"].as_str().unwrap_or(""));
if pr_n == 0 {
continue;
}
let pr = match g.pr(pr_n).await {
Ok(p) => p,
Err(e) => {
tracing::warn!("factory {}#{n}: pull request: {e:#}", cfg.url);
continue;
}
};
if pr["state"].as_str() != Some("merged") {
continue;
}
// Remember it at once: if the version step below fails, the issue can still be closed by hand.
let _ = app.store.factory_issue_set(&cfg.url, n, &[("merged", json!(1))]);
let title = r["title"].as_str().unwrap_or("").to_string();
let others: Vec<String> = g.open_issue_titles().await?.into_iter().filter(|(num, _)| *num != n).map(|(_, t)| t).collect();
let dir = checkout(app, user, cfg).await?;
let cur = tags_version(cfg, &dir).await;
let bump = bump_for(&title, &others);
let new = fmt(next_version(cur, bump));
let base = base_branch(cfg, &dir).await;
let (_, _, name) = cfg.parts()?;
let work = fresh_worktree(cfg, &dir, "_release", &format!("{name}-version"), &base).await?;
let msg = format!("Release v{new}: {title} (#{n})");
let published = async {
commit_version(cfg, &work, &new, &msg).await?;
publish_version(cfg, &work, &base, &new, &msg).await
}
.await;
drop_worktree(cfg, &dir, &work).await;
let warn = match published {
Ok(w) => w,
Err(e) => {
tracing::warn!("factory {}#{n}: version {new}: {e:#}", cfg.url);
continue;
}
};
let _ = checkout(app, user, cfg).await; // pulls the merge and the VERSION commit
app.store.factory_issue_set(&cfg.url, n, &[("version", json!(new.clone())), ("state", json!("closed"))])?;
app.store.factory_version_set(&cfg.url, &new)?;
let _ = g.close_issue(n as u64).await;
let why = if bump == Bump::Minor && milestone_of(&title).is_some() { " – the milestone is complete" } else { "" };
let extra = if warn.is_empty() { String::new() } else { format!("\n\nNote: {warn}.") };
bot_comment(&g, n as u64, &format!("**Version v{new}**{why}. The change is merged; tag `v{new}` and `VERSION` are on the default branch.{extra}")).await;
notify(app, user, &format!("Factory #{n}"), &format!("v{new}{why}"), n).await;
}
Ok(())
}
// --- manual release ----------------------------------------------------------------------------
/// `.factory/release.json`: how to build the downloads of a release.
#[derive(Debug, Default, Deserialize)]
pub struct ReleaseSpec {
/// Docker image name without tag, e.g. registry.example.org/team/app (empty = no image).
#[serde(default)]
pub image: String,
#[serde(default = "default_platforms")]
pub platforms: String,
#[serde(default = "default_dockerfile")]
pub dockerfile: String,
#[serde(default = "default_context")]
pub context: String,
#[serde(default)]
pub build_args: HashMap<String, String>,
/// Shell commands run in the release checkout before the image is built (e.g. to make zips).
#[serde(default)]
pub commands: Vec<String>,
/// Files (globs relative to the checkout) attached to the release; the source zip is always attached.
#[serde(default)]
pub files: Vec<String>,
/// Name used for the source zip (default: the repository name).
#[serde(default)]
pub name: String,
}
fn default_platforms() -> String {
"linux/amd64,linux/arm64".into()
}
fn default_dockerfile() -> String {
"Dockerfile".into()
}
fn default_context() -> String {
".".into()
}
/// Run a command with a timeout; returns the last lines of its output.
async fn run(cmd: &mut tokio::process::Command, timeout: Duration, stdin: Option<&str>) -> Result<String> {
use tokio::io::AsyncWriteExt;
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped()).stdin(if stdin.is_some() { std::process::Stdio::piped() } else { std::process::Stdio::null() }).kill_on_drop(true);
let mut child = cmd.spawn().context("could not start the command")?;
if let (Some(text), Some(mut si)) = (stdin, child.stdin.take()) {
si.write_all(text.as_bytes()).await?;
}
let out = tokio::time::timeout(timeout, child.wait_with_output()).await.map_err(|_| anyhow::anyhow!("timed out after {} min", timeout.as_secs() / 60))??;
let text = format!("{}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr));
let tail: Vec<&str> = text.lines().rev().take(25).collect::<Vec<_>>().into_iter().rev().collect();
let tail = tail.join("\n");
if !out.status.success() {
bail!("{}", tail);
}
Ok(tail)
}
fn clean_env(cmd: &mut tokio::process::Command, extra: &[(&str, &str)]) {
cmd.env_clear().env("PATH", std::env::var("PATH").unwrap_or_default()).env("HOME", "/tmp");
for (k, v) in extra {
cmd.env(k, v);
}
}
/// Current version, suggested next major version and the release recipe of the default branch.
pub async fn preview(app: &Arc<App>, user: &User, cfg: &RepoCfg) -> Result<Value> {
let dir = checkout(app, user, cfg).await?;
let cur = tags_version(cfg, &dir).await;
let base = base_branch(cfg, &dir).await;
let spec = git(cfg, &dir, &["show", &format!("origin/{base}:.factory/release.json")]).await.ok();
Ok(json!({"current": fmt(cur), "suggested": fmt((cur.0 + 1, 0, 0)), "spec": spec, "running": app.store.factory_release_running(&cfg.url)?}))
}
/// Validate and start a release in the background; returns the release id.
pub async fn start_release(app: &Arc<App>, user: &User, cfg: &RepoCfg, version: &str) -> Result<String> {
let Some(new) = parse_version(version) else { bail!("the version must look like 1.0.0") };
if app.store.factory_release_running(&cfg.url)? {
bail!("a release of this repository is already running");
}
let dir = checkout(app, user, cfg).await?;
let cur = tags_version(cfg, &dir).await;
if new <= cur {
bail!("v{} is not newer than the current version v{}", fmt(new), fmt(cur));
}
let id = crate::types::new_id();
app.store.factory_release_add(&id, &user.id, &cfg.url, &fmt(new))?;
let (app, user, cfg, rid) = (app.clone(), user.clone(), cfg.clone(), id.clone());
tokio::spawn(async move {
let log = |m: &str| {
let _ = app.store.factory_release_log(&rid, m);
};
match run_release(&app, &user, &cfg, new, &rid, &log).await {
Ok(url) => {
let _ = app.store.factory_release_end(&rid, "done", &url);
notify(&app, &user, "Factory release", &format!("v{} released", fmt(new)), 0).await;
}
Err(e) => {
log(&format!("FAILED: {e:#}"));
let _ = app.store.factory_release_end(&rid, "failed", "");
notify(&app, &user, "Factory release", &format!("v{} failed", fmt(new)), 0).await;
}
}
});
Ok(id)
}
async fn run_release(app: &Arc<App>, user: &User, cfg: &RepoCfg, new: Ver, rid: &str, log: &(dyn Fn(&str) + Sync)) -> Result<String> {
let ver = fmt(new);
let tag = format!("v{ver}");
let dir = checkout(app, user, cfg).await?;
let base = base_branch(cfg, &dir).await;
let (_, _, name) = cfg.parts()?;
let g = Forge::new(cfg)?;
log(&format!("release {tag} from {base}"));
let work = fresh_worktree(cfg, &dir, "_release", &format!("{name}-release"), &base).await?;
let tmp = std::env::temp_dir().join(format!("factory-release-{rid}"));
std::fs::create_dir_all(&tmp)?;
let result = release_steps(cfg, &g, &work, &tmp, &base, &name, &ver, &tag, rid, log).await;
drop_worktree(cfg, &dir, &work).await;
let _ = std::fs::remove_dir_all(&tmp);
result
}
#[allow(clippy::too_many_arguments)]
async fn release_steps(cfg: &RepoCfg, g: &Forge, work: &Path, tmp: &Path, base: &str, name: &str, ver: &str, tag: &str, rid: &str, log: &(dyn Fn(&str) + Sync)) -> Result<String> {
let msg = format!("Release {tag}");
commit_version(cfg, work, ver, &msg).await?;
let spec: ReleaseSpec = match std::fs::read_to_string(work.join(".factory/release.json")) {
Ok(t) => serde_json::from_str(&t).context(".factory/release.json is not valid")?,
Err(_) => {
log("no .factory/release.json – only the tag, the release and the source zip are made");
ReleaseSpec::default()
}
};
let hour = Duration::from_secs(3600);
for cmd in &spec.commands {
log(&format!("$ {cmd}"));
let mut c = tokio::process::Command::new("bash");
c.arg("-c").arg(cmd).current_dir(work);
clean_env(&mut c, &[("VERSION", ver), ("CI", "1")]);
log(&run(&mut c, hour, None).await?);
}
if !spec.image.trim().is_empty() {
build_image(cfg, g, &spec, work, tmp, ver, rid, log).await?;
}
// Publish: branch + tag, then the release with its files.
let warn = publish_version(cfg, work, base, ver, &msg).await?;
if !warn.is_empty() {
log(&format!("note: {warn}"));
}
log(&format!("tag {tag} pushed"));
let prev = git(cfg, work, &["tag", "-l", "v[0-9]*"]).await.unwrap_or_default().lines().filter_map(|t| parse_version(t).map(|v| (v, t.to_string()))).filter(|(v, _)| fmt(*v) != ver && *v < parse_version(ver).unwrap_or((0, 0, 0))).max().map(|(_, t)| t);
let range = prev.as_ref().map(|p| format!("{p}..{tag}")).unwrap_or_else(|| tag.to_string());
let changes = git(cfg, work, &["log", "--pretty=format:- %s", "--max-count=200", &range]).await.unwrap_or_default();
let mut notes = format!("Release {tag}\n\n");
if !spec.image.trim().is_empty() {
notes.push_str(&format!("Docker image: `{}:{ver}` ({})\n\n", spec.image.trim(), spec.platforms));
}
notes.push_str(&format!("## Changes\n\n{changes}\n"));
let rel = g.create_release(tag, &format!("{name} {tag}"), &notes).await?;
let url = rel["html_url"].as_str().unwrap_or("").to_string();
log(&format!("release created {url}"));
// Downloads: the source zip and the configured files.
let zip_name = format!("{}-{ver}-source.zip", Some(spec.name.trim()).filter(|n| !n.is_empty()).unwrap_or(name));
let zip = tmp.join(&zip_name);
git(cfg, work, &["archive", "--format=zip", &format!("--prefix={name}-{ver}/"), "-o", &zip.display().to_string(), "HEAD"]).await?;
let mut files: Vec<(String, PathBuf)> = vec![(zip_name, zip)];
if !spec.files.is_empty() {
let mut builder = globset::GlobSetBuilder::new();
for f in &spec.files {
builder.add(globset::Glob::new(f).with_context(|| format!("bad file pattern {f}"))?);
}
let set = builder.build()?;
let mut stack = vec![work.to_path_buf()];
while let Some(d) = stack.pop() {
for e in std::fs::read_dir(&d)?.flatten() {
let p = e.path();
let rel_path = p.strip_prefix(work).unwrap_or(&p).to_path_buf();
if rel_path.starts_with(".git") || rel_path.starts_with("node_modules") || rel_path.starts_with("target") && !set.is_match(&rel_path) {
continue;
}
if p.is_dir() {
stack.push(p);
} else if set.is_match(&rel_path) && files.len() < 60 {
files.push((e.file_name().to_string_lossy().to_string(), p));
}
}
}
}
for (fname, path) in &files {
match g.upload_asset(&rel["id"], fname, path).await {
Ok(()) => log(&format!("attached {fname}")),
Err(e) => log(&format!("not attached: {e:#}")),
}
}
Ok(url)
}
/// Build and push the multi-arch Docker image with buildx (own builder, own login, both removed afterwards).
#[allow(clippy::too_many_arguments)]
async fn build_image(cfg: &RepoCfg, g: &Forge, spec: &ReleaseSpec, work: &Path, tmp: &Path, ver: &str, rid: &str, log: &(dyn Fn(&str) + Sync)) -> Result<()> {
let image = spec.image.trim();
let first = image.split('/').next().unwrap_or("");
let host = if image.contains('/') && (first.contains('.') || first.contains(':')) { first } else { "docker.io" };
let conf = tmp.join("docker");
std::fs::create_dir_all(&conf)?;
let conf_s = conf.display().to_string();
let builder = format!("factory-{}", &rid[..8.min(rid.len())]);
let minute = Duration::from_secs(120);
let env = [("DOCKER_CONFIG", conf_s.as_str())];
let mut c = tokio::process::Command::new("docker");
c.args(["buildx", "version"]);
clean_env(&mut c, &env);
run(&mut c, minute, None).await.context("docker buildx is not available in this installation")?;
let login = g.login().await?;
log(&format!("docker login {host}"));
let mut c = tokio::process::Command::new("docker");
c.args(["login", host, "-u", &login, "--password-stdin"]);
clean_env(&mut c, &env);
run(&mut c, minute, Some(&cfg.token)).await.context("docker login failed")?;
let mut c = tokio::process::Command::new("docker");
c.args(["buildx", "create", "--name", &builder, "--driver", "docker-container"]);
clean_env(&mut c, &env);
run(&mut c, minute, None).await.context("could not create the buildx builder")?;
let mut args: Vec<String> = ["buildx", "build", "--builder", &builder, "--platform", &spec.platforms, "-f", &spec.dockerfile, "-t", &format!("{image}:{ver}"), "-t", &format!("{image}:latest"), "--build-arg", &format!("VERSION={ver}")].iter().map(|s| s.to_string()).collect();
for (k, v) in &spec.build_args {
args.extend(["--build-arg".to_string(), format!("{k}={v}")]);
}
args.extend(["--push".to_string(), spec.context.clone()]);
log(&format!("docker buildx build {} → {image}:{ver}", spec.platforms));
let mut c = tokio::process::Command::new("docker");
c.args(&args).current_dir(work);
clean_env(&mut c, &env);
let built = run(&mut c, Duration::from_secs(3 * 3600), None).await;
let mut c = tokio::process::Command::new("docker");
c.args(["buildx", "rm", "--force", &builder]);
clean_env(&mut c, &env);
let _ = run(&mut c, minute, None).await;
log(&built.context("the image build failed")?);
log("image pushed");
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_and_formats_versions() {
assert_eq!(parse_version("v1.2.3"), Some((1, 2, 3)));
assert_eq!(parse_version("0.0.0"), Some((0, 0, 0)));
assert_eq!(parse_version("1.2"), None);
assert_eq!(parse_version("1.2.3.4"), None);
assert_eq!(parse_version("vx.1.2"), None);
assert_eq!(fmt((0, 1, 10)), "0.1.10");
assert!(parse_version("0.10.0") > parse_version("0.9.9"));
}
#[test]
fn reads_milestones_from_titles() {
assert_eq!(milestone_of("M1.3 – Import"), Some((1, Some(3))));
assert_eq!(milestone_of("M12.10 - x"), Some((12, Some(10))));
assert_eq!(milestone_of("M1 – Foundation"), Some((1, None)));
assert_eq!(milestone_of("M0"), Some((0, None)));
assert_eq!(milestone_of("Make it faster"), None);
assert_eq!(milestone_of("M1abc"), None);
assert_eq!(milestone_of("Fix login"), None);
}
#[test]
fn issues_raise_patch_and_the_last_one_of_a_milestone_the_minor() {
let open = |v: &[&str]| v.iter().map(|s| s.to_string()).collect::<Vec<_>>();
// other M1 issues still open: patch
assert_eq!(bump_for("M1.3 – Import", &open(&["M1.4 – Debayering", "M2.1 – Mail"])), Bump::Patch);
// the last open M1 issue: minor (other milestones do not matter)
assert_eq!(bump_for("M1.11 – Log", &open(&["M2.1 – Mail", "Fix typo"])), Bump::Minor);
assert_eq!(bump_for("Fix login bug", &open(&["M1.1 – x"])), Bump::Patch);
assert_eq!(bump_for("M3 – Mosaics", &open(&[])), Bump::Minor);
assert_eq!(next_version((0, 0, 7), Bump::Patch), (0, 0, 8));
assert_eq!(next_version((0, 0, 10), Bump::Minor), (0, 1, 0));
assert_eq!(next_version((0, 1, 4), Bump::Minor), (0, 2, 0));
}
#[test]
fn release_spec_has_defaults() {
let s: ReleaseSpec = serde_json::from_str(r#"{"image": "r.example/app"}"#).unwrap();
assert_eq!((s.platforms.as_str(), s.dockerfile.as_str(), s.context.as_str()), ("linux/amd64,linux/arm64", "Dockerfile", "."));
assert!(s.commands.is_empty() && s.files.is_empty());
}
#[tokio::test]
async fn sync_default_pulls_what_was_merged() {
let run = |dir: &Path, args: &[&str]| {
let o = std::process::Command::new("git").args(["-c", "user.name=t", "-c", "user.email=t@t", "-c", "init.defaultBranch=main"]).args(args).current_dir(dir).output().unwrap();
assert!(o.status.success(), "git {args:?}: {}", String::from_utf8_lossy(&o.stderr));
};
let root = std::env::temp_dir().join(format!("factory-sync-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).unwrap();
run(&root, &["init", "-q", "--bare", "origin.git"]);
run(&root, &["clone", "-q", "origin.git", "a"]);
std::fs::write(root.join("a/one.txt"), "1").unwrap();
run(&root.join("a"), &["add", "."]);
run(&root.join("a"), &["commit", "-qm", "one"]);
run(&root.join("a"), &["push", "-q", "origin", "HEAD:main"]);
run(&root, &["--git-dir=origin.git", "symbolic-ref", "HEAD", "refs/heads/main"]);
run(&root, &["clone", "-q", "origin.git", "checkout"]);
// somebody merges a second change on the remote
std::fs::write(root.join("a/two.txt"), "2").unwrap();
run(&root.join("a"), &["add", "."]);
run(&root.join("a"), &["commit", "-qm", "two"]);
run(&root.join("a"), &["push", "-q", "origin", "HEAD:main"]);
let cfg: RepoCfg = serde_json::from_value(json!({"url": "https://g.example/o/r.git", "token": "t"})).unwrap();
let dir = root.join("checkout");
git(&cfg, &dir, &["fetch", "origin"]).await.unwrap();
assert!(!dir.join("two.txt").exists(), "a fetch alone does not update the files");
sync_default(&cfg, &dir).await.unwrap();
assert!(dir.join("two.txt").exists());
// local changes block switching, nothing is damaged
std::fs::write(dir.join("one.txt"), "edited").unwrap();
sync_default(&cfg, &dir).await.unwrap();
assert_eq!(std::fs::read_to_string(dir.join("one.txt")).unwrap(), "edited");
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn pr_numbers_come_from_urls() {
assert_eq!(pr_number("https://g.example/o/r/pulls/72"), 72);
assert_eq!(pr_number("https://g.example/o/r/-/merge_requests/5/"), 5);
assert_eq!(pr_number(""), 0);
}
#[test]
fn busy_guard_blocks_a_second_pass() {
let a = busy("https://g.example/o/busy-test");
assert!(a.is_some());
assert!(busy("https://g.example/o/busy-test").is_none());
drop(a);
assert!(busy("https://g.example/o/busy-test").is_some());
}
}