feat: module for manipulating Git refs — radicle-ci-broker

Add helper functions to construct plain branch names (“main”), full branch refs (“refs/heads/main”), and namespaced full branch names (“refs/namespaces/$NID/refs/heads/main”).

Keeping track of while only using RefStrings is too hard to get right. We need to use the types provided by the radicle crate: BranchName, Qualified, and Namespaced. Even if I find the type names less than obvious, they’re much better than plain RefStrings.

Signed-off-by: Lars Wirzenius liw@liw.fi

fix: use new Git refs module, fix bugs found

This is a huge change, but it’s mostly a few kinds of similar changes in a lot of places. Unfortunately, they were not easy to tease apart into small, easily reviewed commits.

Use the Git ref types created by the new refs module. Fix problems this exposes.

The CiEvent enum variants for branch events now use the BranchName type for branch names. In other words, they have a plain branch name. The CiEvent::from_node_event constructor also always sets the branch name to a plain branch name, instead of a name spaced ref for updated or deleted branches. The ci_event.rs module’s unit tests have been fixed to use the correct kind of Git ref in each test. (It used to be a mess.)

The CI event filter “Branch” now contains a BranchName, previously a RefString. This should not break anything, as a RefString will always work as a BranchName.

The DefaultBranch filter now works, because it compares plain branch names, where it previously would compare a plain and a name spaced branch name, and those are never equal.

“cibtool trigger” and “cibtool event add” now add branch events with a plain branch instead of a name spaced ref.

