Allow for any git repo to be checked out

Author: ColinKinloch

gitlab-runner/examples/demo-runner.rs

@@ -123,6 +123,33 @@ impl Run {
                     }
                     Ok(())
                 }
+                "clone" => {
+                    let url = match p.next() {
+                        Some(url) => url,
+                        _ => {
+                            outputln!("Missing repo url as first argument");
+                            return Err(());
+                        }
+                    };
+                    let path = match p.next() {
+                        Some(path) => self.job.build_dir().join(path),
+                        _ => {
+                            outputln!("Missing repo output path as second argument");
+                            return Err(());
+                        }
+                    };
+                    let reference = p.next();
+
+                    Job::checkout_repo_inner(
+                        path.as_path(),
+                        url,
+                        reference,
+                        std::iter::empty::<&str>(),
+                        Some(1),
+                    )
+                    .map_err(|e| outputln!("Failed to checkout repo: {}", e.to_string()))?;
+                    Ok(())
+                }
                 "checkout" => {
                     let path = match p.next() {
                         Some(path) => self.job.build_dir().join(path),

gitlab-runner/src/client.rs

@@ -291,15 +291,25 @@ pub enum GitCheckoutError {
     #[error(transparent)]
     GitObjectPeel(#[from] gix::object::peel::to_kind::Error),
     #[error(transparent)]
+    GitObjsFindExisting(#[from] gix::objs::find::existing::Error),
+    #[error(transparent)]
     GitRefIterInit(#[from] gix::reference::iter::init::Error),
     #[error(transparent)]
+    GitRefFindExisting(#[from] gix::reference::find::existing::Error),
+    #[error(transparent)]
+    GitRefFind(#[from] gix::reference::find::Error),
+    #[error(transparent)]
+    GetRefPeel(#[from] gix::reference::peel::Error),
+    #[error(transparent)]
     GitPackedBufferOpen(#[from] gix::refs::packed::buffer::open::Error),
     #[error(transparent)]
     GitRefspecParse(#[from] gix::refspec::parse::Error),
     #[error(transparent)]
     GitHashDecode(#[from] gix::hash::decode::Error),
     #[error(transparent)]
     GitWorktreeCheckout(#[from] gix::worktree::state::checkout::Error),
+    #[error(transparent)]
+    GitHeadPeel(#[from] gix::head::peel::Error),
     #[error("Job does not allow fetch")]
     FetchNotAllowed,
     #[error("Failed to find commit")]

gitlab-runner/src/job.rs

@@ -355,22 +355,22 @@ impl Job {
         Self::checkout_repo_inner(
             repo_dir.path(),
             &self.response.git_info.repo_url,
-            &self.response.git_info.sha,
-            self.response.git_info.refspecs.iter(),
-            self.response.git_info.depth,
+            Some(&self.response.git_info.sha),
+            &self.response.git_info.refspecs,
+            Some(self.response.git_info.depth),
         )?;
 
         Ok(repo_dir.into_path())
     }
 
     /// Fetch and checkout worktree for job
     #[allow(clippy::result_large_err)]
-    fn checkout_repo_inner(
+    pub fn checkout_repo_inner(
         repo_dir: &Path,
         repo_url: &str,
-        sha: &str,
-        refspecs: impl Iterator<Item = impl AsRef<str>>,
-        depth: u32,
+        head_ref: Option<&str>,
+        refspecs: impl IntoIterator<Item = impl AsRef<str>>,
+        depth: Option<u32>,
     ) -> Result<(), GitCheckoutError> {
         let should_interrupt = AtomicBool::new(false);
         let mut progress = progress::Discard;
@@ -384,48 +384,92 @@ impl Job {
         )?;
 
         // Specify which refspecs are fetched from remote
-        let refspecs = refspecs
+        let mut refspecs = refspecs
+            .into_iter()
             .map(|s| {
                 refspec::parse(s.as_ref().into(), refspec::parse::Operation::Fetch)
                     .map(|r| r.to_owned())
             })
             .collect::<Result<Vec<_>, _>>()?;
 
-        let mut fetch_opts = remote::ref_map::Options::default();
-        fetch_opts.extra_refspecs.extend(refspecs);
-        fetch = fetch.with_fetch_options(fetch_opts);
+        let mut sha = None;
+
+        if let Some(head_ref) = head_ref {
+            if let Ok(object_id) = gix::ObjectId::from_hex(head_ref.as_bytes()) {
+                // TODO: I need to specify that the sha should be fetched from remote, right?
+                //  Is there a format for a sha as a refspec?
+                if let Ok(refspec) = refspec::parse(
+                    format!("+{head_ref}").as_str().into(),
+                    refspec::parse::Operation::Fetch,
+                ) {
+                    refspecs.push(refspec.to_owned());
+                }
+                sha = Some(object_id);
+            } else {
+                // TODO: For some reason this doesn't create refs/heads/{reference}
+                if let Ok(refspec) = refspec::parse(
+                    format!("+refs/heads/{head_ref}:refs/remotes/origin/{head_ref}")
+                        .as_str()
+                        .into(),
+                    refspec::parse::Operation::Fetch,
+                ) {
+                    refspecs.push(refspec.to_owned());
+                }
+            }
+        }
 
-        if depth > 0 {
-            fetch = fetch.with_shallow(remote::fetch::Shallow::DepthAtRemote(
-                NonZeroU32::new(depth).unwrap(),
-            ))
-        };
+        if !refspecs.is_empty() {
+            let mut fetch_opts = remote::ref_map::Options::default();
+            fetch_opts.extra_refspecs.extend(refspecs);
+            fetch = fetch.with_fetch_options(fetch_opts);
+        }
+
+        if let Some(depth) = depth {
+            if depth > 0 {
+                fetch = fetch.with_shallow(remote::fetch::Shallow::DepthAtRemote(
+                    NonZeroU32::new(depth).unwrap(),
+                ));
+            }
+        }
 
         let checkout_progress = progress.add_child("checkout".to_string());
         let (checkout, _outcome) =
             fetch.fetch_then_checkout(checkout_progress, &should_interrupt)?;
 
         let repo = checkout.persist();
 
-        // Checkout worktree at specific sha
-        let sha = gix::ObjectId::from_hex(sha.as_bytes())?;
-        let root_tree_id = repo
-            .try_find_object(sha)?
-            .ok_or(GitCheckoutError::MissingCommit)?;
+        let root_tree_id = if let Some(sha) = sha {
+            // Checkout worktree at specific sha
+            repo.try_find_object(sha)?
+                .ok_or(GitCheckoutError::MissingCommit)?
+        } else if let Some(reference) = head_ref {
+            repo
+                // TODO: This should be refs/heads/{reference} but it doesn't exist
+                .try_find_reference(format!("refs/remotes/origin/{reference}").as_str())?
+                .ok_or(GitCheckoutError::MissingCommit)?
+                .peel_to_id_in_place()?
+                .object()?
+        } else {
+            // Checkout head
+            repo.head()?
+                .try_peel_to_id_in_place()?
+                .ok_or(GitCheckoutError::MissingCommit)?
+                .object()?
+        };
         let root_tree = root_tree_id.peel_to_tree()?.id;
 
-        let workdir = repo.work_dir().ok_or_else(|| {
-            clone::checkout::main_worktree::Error::BareRepository {
-                git_dir: repo.git_dir().to_owned(),
-            }
-        })?;
-
         let index = index::State::from_tree(&root_tree, &repo.objects, Default::default())
             .map_err(|err| clone::checkout::main_worktree::Error::IndexFromTree {
                 id: root_tree,
                 source: err,
             })?;
 
+        let workdir = repo.work_dir().ok_or_else(|| {
+            clone::checkout::main_worktree::Error::BareRepository {
+                git_dir: repo.git_dir().to_owned(),
+            }
+        })?;
+
         let files_progress = progress.add_child_with_id(
             "files".to_string(),
             clone::checkout::main_worktree::ProgressId::CheckoutFiles.into(),