rust: add command to upload release artifacts

Author: indygreg

src/github.rs

@@ -8,12 +8,16 @@ use {
     octocrab::OctocrabBuilder,
     once_cell::sync::Lazy,
     serde::Deserialize,
-    std::{collections::HashMap, io::Read, path::PathBuf},
+    std::{
+        collections::{BTreeMap, BTreeSet},
+        io::Read,
+        path::PathBuf,
+    },
     zip::ZipArchive,
 };
 
-static SUFFIXES_BY_TRIPLE: Lazy<HashMap<&'static str, Vec<&'static str>>> = Lazy::new(|| {
-    let mut h = HashMap::new();
+static SUFFIXES_BY_TRIPLE: Lazy<BTreeMap<&'static str, Vec<&'static str>>> = Lazy::new(|| {
+    let mut h = BTreeMap::new();
 
     // macOS.
     let macos_suffixes = vec!["debug", "lto", "pgo", "pgo+lto", "install_only"];
@@ -168,3 +172,115 @@ pub async fn command_fetch_release_distributions(args: &ArgMatches<'_>) -> Resul
 
     Ok(())
 }
+
+pub async fn command_upload_release_distributions(args: &ArgMatches<'_>) -> Result<()> {
+    let dist_dir = PathBuf::from(args.value_of("dist").expect("dist should be specified"));
+    let datetime = args
+        .value_of("datetime")
+        .expect("datetime should be specified");
+    let tag = args.value_of("tag").expect("tag should be specified");
+    let ignore_missing = args.is_present("ignore_missing");
+    let token = args
+        .value_of("token")
+        .expect("token should be specified")
+        .to_string();
+    let organization = args
+        .value_of("organization")
+        .expect("organization should be specified");
+    let repo = args.value_of("repo").expect("repo should be specified");
+
+    let mut filenames = std::fs::read_dir(&dist_dir)?
+        .into_iter()
+        .map(|x| {
+            let path = x?.path();
+            let filename = path
+                .file_name()
+                .ok_or_else(|| anyhow!("unable to resolve file name"))?;
+
+            Ok(filename.to_string_lossy().to_string())
+        })
+        .collect::<Result<Vec<_>>>()?;
+    filenames.sort();
+
+    let filenames = filenames
+        .into_iter()
+        .filter(|x| x.contains(datetime) && x.starts_with("cpython-"))
+        .collect::<BTreeSet<_>>();
+
+    let mut python_versions = BTreeSet::new();
+    for filename in &filenames {
+        let parts = filename.split('-').collect::<Vec<_>>();
+        python_versions.insert(parts[1]);
+    }
+
+    let mut wanted_filenames = BTreeSet::new();
+    for version in python_versions {
+        for (triple, suffixes) in SUFFIXES_BY_TRIPLE.iter() {
+            for suffix in suffixes {
+                let extension = if suffix.contains("install_only") {
+                    "tar.gz"
+                } else {
+                    "tar.zst"
+                };
+
+                wanted_filenames.insert(format!(
+                    "cpython-{}-{}-{}-{}.{}",
+                    version, triple, suffix, datetime, extension
+                ));
+            }
+        }
+    }
+
+    let missing = wanted_filenames.difference(&filenames).collect::<Vec<_>>();
+    for f in &missing {
+        println!("missing release artifact: {}", f);
+    }
+    if !missing.is_empty() && !ignore_missing {
+        return Err(anyhow!("missing release artifacts"));
+    }
+
+    let client = OctocrabBuilder::new().personal_token(token).build()?;
+    let repo = client.repos(organization, repo);
+    let releases = repo.releases();
+
+    let release = if let Ok(release) = releases.get_by_tag(tag).await {
+        release
+    } else {
+        return Err(anyhow!(
+            "release {} does not exist; create it via GitHub web UI",
+            tag
+        ));
+    };
+
+    for filename in wanted_filenames.intersection(&filenames) {
+        let path = dist_dir.join(filename);
+        let file_data = std::fs::read(&path)?;
+
+        let mut url = release.upload_url.clone();
+        let path = url.path().to_string();
+
+        if let Some(path) = path.strip_suffix("%7B") {
+            url.set_path(path);
+        }
+
+        url.query_pairs_mut()
+            .clear()
+            .append_pair("name", filename.as_str());
+
+        println!("uploading {} to {}", filename, url);
+
+        let request = client
+            .request_builder(url, reqwest::Method::POST)
+            .header("Content-Length", file_data.len())
+            .header("Content-Type", "application/x-tar")
+            .body(file_data);
+
+        let response = client.execute(request).await?;
+
+        if !response.status().is_success() {
+            return Err(anyhow!("HTTP {}", response.status()));
+        }
+    }
+
+    Ok(())
+}

src/main.rs

@@ -963,6 +963,59 @@ fn main_impl() -> Result<()> {
                     .help("GitHub repository name"),
             ),
     );
+
+    let app = app.subcommand(
+        SubCommand::with_name("upload-release-distributions")
+            .about("Upload release distributions to a GitHub release")
+            .arg(
+                Arg::with_name("token")
+                    .long("--token")
+                    .required(true)
+                    .takes_value(true)
+                    .help("GitHub API token"),
+            )
+            .arg(
+                Arg::with_name("dist")
+                    .long("--dist")
+                    .required(true)
+                    .takes_value(true)
+                    .help("Directory with release artifacts"),
+            )
+            .arg(
+                Arg::with_name("datetime")
+                    .long("--datetime")
+                    .required(true)
+                    .takes_value(true)
+                    .help("Date/time tag associated with builds"),
+            )
+            .arg(
+                Arg::with_name("tag")
+                    .long("--tag")
+                    .required(true)
+                    .takes_value(true)
+                    .help("Release tag"),
+            )
+            .arg(
+                Arg::with_name("ignore_missing")
+                    .long("--ignore-missing")
+                    .help("Continue even if there are missing artifacts"),
+            )
+            .arg(
+                Arg::with_name("organization")
+                    .long("--org")
+                    .takes_value(true)
+                    .default_value("indygreg")
+                    .help("GitHub organization"),
+            )
+            .arg(
+                Arg::with_name("repo")
+                    .long("--repo")
+                    .takes_value(true)
+                    .default_value("python-build-standalone")
+                    .help("GitHub repository name"),
+            ),
+    );
+
     let app = app.subcommand(
         SubCommand::with_name("validate-distribution")
             .about("Ensure a distribution archive conforms to standards")
@@ -989,7 +1042,13 @@ fn main_impl() -> Result<()> {
                 .unwrap()
                 .block_on(crate::github::command_fetch_release_distributions(args))
         }
-
+        ("upload-release-distributions", Some(args)) => {
+            tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .build()
+                .unwrap()
+                .block_on(crate::github::command_upload_release_distributions(args))
+        }
         ("validate-distribution", Some(args)) => command_validate_distribution(args),
         _ => Err(anyhow!("invalid sub-command")),
     }