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

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

 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())

 #[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;