Signed-off-by: Lars Wirzenius liw@liw.fi

 when I run ./env.sh cib --config config.yaml queued
 when I run cibtool --db ci-broker.db run list --json
 then stdout contains "/refs/heads/main"
 then stdout doesn't contain "/refs/heads/oksa"
 then stdout contains ""main""
 then stdout doesn't contain "oksa"
 ~~~
 ~~~{#filter-branchcreated.yaml .file .json}

 |:----------------|:--------------------|:------------|
 | `BranchCreated` | `from_node`         | `NodeId`    |
 |                 | `repo`              | `RepoId`    |
 |                 | `branch`            | `RefSting`  |
 |                 | `branch`            | `BranchName`|
 |                 | `tip`               | `Oid`       |
 ## `BranchUpdated`

 |:----------------|:------------|:------------|
 | `BranchUpdated` | `from_node` | `NodeId`    |
 |                 | `repo`      | `RepoId`    |
 |                 | `branch`    | `RefSting`  |
 |                 | `branch`    | `BranchName`|
 |                 | `tip`       | `Oid`       |
 |                 | `old_tip`   | `Oid`       |

 |:----------------|:------------|:------------|
 | `BranchDeleted` | `from_node` | `NodeId`    |
 |                 | `repo`      | `RepoId`    |
 |                 | `branch`    | `RefString` |
 |                 | `tip`       | ` Oid`      |
 |                 | `branch`    | `BranchName`|
 |                 | `tip`       | `Oid`       |
 ## `PatchCreated`

 use serde::Serialize;
 use radicle::{
     git::{Oid, RefString},
     git::Oid,
     prelude::{NodeId, RepoId},
     storage::ReadStorage,
     Profile, Storage,

     #[error(transparent)]
     Page(#[from] PageError),
     #[error("failed to interpret as a Git reference: {0:?}")]
     RefString(String, #[source] radicle::git::fmt::Error),
     #[error("failed to read event ID from file {0}")]
     ReadEventId(PathBuf, #[source] std::io::Error),

 use clap::ValueEnum;
 use radicle::patch::PatchId;
 use radicle_ci_broker::refs::branch_ref;
 #[allow(unused_imports)] // FIXME
 use radicle_ci_broker::{
     filter::EventFilter, node_event_source::NodeEventSource, util::read_file_as_objectid,
     filter::EventFilter, node_event_source::NodeEventSource, refs::ref_string,
     util::read_file_as_objectid,
 };
 use super::*;

             self.lookup_commit(rid, &self.commit)?
         };
         let name = format!("refs/namespaces/{}/refs/heads/{}", nid, self.name.as_str());
         let name =
             RefString::try_from(name.clone()).map_err(|e| CibToolError::RefString(name, e))?;
         let branch_name = branch_ref(&ref_string(&self.name).map_err(CibToolError::RefError)?)
             .map_err(CibToolError::RefError)?;
         let event = match &self.kind {
             EventKind::BranchCreated => {
                 if self.base.is_some() {
                     return Err(CibToolError::NoBaseAllowed);
                 } else {
                     CiEvent::branch_created(nid, rid, &name, oid).map_err(CibToolError::CiEvent)?
                     CiEvent::branch_created(nid, rid, &branch_name, oid)
                         .map_err(CibToolError::CiEvent)?
                 }
             }
             EventKind::BranchUpdated => {

                     } else {
                         self.lookup_commit(rid, base)?
                     };
                     CiEvent::branch_updated(nid, rid, &name, oid, base)
                     CiEvent::branch_updated(nid, rid, &branch_name, oid, base)
                         .map_err(CibToolError::CiEvent)?
                 } else {
                     return Err(CibToolError::BaseRequired);
                 }
             }
             EventKind::BranchDeleted => {
                 CiEvent::branch_deleted(nid, rid, &name, oid).map_err(CibToolError::CiEvent)?
             }
             EventKind::BranchDeleted => CiEvent::branch_deleted(nid, rid, &branch_name, oid)
                 .map_err(CibToolError::CiEvent)?,
             EventKind::PatchCreated => {
                 if let Some(patch_id) = &self.patch_id {
                     CiEvent::patch_created(nid, rid, *patch_id, oid)

 use radicle_ci_broker::refs::{branch_ref, ref_string};
 use super::*;
 /// Trigger a CI run.

         let oid = util::oid_from_cli_arg(&profile, rid, &self.commit)?;
         let base = util::lookup_commit(&profile, rid, &format!("{oid}^")).unwrap_or(oid);
         let name = format!("refs/namespaces/{nid}/refs/heads/{}", self.name.as_str());
         let name =
             RefString::try_from(name.clone()).map_err(|e| CibToolError::RefString(name, e))?;
         let event =
             CiEvent::branch_updated(nid, rid, &name, oid, base).map_err(CibToolError::CiEvent)?;
         let branch_name = branch_ref(&ref_string(&self.name).map_err(CibToolError::RefError)?)
             .map_err(CibToolError::RefError)?;
         let event = CiEvent::branch_updated(nid, rid, &branch_name, oid, base)
             .map_err(CibToolError::CiEvent)?;
         if self.stdout {
             let json = event.to_pretty_json().map_err(CibToolError::EventToJson2)?;

 use radicle::{
     cob::patch::PatchId,
     crypto::PublicKey,
     git::Oid,
     git::RefString,
     git::{BranchName, Namespaced, Oid, RefString},
     node::{Event, NodeId},
     prelude::RepoId,
     storage::RefUpdate,
 };
 use crate::logger;
 use crate::refs::{branch_from_namespaced, namespaced_from_str};
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
 #[non_exhaustive]

     BranchCreated {
         from_node: NodeId,
         repo: RepoId,
         branch: RefString,
         branch: BranchName,
         tip: Oid,
     },
     BranchUpdated {
         from_node: NodeId,
         repo: RepoId,
         branch: RefString,
         branch: BranchName,
         tip: Oid,
         old_tip: Oid,
     },
     BranchDeleted {
         from_node: NodeId,
         repo: RepoId,
         branch: RefString,
         branch: BranchName,
         tip: Oid,
     },
     PatchCreated {

         }
     }
     pub fn branch(&self) -> Option<&RefString> {
     pub fn branch(&self) -> Option<&BranchName> {
         match self {
             Self::V1(CiEventV1::Shutdown) => None,
             Self::V1(CiEventV1::BranchCreated { branch, .. }) => Some(branch),

     pub fn branch_created(
         from_node: NodeId,
         repo: RepoId,
         branch: &str,
         branch: &BranchName,
         tip: Oid,
     ) -> Result<Self, CiEventError> {
         assert!(!branch.starts_with("refs/"));
         Ok(Self::V1(CiEventV1::BranchCreated {
             from_node,
             repo,
             branch: ref_string(branch)?,
             branch: branch.clone(),
             tip,
         }))
     }

                 for update in updated {
                     let e = match update {
                         RefUpdate::Created { name, oid } => {
                             let origin = originator(name.to_ref_string())?;
                             let origin = originator(name.to_namespaced().unwrap())?;
                             if let Ok(patch_id) = patch_id(name) {
                                 Self::patch_created(origin, *rid, patch_id, *oid)
                             } else if let Ok(branch) = namespaced_branch(name) {
                             } else if let Ok(branch) = namespaced_from_str(name) {
                                 let branch = branch_from_namespaced(&branch)
                                     .map_err(|err| CiEventError::branch_name(&branch, err))?;
                                 Self::branch_created(origin, *rid, &branch, *oid)?
                             } else {
                                 continue;
                             }
                         }
                         RefUpdate::Updated { name, old, new } => {
                             let origin = originator(name.to_ref_string())?;
                             let origin = originator(name.to_namespaced().unwrap())?;
                             if let Ok(patch_id) = patch_id(name) {
                                 Self::patch_updated(origin, *rid, patch_id, *new)
                             } else if namespaced_branch(name).is_ok() {
                                 Self::branch_updated(origin, *rid, name, *new, *old)?
                             } else if let Ok(branch) = namespaced_from_str(name) {
                                 let branch = branch_from_namespaced(&branch)
                                     .map_err(|err| CiEventError::branch_name(&branch, err))?;
                                 Self::branch_updated(origin, *rid, &branch, *new, *old)?
                             } else {
                                 continue;
                             }
                         }
                         RefUpdate::Deleted { name, oid } => {
                             let origin = originator(name.to_ref_string())?;
                             Self::branch_deleted(origin, *rid, name, *oid)?
                             let origin = originator(name.to_namespaced().unwrap())?;
                             let branch = namespaced_from_str(name)
                                 .map_err(|err| CiEventError::branch_name(name, err))?;
                             let branch = branch_from_namespaced(&branch)
                                 .map_err(|err| CiEventError::branch_name(&branch, err))?;
                             Self::branch_deleted(origin, *rid, &branch, *oid)?
                         }
                         RefUpdate::Skipped { .. } => continue,
                     };

     }
 }
 fn originator(name: RefString) -> Result<PublicKey, CiEventError> {
     if let Some(qualified) = name.clone().into_qualified() {
         if let Some(namespaced) = qualified.to_namespaced() {
             return PublicKey::from_namespaced(&namespaced)
                 .map_err(|err| CiEventError::key_from_namespaced(&name, err));
         }
     }
     Err(CiEventError::without_namespace2(name.as_str()))
 }
 fn ref_string(s: &str) -> Result<RefString, CiEventError> {
     RefString::try_from(s).map_err(|e| CiEventError::ref_string(s, e))
 }
 fn branch_from_namspeced_ref(branch: &str) -> Result<RefString, CiEventError> {
     ref_string(&namespaced_branch(branch).map_err(|_| CiEventError::without_namespace2(branch))?)
 fn originator(name: Namespaced) -> Result<PublicKey, CiEventError> {
     PublicKey::from_namespaced(&name).map_err(|err| CiEventError::key_from_namespaced(&name, err))
 }
 pub struct CiEvents {

     #[error("updated ref name has no name space: {0:?})")]
     WithoutNamespace2(String),
     #[error("failed to create a RefString from {0:?}")]
     RefString(String, radicle::git::fmt::Error),
     #[error("failed to create a branch name from {0:?}")]
     BranchName(String, crate::refs::RefError),
     #[error("failed to read broker events file {0}")]
     ReadFile(PathBuf, #[source] std::io::Error),

     #[error("failed to encode CI event as JSON")]
     ToJson(#[source] serde_json::Error),
     #[error(transparent)]
     Parwe(#[from] ParseError),
 }
 impl CiEventError {
     fn without_namespace2(refname: &str) -> Self {
         Self::WithoutNamespace2(refname.into())
     }
     fn ref_string(name: &str, err: radicle::git::fmt::Error) -> Self {
         Self::RefString(name.into(), err)
     fn branch_name(name: &str, err: crate::refs::RefError) -> Self {
         Self::BranchName(name.into(), err)
     }
     fn read_file(filename: &Path, err: std::io::Error) -> Self {

         Self::NotJson(filename.into(), err)
     }
     fn key_from_namespaced(name: &RefString, err: radicle_crypto::PublicKeyError) -> Self {
     fn key_from_namespaced(name: &Namespaced, err: radicle_crypto::PublicKeyError) -> Self {
         Self::KeyFromNamespaced(name.to_ref_string(), err)
     }
 }

     use radicle::{prelude::NodeId, storage::RefUpdate};
     use std::str::FromStr;
     use crate::refs::ref_string;
     const MAIN_BRANCH_REF_NAME: &str =
         "refs/namespaces/z6MkiB8T5cBEQHnrs2MgjMVqvpSVj42X81HjKfFi2XBoMbtr/refs/heads/main";
     const MAIN_BRANCH_NAME: &str = "main";
     const PATCH_REF_NAME: &str =
         "refs/namespaces/z6MkiB8T5cBEQHnrs2MgjMVqvpSVj42X81HjKfFi2XBoMbtr/refs/heads/patches/f9fa90725474de9002be503ae3cda4670c9a174";

         oid_from(OID)
     }
     fn refstring(s: &str) -> RefString {
         RefString::try_from(s).unwrap()
     fn namespaced_main<'a>() -> Namespaced<'a> {
         ref_string(MAIN_BRANCH_REF_NAME)
             .unwrap()
             .to_namespaced()
             .unwrap()
             .to_owned()
     }
     fn plain_main() -> BranchName {
         branch_from_namespaced(&namespaced_main()).unwrap()
     }
     #[test]

             remote: nid(),
             rid: rid(),
             updated: vec![RefUpdate::Skipped {
                 name: refstring(MAIN_BRANCH_REF_NAME),
                 name: ref_string(MAIN_BRANCH_REF_NAME).unwrap(),
                 oid: oid(),
             }],
         };

     #[test]
     fn branch_created() {
         let rid = rid();
         let main = refstring(MAIN_BRANCH_NAME);
         let oid = oid();
         let event = Event::RefsFetched {
             remote: nid(),
             rid,
             updated: vec![RefUpdate::Created {
                 name: refstring(MAIN_BRANCH_REF_NAME),
                 name: namespaced_main().to_ref_string(),
                 oid,
             }],
         };

                             repo,
                             branch,
                             tip,
                         }) if repo == rid && branch == main && tip == oid => {}
                         }) if repo == rid && branch == plain_main() && tip == oid => {}
                         _ => panic!("should not succeed that way"),
                     }
                 }

             remote: nid(),
             rid,
             updated: vec![RefUpdate::Updated {
                 name: refstring(PATCH_REF_NAME),
                 name: ref_string(PATCH_REF_NAME).unwrap(),
                 old: oid,
                 new: oid,
             }],

     }
 }
 pub fn namespaced_branch(refname: &str) -> Result<String, ParseError> {
     logger::debug2(format!("namespaced_branch: refname={refname:?}"));
     const PAT_BRANCH: &str = r"^refs/namespaces/[^/]+/refs/heads/(.+)$";
     let push_re = Regex::new(PAT_BRANCH).map_err(|e| ParseError::Regex(PAT_BRANCH, e))?;
     if let Some(push_captures) = push_re.captures(refname) {
         if let Some(branch) = push_captures.get(1) {
             let branch = branch.as_str().to_string();
             logger::debug2(format!("namespaced_branch: result={branch:?}"));
             return Ok(branch);
         }
     }
     Err(ParseError::NotBranch(refname.into()))
 }
 fn patch_id(refname: &str) -> Result<PatchId, ParseError> {
     const PAT_PATCH: &str = r"^refs/namespaces/[^/]+/refs/heads/patches/([^/]+)$";
     let patch_re = Regex::new(PAT_PATCH).map_err(|e| ParseError::regex(PAT_PATCH, e))?;

     #[error("Git ref name includes unacceptable Git object id: {0:?}")]
     Oid(String, radicle::git::raw::Error),
     #[error("failed to create a Git branch name from {0:?}")]
     BranchName(String, #[source] crate::refs::RefError),
 }
 impl ParseError {

 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
 mod test_namespaced_branch {
     use super::{namespaced_branch, ParseError};
     #[test]
     fn empty() {
         assert!(matches!(
             namespaced_branch(""),
             Err(ParseError::NotBranch(_))
         ));
     }
     #[test]
     fn lacks_namespace() {
         assert!(matches!(
             namespaced_branch(""),
             Err(ParseError::NotBranch(_))
         ));
     }
     #[test]
     fn has_namespace() {
         let x = namespaced_branch("refs/namespaces/DID/refs/heads/main");
         assert!(x.is_ok());
         assert_eq!(x.unwrap(), "main");
     }
     #[test]
     fn has_namespace_with_path() {
         let x = namespaced_branch("refs/namespaces/DID/refs/heads/liw/debug/this/path");
         assert!(x.is_ok());
         assert_eq!(x.unwrap(), "liw/debug/this/path");
     }
 }
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
 mod test_patch_id {
     use super::{patch_id, Oid, ParseError};

 use radicle::{
     cob::patch::PatchId,
     git::{raw::ObjectType, Oid, RefString},
     git::{raw::ObjectType, BranchName, Oid},
     node::NodeId,
     prelude::{Profile, RepoId},
     storage::git::Repository,
 };
 use crate::{
     ci_event::{namespaced_branch, CiEvent, CiEventV1},
     ci_event::{CiEvent, CiEventV1},
     config::TriggerConfig,
     refs::ref_string,
 };
 #[cfg(test)]

     Repository(RepoId),
     /// Event is for a specific branch.
     Branch(RefString),
     Branch(BranchName),
     /// Event if for the default branch for the repository.
     DefaultBranch,

     }
     pub fn allows(&self, event: &CiEvent) -> bool {
         self.decide(event).allowed
         let dec = self.decide(event);
         dec.allowed
     }
     pub fn from_file(filename: &Path) -> Result<Vec<Self>, FilterError> {

 }
 fn is_default_branch(repo_id: &RepoId, wanted: &str) -> bool {
     if let Ok(default) = get_default_branch(repo_id) {
         if let Ok(default) = namespaced_branch(&default) {
             if let Ok(wanted) = namespaced_branch(wanted) {
                 return default == wanted;
             }
     if let Ok(wanted) = ref_string(wanted) {
         if let Ok(default) = get_default_branch(repo_id) {
             return wanted == default;
         }
     }
     false
 }
 pub fn get_default_branch(repo_id: &RepoId) -> Result<String, Box<dyn std::error::Error>> {
 pub fn get_default_branch(repo_id: &RepoId) -> Result<BranchName, Box<dyn std::error::Error>> {
     let profile = Profile::load()?;
     let path = profile.storage.path().join(repo_id.canonical());
     let repo = Repository::open(path, *repo_id)?;
     let proj = repo.project()?;
     let def = format!(
         "{}/refs/heads/{}",
         profile.id().to_namespace(),
         proj.default_branch()
     );
     Ok(def)
     Ok(proj.default_branch().clone())
 }
 fn has_file(repo_id: &RepoId, oid: &Oid, filename: &Path) -> bool {

     use qcheck_macros::quickcheck;
     use radicle::prelude::{Did, RepoId};
     use crate::refs::branch_from_str;
     use super::*;
     fn did() -> Did {

         PatchId::from(other_oid())
     }
     fn refstring(s: &str) -> RefString {
         RefString::try_from(s).unwrap()
     }
     fn shutdown() -> CiEvent {
         CiEvent::V1(CiEventV1::Shutdown)
     }