| //! Helper script to publish this repository's suites of crates |
| //! |
| //! In a nutshell |
| //! |
| //! * `./publish bump` - bump crate versions as a major release |
| //! * `./publish bump-patch` - bump crate versions as a patch release |
| //! * `./publish publish` - actually publish crates to crates.io |
| //! * `./publish verify` - verify that crates can be published, like a dry run |
| |
| use std::collections::HashMap; |
| use std::env; |
| use std::fs; |
| use std::path::{Path, PathBuf}; |
| use std::process::{Command, Stdio}; |
| use std::thread; |
| use std::time::Duration; |
| |
| // note that this list must be topologically sorted by dependencies |
| const CRATES_TO_PUBLISH: &[&str] = &["wasm-component-ld"]; |
| |
| struct Workspace { |
| version: String, |
| } |
| |
| struct Crate { |
| manifest: PathBuf, |
| name: String, |
| version: String, |
| publish: bool, |
| workspace_version: Option<String>, |
| } |
| |
| fn main() { |
| let mut crates = Vec::new(); |
| let root = read_crate(None, "./Cargo.toml".as_ref()); |
| crates.push(root); |
| |
| let pos = CRATES_TO_PUBLISH |
| .iter() |
| .enumerate() |
| .map(|(i, c)| (*c, i)) |
| .collect::<HashMap<_, _>>(); |
| crates.sort_by_key(|krate| pos.get(&krate.name[..])); |
| |
| match &env::args().nth(1).expect("must have one argument")[..] { |
| name @ "bump" | name @ "bump-patch" => { |
| for krate in crates.iter() { |
| bump_version(&krate, &crates, name == "bump-patch"); |
| } |
| // update the lock file |
| assert!(Command::new("cargo") |
| .arg("fetch") |
| .status() |
| .unwrap() |
| .success()); |
| } |
| |
| "publish" => { |
| // We have so many crates to publish we're frequently either |
| // rate-limited or we run into issues where crates can't publish |
| // successfully because they're waiting on the index entries of |
| // previously-published crates to propagate. This means we try to |
| // publish in a loop and we remove crates once they're successfully |
| // published. Failed-to-publish crates get enqueued for another try |
| // later on. |
| for _ in 0..10 { |
| crates.retain(|krate| !publish(krate)); |
| |
| if crates.is_empty() { |
| break; |
| } |
| |
| println!( |
| "{} crates failed to publish, waiting for a bit to retry", |
| crates.len(), |
| ); |
| thread::sleep(Duration::from_secs(40)); |
| } |
| |
| assert!(crates.is_empty(), "failed to publish all crates"); |
| } |
| |
| "verify" => { |
| verify(&crates); |
| } |
| |
| s => panic!("unknown command: {}", s), |
| } |
| } |
| |
| fn read_crate(ws: Option<&Workspace>, manifest: &Path) -> Crate { |
| let mut name = None; |
| let mut version = None; |
| let mut workspace_version = None; |
| let mut publish = true; |
| let mut in_workspace = false; |
| for line in fs::read_to_string(manifest).unwrap().lines() { |
| if line.starts_with("[") { |
| in_workspace = line.starts_with("[workspace"); |
| continue; |
| } |
| |
| if name.is_none() && line.starts_with("name = \"") { |
| name = Some( |
| line.replace("name = \"", "") |
| .replace("\"", "") |
| .trim() |
| .to_string(), |
| ); |
| } |
| if line.starts_with("version = \"") { |
| let dst = if in_workspace { |
| &mut workspace_version |
| } else { |
| &mut version |
| }; |
| assert!(dst.is_none()); |
| *dst = Some( |
| line.replace("version = \"", "") |
| .replace("\"", "") |
| .trim() |
| .to_string(), |
| ); |
| } |
| if let Some(ws) = ws { |
| if version.is_none() && line.starts_with("version.workspace = true") { |
| version = Some(ws.version.clone()); |
| } |
| } |
| if line.starts_with("publish = false") { |
| publish = false; |
| } |
| } |
| let name = name.unwrap(); |
| let version = if !publish { |
| "0.0.0".to_string() |
| } else { |
| version.unwrap() |
| }; |
| Crate { |
| manifest: manifest.to_path_buf(), |
| name, |
| version, |
| workspace_version, |
| publish, |
| } |
| } |
| |
| fn bump_version(krate: &Crate, crates: &[Crate], patch: bool) { |
| let contents = fs::read_to_string(&krate.manifest).unwrap(); |
| let next_version = |krate: &Crate| -> String { |
| if CRATES_TO_PUBLISH.contains(&&krate.name[..]) { |
| bump( |
| &krate.version, |
| if patch { |
| BumpKind::Patch |
| } else { |
| BumpKind::Major |
| }, |
| ) |
| } else { |
| krate.version.clone() |
| } |
| }; |
| |
| let mut new_manifest = String::new(); |
| let mut is_deps = false; |
| let mut is_workspace = false; |
| for line in contents.lines() { |
| let mut rewritten = false; |
| if !is_deps && line.starts_with("version =") { |
| if CRATES_TO_PUBLISH.contains(&&krate.name[..]) { |
| println!( |
| "bump `{}` {} => {}", |
| krate.name, |
| krate.version, |
| next_version(krate), |
| ); |
| let new_line = if is_workspace { |
| let ws_version = krate.workspace_version.as_ref().unwrap(); |
| let next_version = bump( |
| ws_version, |
| if patch { |
| BumpKind::Patch |
| } else { |
| BumpKind::Major |
| }, |
| ); |
| line.replace(ws_version, &next_version) |
| } else { |
| line.replace(&krate.version, &next_version(krate)) |
| }; |
| new_manifest.push_str(&new_line); |
| rewritten = true; |
| } |
| } |
| |
| if line.starts_with("[") { |
| is_deps = line.contains("dependencies"); |
| is_workspace = line.contains("workspace"); |
| } |
| |
| for other in crates { |
| // If `other` isn't a published crate then it's not going to get a |
| // bumped version so we don't need to update anything in the |
| // manifest. |
| if !other.publish { |
| continue; |
| } |
| if !is_deps || !line.starts_with(&format!("{} ", other.name)) { |
| continue; |
| } |
| if !line.contains(&other.version) { |
| if !line.contains("version =") || !krate.publish { |
| continue; |
| } |
| panic!( |
| "{:?} has a dep on {} but doesn't list version {}", |
| krate.manifest, other.name, other.version |
| ); |
| } |
| rewritten = true; |
| new_manifest.push_str(&line.replace(&other.version, &next_version(other))); |
| break; |
| } |
| if !rewritten { |
| new_manifest.push_str(line); |
| } |
| new_manifest.push_str("\n"); |
| } |
| fs::write(&krate.manifest, new_manifest).unwrap(); |
| } |
| |
| enum BumpKind { |
| Major, |
| #[allow(dead_code)] |
| Minor, |
| Patch, |
| } |
| |
| /// Performs a major version bump increment on the semver version `version`. |
| /// |
| /// This function will perform a semver-major-version bump on the `version` |
| /// specified. This is used to calculate the next version of a crate in this |
| /// repository since we're currently making major version bumps for all our |
| /// releases. This may end up getting tweaked as we stabilize crates and start |
| /// doing more minor/patch releases, but for now this should do the trick. |
| fn bump(version: &str, bump: BumpKind) -> String { |
| let mut iter = version.split('.').map(|s| s.parse::<u32>().unwrap()); |
| let major = iter.next().expect("major version"); |
| let minor = iter.next().expect("minor version"); |
| let patch = iter.next().expect("patch version"); |
| |
| match bump { |
| BumpKind::Patch => { |
| format!("{}.{}.{}", major, minor, patch + 1) |
| } |
| BumpKind::Minor => { |
| format!("{}.{}.0", major, minor + 1) |
| } |
| BumpKind::Major if major != 0 => { |
| format!("{}.0.0", major + 1) |
| } |
| BumpKind::Major if minor != 0 => { |
| format!("0.{}.0", minor + 1) |
| } |
| BumpKind::Major => { |
| format!("0.0.{}", patch + 1) |
| } |
| } |
| } |
| |
| fn publish(krate: &Crate) -> bool { |
| if !CRATES_TO_PUBLISH.iter().any(|s| *s == krate.name) { |
| return true; |
| } |
| |
| // First make sure the crate isn't already published at this version. This |
| // script may be re-run and there's no need to re-attempt previous work. |
| let output = Command::new("curl") |
| .arg(&format!("https://crates.io/api/v1/crates/{}", krate.name)) |
| .output() |
| .expect("failed to invoke `curl`"); |
| if output.status.success() |
| && String::from_utf8_lossy(&output.stdout) |
| .contains(&format!("\"newest_version\":\"{}\"", krate.version)) |
| { |
| println!( |
| "skip publish {} because {} is latest version", |
| krate.name, krate.version, |
| ); |
| return true; |
| } |
| |
| let status = Command::new("cargo") |
| .arg("publish") |
| .current_dir(krate.manifest.parent().unwrap()) |
| .arg("--no-verify") |
| .status() |
| .expect("failed to run cargo"); |
| if !status.success() { |
| println!("FAIL: failed to publish `{}`: {}", krate.name, status); |
| return false; |
| } |
| |
| // // After we've published then make sure that the `wasmtime-publish` group is |
| // // added to this crate for future publications. If it's already present |
| // // though we can skip the `cargo owner` modification. |
| // let output = Command::new("curl") |
| // .arg(&format!( |
| // "https://crates.io/api/v1/crates/{}/owners", |
| // krate.name |
| // )) |
| // .output() |
| // .expect("failed to invoke `curl`"); |
| // if output.status.success() |
| // && String::from_utf8_lossy(&output.stdout).contains("wasmtime-publish") |
| // { |
| // println!( |
| // "wasmtime-publish already listed as an owner of {}", |
| // krate.name |
| // ); |
| // return true; |
| // } |
| |
| // // Note that the status is ignored here. This fails most of the time because |
| // // the owner is already set and present, so we only want to add this to |
| // // crates which haven't previously been published. |
| // let status = Command::new("cargo") |
| // .arg("owner") |
| // .arg("-a") |
| // .arg("github:bytecodealliance:wasmtime-publish") |
| // .arg(&krate.name) |
| // .status() |
| // .expect("failed to run cargo"); |
| // if !status.success() { |
| // panic!( |
| // "FAIL: failed to add wasmtime-publish as owner `{}`: {}", |
| // krate.name, status |
| // ); |
| // } |
| |
| true |
| } |
| |
| // Verify the current tree is publish-able to crates.io. The intention here is |
| // that we'll run `cargo package` on everything which verifies the build as-if |
| // it were published to crates.io. This requires using an incrementally-built |
| // directory registry generated from `cargo vendor` because the versions |
| // referenced from `Cargo.toml` may not exist on crates.io. |
| fn verify(crates: &[Crate]) { |
| drop(fs::remove_dir_all(".cargo")); |
| drop(fs::remove_dir_all("vendor")); |
| let vendor = Command::new("cargo") |
| .arg("vendor") |
| .stderr(Stdio::inherit()) |
| .output() |
| .unwrap(); |
| assert!(vendor.status.success()); |
| |
| fs::create_dir_all(".cargo").unwrap(); |
| fs::write(".cargo/config.toml", vendor.stdout).unwrap(); |
| |
| for krate in crates { |
| if !krate.publish { |
| continue; |
| } |
| verify_and_vendor(&krate); |
| } |
| |
| fn verify_and_vendor(krate: &Crate) { |
| let mut cmd = Command::new("cargo"); |
| cmd.arg("package") |
| .arg("--allow-dirty") |
| .arg("--manifest-path") |
| .arg(&krate.manifest) |
| .env("CARGO_TARGET_DIR", "./target"); |
| let status = cmd.status().unwrap(); |
| assert!(status.success(), "failed to verify {:?}", &krate.manifest); |
| let tar = Command::new("tar") |
| .arg("xf") |
| .arg(format!( |
| "../target/package/{}-{}.crate", |
| krate.name, krate.version |
| )) |
| .current_dir("./vendor") |
| .status() |
| .unwrap(); |
| assert!(tar.success()); |
| fs::write( |
| format!( |
| "./vendor/{}-{}/.cargo-checksum.json", |
| krate.name, krate.version |
| ), |
| "{\"files\":{}}", |
| ) |
| .unwrap(); |
| } |
| } |
