e243687 feat: add shutdown event and debug logging for trigger building — radicle-ci-broker

Radicle CI broker

feat: add shutdown event and debug logging for trigger building

Lars Wirzenius committed 2 years ago

commit e24368765815de9a685fa01d77d84af43bd74413
parent defea3a7844863b1eb40f7a2bc43d32821788f4f

2 files changed +67 -27

modified src/bin/ci-broker.rs

@@ -14,7 +14,7 @@ use radicle_ci_broker::{

     broker::Broker,
     config::Config,
     error::BrokerError,
     event::NodeEventSource,
     event::{BrokerEvent, NodeEventSource},
     msg::RequestBuilder,
     pages::{PageBuilder, StatusPage},
 };

@@ -104,34 +104,42 @@ fn fallible_main() -> Result<(), BrokerError> {

     // This loop ends when there's an error, e.g., failure to read an
     // event from the node.
     loop {
     'event_loop: loop {
         debug!("waiting for event from node");
         for e in source.event()? {
             page.broker_event(&e);
             info!("broker event {e:#?}");
             let req = RequestBuilder::default()
                 .profile(&profile)
                 .broker_event(&e)
                 .build_trigger()?;
             if let Err(e) = broker.execute_ci(&req, &mut page) {
                 error!("failed to run adapter, or adapter failed to run CI: {e}");
             match e {
                 BrokerEvent::Shutdown => break 'event_loop,
                 BrokerEvent::RefChanged { .. } => {
                     info!("broker event {e:#?}");
                     let req = RequestBuilder::default()
                         .profile(&profile)
                         .broker_event(&e)
                         .build_trigger()?;
                     if let Err(e) = broker.execute_ci(&req, &mut page) {
                         error!("failed to run adapter, or adapter failed to run CI: {e}");
                     }
                 }
             }
         }
     }
     Ok(())
 }
 fn status_updater(dirname: PathBuf, mut page: StatusPage, interval: Duration) {
     let filename = dirname.join("status.json");
     loop {
         page.update_timestamp();
         if let Err(e) = page.write_json(&filename) {
             eprintln!("ERROR: failed to update {}: {e}", filename.display());
         }
         if let Err(e) = page.write(&dirname) {
             eprintln!(
                 "ERROR: failed to update repot pages in {}: {e}",
                 dirname.display()
             );
         if dirname.exists() {
             if let Err(e) = page.write_json(&filename) {
                 eprintln!("ERROR: failed to update {}: {e}", filename.display());
             }
             if let Err(e) = page.write(&dirname) {
                 eprintln!(
                     "ERROR: failed to update repot pages in {}: {e}",
                     dirname.display()
                 );
             }
         }
         sleep(interval);
     }

modified src/msg.rs

@@ -16,6 +16,7 @@ use std::{

     io::{BufRead, BufReader, Read, Write},
 };
 use log::debug;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;

@@ -121,26 +122,46 @@ impl<'a> RequestBuilder<'a> {

     /// Create a [`Request::Trigger`] message.
     pub fn build_trigger(self) -> Result<Request, MessageError> {
         debug!("build_trigger: called");
         let profile = self.profile.ok_or(MessageError::NoProfile)?;
         debug!("build_trigger: got profile");
         let event = self.event.ok_or(MessageError::NoEvent)?;
         let BrokerEvent::RefChanged {
             rid,
             name,
             oid,
             old,
         } = event;
         debug!("build_trigger: got event");
         let (rid, name, oid, old) = match event {
             BrokerEvent::Shutdown => panic!("got shutdown"),
             BrokerEvent::RefChanged {
                 rid,
                 name,
                 oid,
                 old,
             } => (rid, name, oid, old),
         };
         debug!("build_trigger: unpacked event");
         let is_patch = is_patch_update(name).is_some();
         let repository = profile.storage.repository(*rid)?;
         debug!("build_trigger: got repository");
         let storage = &profile.storage;
         let repo = radicle_surf::Repository::open(paths::repository(storage, rid))?;
         debug!("build_trigger: opened repository");
         let repo_project = repository.project()?;
         debug!("build_trigger: got project");
         let repo_identity = repository.identity()?;
         let author = extract_author(profile, event)?;
         debug!("build_trigger: got identity");
         let author = match extract_author(profile, event) {
             Ok(author) => author,
             Err(err) => {
                 debug!("build_trigger: author lookup failed: {err}");
                 return Err(err);
             }
         };
         debug!("build_trigger: got author");
         let push_info: Option<PushEvent>;
         let patch_info: Option<PatchEvent>;
         let event_type: EventType;
         debug!("build_trigger: checking if patch or push");
         if is_patch {
             debug!("build_trigger: is patch");
             event_type = EventType::Patch;
             let patch_id = event.patch_id().ok_or(MessageError::Trigger)?;
             let patch = patch::Patches::open(&repository)?

@@ -206,6 +227,7 @@ impl<'a> RequestBuilder<'a> {

                 },
             });
         } else {
             debug!("build_trigger: is push");
             event_type = EventType::Push;
             let before_oid: Oid = old.unwrap_or(*oid);
             let push_commits: Vec<Oid> = repo

@@ -242,6 +264,7 @@ impl<'a> RequestBuilder<'a> {

             },
         };
         debug!("build_trigger: return Ok");
         Ok(Request::Trigger {
             common,
             push: push_info,

@@ -340,7 +363,16 @@ fn did_to_author(profile: &Profile, did: &Did) -> Result<Author, MessageError> {

 }
 fn extract_author(profile: &Profile, event: &BrokerEvent) -> Result<Author, MessageError> {
     let nid = event.nid().ok_or(MessageError::Trigger)?;
     debug!("extract_author: called");
     debug!("extract_author: {event:#?}");
     let nid = match event.nid() {
         Some(nid) => nid,
         None => {
             debug!("extract_author: nid lookup failed");
             return Err(MessageError::Trigger);
         }
     };
     debug!("extract_author: got nid {nid}");
     did_to_author(profile, &Did::from(nid))
 }