Add patchable init

Author: nightkr

rust/patchable/README.md

@@ -37,3 +37,11 @@ It currently recognizes the following keys:
 
 - `upstream` - the URL of the upstream repository (such as `https://github.com/apache/druid.git`)
 - `base` - the commit hash of the upstream base commit (such as `7cffb81a8e124d5f218f9af16ad685acf5e9c67c`)
+
+### Template
+
+Instead of creating this manually, run `patchable init`:
+
+```toml
+cargo patchable init druid 28.0.0 --upstream=https://github.com/apache/druid.git --base=druid-28.0.0
+```

rust/patchable/src/main.rs

@@ -5,20 +5,29 @@ mod repo;
 mod utils;
 
 use core::str;
-use std::path::{Path, PathBuf};
+use std::{
+    fs::File,
+    io::Write,
+    path::{Path, PathBuf},
+};
 
 use git2::Repository;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use snafu::{OptionExt, ResultExt as _, Snafu};
 use tracing_subscriber::{layer::SubscriberExt as _, util::SubscriberInitExt as _};
 
 #[derive(clap::Parser)]
 struct ProductVersion {
+    /// The product name slug (such as druid)
     product: String,
+
+    /// The product version (such as 28.0.0)
+    ///
+    /// Should not contain a v prefix.
     version: String,
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Serialize)]
 struct ProductVersionConfig {
     upstream: String,
     base: String,
@@ -101,6 +110,22 @@ enum Cmd {
         #[clap(flatten)]
         pv: ProductVersion,
     },
+
+    /// Creates a patchable.toml for a given product version
+    Init {
+        #[clap(flatten)]
+        pv: ProductVersion,
+
+        /// The upstream URL (such as https://github.com/apache/druid.git)
+        #[clap(long)]
+        upstream: String,
+
+        /// The upstream commit-ish (such as druid-28.0.0) that the patch series applies to
+        ///
+        /// Refs (such as tags and branches) will be resolved to commit IDs.
+        #[clap(long)]
+        base: String,
+    },
 }
 
 #[derive(Debug, Snafu)]
@@ -118,6 +143,18 @@ pub enum Error {
         source: toml::de::Error,
         path: PathBuf,
     },
+    #[snafu(display("failed to serialize config"))]
+    SerializeConfig { source: toml::ser::Error },
+    #[snafu(display("failed to create patch dir at {path:?}"))]
+    CreatePatchDir {
+        source: std::io::Error,
+        path: PathBuf,
+    },
+    #[snafu(display("failed to save config to {path:?}"))]
+    SaveConfig {
+        source: std::io::Error,
+        path: PathBuf,
+    },
 
     #[snafu(display("failed to find images repository"))]
     FindImagesRepo { source: git2::Error },
@@ -208,7 +245,7 @@ fn main() -> Result<()> {
             .context(OpenProductRepoForCheckoutSnafu)?;
 
             let base_commit =
-                repo::ensure_commit_exists_or_fetch(&product_repo, &config.base, &config.upstream)
+                repo::resolve_commitish_or_fetch(&product_repo, &config.base, &config.upstream)
                     .context(FetchBaseCommitSnafu)?;
             let patched_commit = patch::apply_patches(&product_repo, &ctx.patch_dir(), base_commit)
                 .context(ApplyPatchesSnafu)?;
@@ -228,6 +265,7 @@ fn main() -> Result<()> {
                 "worktree is ready!"
             );
         }
+
         Cmd::Export { pv } => {
             let ctx = ProductVersionContext {
                 pv,
@@ -288,6 +326,40 @@ fn main() -> Result<()> {
                 "worktree is exported!"
             );
         }
+
+        Cmd::Init { pv, upstream, base } => {
+            let ctx = ProductVersionContext {
+                pv,
+                images_repo_root,
+            };
+
+            let product_repo_root = ctx.repo();
+            let product_repo = tracing::info_span!(
+                "finding product repository",
+                product.repository = ?product_repo_root,
+            )
+            .in_scope(|| repo::ensure_bare_repo(&product_repo_root))
+            .context(OpenProductRepoForCheckoutSnafu)?;
+
+            tracing::info!(?base, "resolving base commit-ish");
+            let base_commit = repo::resolve_commitish_or_fetch(&product_repo, &base, &upstream)
+                .context(FetchBaseCommitSnafu)?;
+            tracing::info!(?base, base.commit = ?base_commit, "resolved base commit");
+
+            let config = ProductVersionConfig {
+                upstream,
+                base: base.to_string(),
+            };
+            let config_path = ctx.config_path();
+            if let Some(config_dir) = config_path.parent() {
+                std::fs::create_dir_all(config_dir)
+                    .context(CreatePatchDirSnafu { path: config_dir })?;
+            }
+            let config_toml = toml::to_string_pretty(&config).context(SerializeConfigSnafu)?;
+            File::create_new(&config_path)
+                .and_then(|mut f| f.write_all(config_toml.as_bytes()))
+                .context(SaveConfigSnafu { path: config_path })?;
+        }
     }
 
     Ok(())

rust/patchable/src/repo.rs

@@ -57,7 +57,7 @@ pub enum Error {
         target: error::CommitRef,
     },
 
-    #[snafu(display("failed to find {commit} in {repo}"))]
+    #[snafu(display("failed to find commit {commit} in {repo}"))]
     FindCommit {
         source: git2::Error,
         repo: error::RepoPath,
@@ -105,14 +105,16 @@ pub fn ensure_bare_repo(path: &Path) -> Result<Repository> {
     }
 }
 
-/// Fetch `commit` from `upstream_url`, if it doesn't already exist.
+/// Try to resolve `commitish` locally. If it doesn't exist, try to fetch it from `upstream_url`.
+///
+/// Returns the resolved commit ID.
 #[tracing::instrument(skip(repo))]
-pub fn ensure_commit_exists_or_fetch(
+pub fn resolve_commitish_or_fetch(
     repo: &Repository,
-    commit: &str,
+    commitish: &str,
     upstream_url: &str,
 ) -> Result<Oid> {
-    let commit = match repo.revparse_single(commit) {
+    let commit = match repo.revparse_single(commitish) {
         Ok(commit_obj) => {
             tracing::info!("base commit exists, reusing");
             Ok(commit_obj)
@@ -128,9 +130,10 @@ pub fn ensure_commit_exists_or_fetch(
                     url: upstream_url,
                 })?
                 .fetch(
-                    &[commit],
+                    &[commitish],
                     Some(
                         FetchOptions::new()
+                            .update_fetchhead(true)
                             // TODO: could be 1, CLI option maybe?
                             .depth(0),
                     ),
@@ -139,14 +142,18 @@ pub fn ensure_commit_exists_or_fetch(
                 .with_context(|_| FetchSnafu {
                     repo,
                     url: upstream_url,
-                    refs: vec![commit.to_string()],
+                    refs: vec![commitish.to_string()],
                 })?;
             tracing::info!("fetched base commit");
-            repo.revparse_single(commit)
+            // FETCH_HEAD is written by Remote::fetch to be the last reference fetched
+            repo.revparse_single("FETCH_HEAD")
         }
         Err(err) => Err(err),
     }
-    .context(FindCommitSnafu { repo, commit })?;
+    .context(FindCommitSnafu {
+        repo,
+        commit: commitish,
+    })?;
     Ok(commit
         .peel_to_commit()
         .context(FindCommitSnafu { repo, commit })?