feat: make CI events versioned — radicle-ci-broker

This will help us avoid breaking changes in the future, when CI events need to be modified, and CI broker instances need to cope with the event queues in their databases.

Previously we had

enum CiEvent {
    BranchCreated { ... },
    BranchUpdatee { ... },
    ....
}

Change that to:

enum CiEvent {
    V1(CiEventV1),
}

enum CiEventV1 {
    BranchCreated { ... },
    BranchUpdatee { ... },
    ....
}

This will allow us to add new version variants to CiEvent, without losing access to the already enqueued V1 events.

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

refactor: make BrokerError::NotTrigger not be so large

It’s awkward if enum variants have wildly different sizes. Change BrokerError::NotTrigger to store the Request value in a Box, so that it’s not in the enum directly. This makes all variants about the same size, and thus the decorators that allow the clippy::large_enum_variant can be dropped.

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

 }
 #[derive(Debug, thiserror::Error)]
 #[allow(clippy::large_enum_variant)]
 enum CibError {
     #[error("failed to read configuration file {0}")]
     ReadConfig(PathBuf, #[source] ConfigError),

 use radicle_ci_broker::{
     broker::BrokerError,
     ci_event::{CiEvent, CiEventError},
     ci_event::{CiEvent, CiEventError, CiEventV1},
     db::{Db, DbError, QueueId, QueuedCiEvent},
     logger,
     msg::{RunId, RunResult},

 }
 #[derive(Debug, thiserror::Error)]
 #[allow(clippy::large_enum_variant)]
 enum CibToolError {
     #[error("failed to look up node profile")]
     Profile(#[source] radicle::profile::Error),

 impl Leaf for Shutdown {
     fn run(&self, args: &Args) -> Result<(), CibToolError> {
         let db = args.open_db()?;
         let id = db.push_queued_ci_event(CiEvent::Shutdown)?;
         let id = db.push_queued_ci_event(CiEvent::V1(CiEventV1::Shutdown))?;
         if let Some(filename) = &self.id_file {
             write(filename, id.to_string().as_bytes())

 /// All possible errors from this module.
 #[derive(Debug, thiserror::Error)]
 #[allow(clippy::large_enum_variant)]
 pub enum BrokerError {
     /// Error formatting a time as a string.
     #[error(transparent)]

     /// Request is not a trigger message.
     #[error("tried to execute CI based on a message that is not a trigger one: {0:#?}")]
     NotTrigger(Request),
     NotTrigger(Box<Request>),
     /// Could not convert repository ID from string.
     #[error("failed to understand repository id {0:?}")]

 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
 pub enum CiEvent {
     V1(CiEventV1),
 }
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
 pub enum CiEventV1 {
     Shutdown,
     BranchCreated {
         from_node: NodeId,

         branch: &str,
         tip: Oid,
     ) -> Result<Self, CiEventError> {
         Ok(Self::BranchCreated {
         Ok(Self::V1(CiEventV1::BranchCreated {
             from_node: node,
             repo,
             branch: RefString::try_from(branch)
                 .map_err(|e| CiEventError::RefString(branch.into(), e))?,
             tip,
         })
         }))
     }
     pub fn branch_updated(

     ) -> Result<Self, CiEventError> {
         let branch =
             namespaced_branch(branch).map_err(|_| CiEventError::without_namespace2(branch))?;
         Ok(Self::BranchUpdated {
         Ok(Self::V1(CiEventV1::BranchUpdated {
             from_node: node,
             repo,
             branch: RefString::try_from(branch.clone())
                 .map_err(|e| CiEventError::RefString(branch.clone(), e))?,
             tip,
             old_tip,
         })
         }))
     }
     pub fn from_node_event(event: &Event) -> Result<Vec<Self>, CiEventError> {

                         RefUpdate::Created { name, oid } => {
                             eprintln!("created: {name:?}");
                             if let Ok(patch_id) = patch_id(name) {
                                 CiEvent::PatchCreated {
                                 CiEventV1::PatchCreated {
                                     from_node: *remote,
                                     repo: *rid,
                                     patch: patch_id,
                                     new_tip: *oid,
                                 }
                             } else if let Ok(branch) = namespaced_branch(name) {
                                 CiEvent::BranchCreated {
                                 CiEventV1::BranchCreated {
                                     from_node: *remote,
                                     repo: *rid,
                                     branch: ref_string(branch)?,

                                 continue;
                             }
                         }
                         RefUpdate::Deleted { name, oid } => CiEvent::BranchDeleted {
                         RefUpdate::Deleted { name, oid } => CiEventV1::BranchDeleted {
                             repo: *rid,
                             branch: branch(name, update)?,
                             tip: *oid,
                         },
                         RefUpdate::Skipped { .. } => continue,
                     };
                     events.push(e);
                     events.push(CiEvent::V1(e));
                 }
                 Ok(events)
             }

             Ok(events) if !events.is_empty() => {
                 for e in events {
                     match e {
                         CiEvent::BranchCreated {
                         CiEvent::V1(CiEventV1::BranchCreated {
                             from_node: _,
                             repo,
                             branch,
                             tip,
                         } if repo == rid && branch == main && tip == oid => {}
                         }) if repo == rid && branch == main && tip == oid => {}
                         _ => panic!("should not succeed that way"),
                     }
                 }

 use radicle::{cob::patch::PatchId, git::RefString, prelude::RepoId};
 use radicle_git_ext::Oid;
 use crate::{ci_event::CiEvent, logger};
 use crate::{
     ci_event::{CiEvent, CiEventV1},
     logger,
 };
 /// A Boolean expression for filtering broker events.
 #[derive(Debug, Clone, Deserialize, Serialize)]

         }
         match event {
             CiEvent::Shutdown => true,
             CiEvent::BranchCreated { repo, branch, .. } => match self {
             CiEvent::V1(CiEventV1::Shutdown) => true,
             CiEvent::V1(CiEventV1::BranchCreated { repo, branch, .. }) => match self {
                 Self::Repository(wanted) => repo == wanted,
                 Self::Branch(wanted) => branch == wanted,
                 Self::BranchCreated => true,
                 _ => false,
             },
             CiEvent::BranchUpdated { repo, branch, .. } => match self {
             CiEvent::V1(CiEventV1::BranchUpdated { repo, branch, .. }) => match self {
                 Self::Repository(wanted) => repo == wanted,
                 Self::Branch(wanted) => branch == wanted,
                 Self::BranchUpdated => true,
                 _ => false,
             },
             CiEvent::BranchDeleted { repo, branch, .. } => match self {
             CiEvent::V1(CiEventV1::BranchDeleted { repo, branch, .. }) => match self {
                 Self::Repository(wanted) => repo == wanted,
                 Self::Branch(wanted) => branch == wanted,
                 Self::BranchDeleted => true,
                 _ => false,
             },
             CiEvent::PatchCreated { repo, patch, .. } => match self {
             CiEvent::V1(CiEventV1::PatchCreated { repo, patch, .. }) => match self {
                 Self::Repository(wanted) => repo == wanted,
                 Self::Patch(wanted) => *patch == PatchId::from(wanted),
                 Self::PatchCreated => true,
                 _ => false,
             },
             CiEvent::PatchUpdated { repo, patch, .. } => match self {
             CiEvent::V1(CiEventV1::PatchUpdated { repo, patch, .. }) => match self {
                 Self::Repository(wanted) => repo == wanted,
                 Self::Patch(wanted) => *patch == PatchId::from(wanted),
                 Self::PatchUpdated => true,

         old_tip: Oid,
     ) -> Vec<CiEvent> {
         vec![
             CiEvent::BranchCreated {
             CiEvent::V1(CiEventV1::BranchCreated {
                 from_node: did.into(),
                 repo,
                 branch: branch.clone(),
                 tip,
             },
             CiEvent::BranchUpdated {
             }),
             CiEvent::V1(CiEventV1::BranchUpdated {
                 from_node: did.into(),
                 repo,
                 branch: branch.clone(),
                 tip,
                 old_tip,
             },
             CiEvent::BranchDeleted { repo, branch, tip },
             CiEvent::PatchCreated {
             }),
             CiEvent::V1(CiEventV1::BranchDeleted { repo, branch, tip }),
             CiEvent::V1(CiEventV1::PatchCreated {
                 from_node: did.into(),
                 repo,
                 patch,
                 new_tip: tip,
             },
             CiEvent::PatchUpdated {
             }),
             CiEvent::V1(CiEventV1::PatchUpdated {
                 from_node: did.into(),
                 repo,
                 patch,
                 new_tip: tip,
             },
             }),
         ]
     }

         for e in events.iter().filter(|e| {
             matches!(
                 e,
                 CiEvent::BranchCreated { .. }
                     | CiEvent::BranchUpdated { .. }
                     | CiEvent::BranchDeleted { .. }
                 CiEvent::V1(CiEventV1::BranchCreated { .. })
                     | CiEvent::V1(CiEventV1::BranchUpdated { .. })
                     | CiEvent::V1(CiEventV1::BranchDeleted { .. })
             )
         }) {
             eprintln!("{:#?} → {}", e, filter.allows(e));

         eprintln!("filter: {filter:#?}");
         for e in all_events(did(), rid(), refstring("main"), patch_id(), oid(), oid())
             .iter()
             .filter(|e| matches!(e, CiEvent::BranchCreated { .. }))
             .filter(|e| matches!(e, CiEvent::V1(CiEventV1::BranchCreated { .. })))
         {
             eprintln!("{:#?} → {}", e, filter.allows(e));
             assert!(filter.allows(e));

     Profile,
 };
 use crate::ci_event::CiEvent;
 use crate::ci_event::{CiEvent, CiEventV1};
 // This gets put into every [`Request`] message so the adapter can
 // detect its getting a message it knows how to handle.

         match self.ci_event {
             None => Err(MessageError::CiEventNotSet),
             Some(CiEvent::BranchCreated {
             Some(CiEvent::V1(CiEventV1::BranchCreated {
                 from_node,
                 repo,
                 branch,
                 tip,
             }) => {
             })) => {
                 let rad_repo = profile.storage.repository(*repo)?;
                 let project_info = rad_repo.project()?;

                     patch: None,
                 })
             }
             Some(CiEvent::BranchUpdated {
             Some(CiEvent::V1(CiEventV1::BranchUpdated {
                 from_node,
                 repo,
                 branch,
                 tip,
                 old_tip,
             }) => {
             })) => {
                 let rad_repo = profile.storage.repository(*repo)?;
                 let git_repo =
                     radicle_surf::Repository::open(paths::repository(&profile.storage, repo))?;

 #[cfg(test)]
 #[allow(clippy::unwrap_used)] // OK in tests: panic is fine
 pub mod trigger_from_ci_event_tests {
     use crate::ci_event::CiEvent;
     use crate::ci_event::{CiEvent, CiEventV1};
     use crate::msg::{EventType, Request, RequestBuilder};
     use radicle::git::RefString;
     use radicle::patch::{MergeTarget, Patches};

             &project.backend,
         );
         let ci_event = CiEvent::BranchCreated {
         let ci_event = CiEvent::V1(CiEventV1::BranchCreated {
             from_node: *profile.id(),
             repo: project.id,
             branch: RefString::try_from(
                 "refs/namespaces/$nid/refs/heads/master".replace("$nid", &profile.id().to_string()),
             )?,
             tip: cmt,
         };
         });
         let req = RequestBuilder::default()
             .profile(&profile)

             &node.signer,
         )?;
         let ci_event = CiEvent::PatchCreated {
         let ci_event = CiEvent::V1(CiEventV1::PatchCreated {
             from_node: *profile.id(),
             repo: project.id,
             patch: *patch_cob.id(),
             new_tip: cmt,
         };
         });
         let req = RequestBuilder::default()
             .profile(&profile)

             }
             let event_element = match event.event() {
                 CiEvent::Shutdown => Element::new(Tag::Span).with_text("shutdown"),
                 CiEvent::BranchCreated {
                 CiEvent::V1(CiEventV1::Shutdown) => Element::new(Tag::Span).with_text("shutdown"),
                 CiEvent::V1(CiEventV1::BranchCreated {
                     from_node: _,
                     repo,
                     branch,
                     tip,
                 } => render_event(repo, branch, tip),
                 CiEvent::BranchUpdated {
                 }) => render_event(repo, branch, tip),
                 CiEvent::V1(CiEventV1::BranchUpdated {
                     from_node: _,
                     repo,
                     branch,
                     tip,
                     old_tip: _,
                 } => render_event(repo, branch, tip),
                 CiEvent::BranchDeleted { repo, branch, tip } => render_event(repo, branch, tip),
                 CiEvent::PatchCreated {
                 }) => render_event(repo, branch, tip),
                 CiEvent::V1(CiEventV1::BranchDeleted { repo, branch, tip }) => {
                     render_event(repo, branch, tip)
                 }
                 CiEvent::V1(CiEventV1::PatchCreated {
                     from_node: _,
                     repo,
                     patch,
                     new_tip,
                 } => render_event(repo, &patch.to_string(), new_tip),
                 CiEvent::PatchUpdated {
                 }) => render_event(repo, &patch.to_string(), new_tip),
                 CiEvent::V1(CiEventV1::PatchUpdated {
                     from_node: _,
                     repo,
                     patch,
                     new_tip,
                 } => render_event(repo, &patch.to_string(), new_tip),
                 }) => render_event(repo, &patch.to_string(), new_tip),
             };
             table.push_child(

                 .iter()
                 .filter_map(|id| match db.get_queued_ci_event(id) {
                     Ok(Some(event)) => match event.event() {
                         CiEvent::Shutdown => Some(Ok(event)),
                         CiEvent::BranchCreated { repo, .. }
                         | CiEvent::BranchUpdated { repo, .. }
                         | CiEvent::PatchCreated { repo, .. }
                         | CiEvent::PatchUpdated { repo, .. } => {
                         CiEvent::V1(CiEventV1::Shutdown) => Some(Ok(event)),
                         CiEvent::V1(CiEventV1::BranchCreated { repo, .. })
                         | CiEvent::V1(CiEventV1::BranchUpdated { repo, .. })
                         | CiEvent::V1(CiEventV1::PatchCreated { repo, .. })
                         | CiEvent::V1(CiEventV1::PatchUpdated { repo, .. }) => {
                             if Self::is_public_repo(profile, repo) {
                                 Some(Ok(event))
                             } else {

     fn process_event(&mut self, event: &CiEvent) -> Result<bool, QueueError> {
         match event {
             CiEvent::Shutdown => {
             CiEvent::V1(CiEventV1::Shutdown) => {
                 logger::queueproc_action_shutdown();
                 Ok(true)
             }
             CiEvent::BranchCreated {
             CiEvent::V1(CiEventV1::BranchCreated {
                 from_node: _,
                 repo,
                 branch: _,
                 tip,
             } => {
             }) => {
                 logger::queueproc_action_run(repo, tip);
                 let trigger = RequestBuilder::default()
                     .profile(&self.profile)

 };
 use crate::adapter::Adapter;
 use crate::ci_event::CiEvent;
 use crate::ci_event::{CiEvent, CiEventV1};
 use crate::msg::{Request, RequestBuilder};
 use radicle::crypto::ssh::Keystore;
 use radicle::crypto::test::signer::MockSigner;