Factory: versions and tags, releases, retry settings, pull of the default branch
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
06c1b8df1b
commit
cb1e31b6e9
13 files changed
+1082
-19
No files matched your search
@@ -0,0 +1,609 @@
|
||||
//! 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 {
|
||||
let _ = git(cfg, dir, &["fetch", "--tags", "--force", "origin"]).await;
|
||||
git(cfg, dir, &["tag", "-l", "v[0-9]*"]).await.unwrap_or_default().lines().filter_map(parse_version).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| r["state"].as_str() == Some("done") && r["version"].as_str() == Some("");
|
||||
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(pending) {
|
||||
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;
|
||||
}
|
||||
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()))])?;
|
||||
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}"), ¬es).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());
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user