cfb6998 refactor: use ergo in event commands — radicle-ci-broker

radicle-ci-broker

rad:zwTxygwuz5LDGBq255RA2CbNGrz8

Radicle CI broker

refactor: use ergo in event commands

Lars Wirzenius committed 8 months ago

commit cfb699805782e043d713cc9410f7e30838b1db50
parent 1855817

2 files changed +41 -111

modified src/bin/cibtool.rs

@@ -18,12 +18,7 @@ use std::{

 use clap::Parser;
 use radicle::{
     git::Oid,
     prelude::{NodeId, RepoId},
     storage::ReadStorage,
     Profile, Storage,
 };
 use radicle::{git::Oid, prelude::NodeId, Profile};
 use radicle_ci_broker::{
     broker::BrokerError,

@@ -253,33 +248,9 @@ enum CibToolError {

     #[error("failed to look up node profile")]
     Profile(#[source] radicle::profile::Error),
     #[error("failed to look up open node storage")]
     Storage(#[source] radicle::storage::Error),
     #[error("failed to list repositories in node storage")]
     Repositories(#[source] radicle::storage::Error),
     #[error("failed to look up project info for repository {0}")]
     Project(RepoId, #[source] radicle::identity::doc::PayloadError),
     #[error("node has more than one repository called {0}")]
     DuplicateRepositories(String),
     #[error("node has no repository called: {0}")]
     NotFound(String),
     #[error("cannot find CI run with id {0}")]
     RunNotFound(RunId),
     #[error("failed to open git repository in node storage: {0}")]
     RepoOpen(RepoId, #[source] radicle::storage::RepositoryError),
     #[error("failed to get project information for {0}")]
     GetProject(RepoId, #[source] radicle::storage::RepositoryError),
     #[error("failed to parse git ref as a commit id: {0}")]
     RevParse(String, #[source] radicle::git::raw::Error),
     #[error(transparent)]
     Broker(#[from] BrokerError),

@@ -389,4 +360,7 @@ enum CibToolError {

     #[error(transparent)]
     Trigger(#[from] cibtoolcmd::TriggerError),
     #[error(transparent)]
     Event(#[from] cibtoolcmd::EventError),
 }

modified src/bin/cibtoolcmd/event.rs

@@ -2,11 +2,10 @@ use std::io::Write;

 use clap::ValueEnum;
 use radicle::patch::PatchId;
 use radicle_ci_broker::refs::branch_ref;
 use radicle::{git::BranchName, patch::PatchId, storage::git::Repository};
 use radicle_ci_broker::{
     filter::EventFilter, node_event_source::NodeEventSource, refs::ref_string,
     util::read_file_as_objectid,
     ergo, filter::EventFilter, node_event_source::NodeEventSource, refs::branch_ref,
     refs::ref_string, util::read_file_as_objectid,
 };
 use super::*;

@@ -117,92 +116,39 @@ pub struct AddEvent {

 }
 impl AddEvent {
     fn lookup_nid(&self) -> Result<NodeId, CibToolError> {
         let profile = Profile::load().map_err(CibToolError::Profile)?;
         Ok(*profile.id())
     }
     fn lookup_rid(&self, wanted: &str) -> Result<RepoId, CibToolError> {
         let profile = Profile::load().map_err(CibToolError::Profile)?;
         let storage =
             Storage::open(profile.storage(), profile.info()).map_err(CibToolError::Storage)?;
         let mut rid = None;
         let repo_infos = storage.repositories().map_err(CibToolError::Repositories)?;
         for ri in repo_infos {
             let project = ri
                 .doc
                 .project()
                 .map_err(|e| CibToolError::Project(ri.rid, e))?;
             if project.name() == wanted {
                 if rid.is_some() {
                     return Err(CibToolError::DuplicateRepositories(wanted.into()));
                 }
                 rid = Some(ri.rid);
             }
         }
         if let Some(rid) = rid {
             Ok(rid)
     fn branch(&self, r: &ergo::Radicle, repo: &Repository) -> Result<BranchName, TriggerError> {
         if let Some(name) = &self.name {
             Ok(branch_ref(&ref_string(name)?)?)
         } else {
             Err(CibToolError::NotFound(wanted.into()))
             let project = r.project(&repo.id).map_err(TriggerError::Ergonomic)?;
             Ok(project.default_branch().clone())
         }
     }
     fn lookup_commit(&self, rid: RepoId, gitref: &str) -> Result<Oid, CibToolError> {
         let profile = Profile::load().map_err(CibToolError::Profile)?;
         let storage =
             Storage::open(profile.storage(), profile.info()).map_err(CibToolError::Storage)?;
         let repo = storage
             .repository(rid)
             .map_err(|e| CibToolError::RepoOpen(rid, e))?;
         let object = repo
             .backend
             .revparse_single(gitref)
             .map_err(|e| CibToolError::RevParse(gitref.into(), e))?;
         Ok(object.id().into())
     }
 }
 impl Leaf for AddEvent {
     fn run(&self, args: &Args) -> Result<(), CibToolError> {
         let nid = self.lookup_nid()?;
         let r = ergo::Radicle::new().map_err(EventError::Ergonomic)?;
         let rid = if let Ok(rid) = RepoId::from_urn(&self.repo) {
             rid
         } else {
             self.lookup_rid(&self.repo)?
         };
         let profile = r.profile();
         let nid = *profile.id();
         let oid = if let Ok(rid) = Oid::from_str(&self.commit) {
             rid
         } else {
             self.lookup_commit(rid, &self.commit)?
         };
         let repo = r
             .repository_by_name(&self.repo)
             .map_err(EventError::Ergonomic)?;
         let branch_name = if let Some(name) = &self.name {
             branch_ref(&ref_string(name).map_err(CibToolError::RefError)?)
                 .map_err(CibToolError::RefError)?
         } else {
             let profile = util::load_profile()?;
             let repo = profile
                 .storage
                 .repository(rid)
                 .map_err(|err| CibToolError::RepoOpen(rid, err))?;
             let project = repo
                 .project()
                 .map_err(|err| CibToolError::GetProject(rid, err))?;
             project.default_branch().clone()
         };
         let oid = r
             .resolve_commit(&repo.id, &self.commit)
             .map_err(EventError::Ergonomic)?;
         let branch_name = self.branch(&r, &repo)?;
         let event = match &self.kind {
             EventKind::BranchCreated => {
                 if self.base.is_some() {
                     return Err(CibToolError::NoBaseAllowed);
                 } else {
                     CiEvent::branch_created(nid, rid, &branch_name, oid)
                     CiEvent::branch_created(nid, repo.id, &branch_name, oid)
                         .map_err(CibToolError::CiEvent)?
                 }
             }

@@ -211,32 +157,33 @@ impl Leaf for AddEvent {

                     let base = if let Ok(base) = Oid::from_str(base) {
                         base
                     } else {
                         self.lookup_commit(rid, base)?
                         r.resolve_commit(&repo.id, base)
                             .map_err(EventError::Ergonomic)?
                     };
                     CiEvent::branch_updated(nid, rid, &branch_name, oid, base)
                     CiEvent::branch_updated(nid, repo.id, &branch_name, oid, base)
                         .map_err(CibToolError::CiEvent)?
                 } else {
                     return Err(CibToolError::BaseRequired);
                 }
             }
             EventKind::BranchDeleted => CiEvent::branch_deleted(nid, rid, &branch_name, oid)
             EventKind::BranchDeleted => CiEvent::branch_deleted(nid, repo.id, &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)
                     CiEvent::patch_created(nid, repo.id, *patch_id, oid)
                 } else if let Some(filename) = &self.patch_id_file {
                     let patch_id = read_file_as_objectid(filename)?;
                     CiEvent::patch_created(nid, rid, patch_id, oid)
                     CiEvent::patch_created(nid, repo.id, patch_id, oid)
                 } else {
                     return Err(CibToolError::PatchIdRequired);
                 }
             }
             EventKind::PatchUpdated => {
                 if let Some(patch_id) = &self.patch_id {
                     CiEvent::patch_updated(nid, rid, *patch_id, oid)
                     CiEvent::patch_updated(nid, repo.id, *patch_id, oid)
                 } else if let Some(filename) = &self.patch_id_file {
                     let patch_id = read_file_as_objectid(filename)?;
                     CiEvent::patch_created(nid, rid, patch_id, oid)
                     CiEvent::patch_created(nid, repo.id, patch_id, oid)
                 } else {
                     return Err(CibToolError::PatchIdRequired);
                 }

@@ -555,3 +502,12 @@ impl Leaf for FilterEvents {

         Ok(())
     }
 }
 #[derive(Debug, thiserror::Error)]
 pub enum EventError {
     #[error(transparent)]
     Ergonomic(#[from] radicle_ci_broker::ergo::ErgoError),
     #[error(transparent)]
     RefError(#[from] radicle_ci_broker::refs::RefError),
 }