Handle almost all errors as errors, instead of causing a panic — radicle-ci-broker

Instead of calling Result::unwrap or Result::expect, which panic if the result is not Ok, we return the error to the caller. That will hopefully be logged and thus visible to the user in a way that is easier to deal with than a panic

This leaves only a few JoinHandle::join results that are handled in a way that causes a panic. JoinHandle returns errors that do not implement the std::error::Error trait, which makes them a little harder to handle the way other errors are handled. Specifically, thiserror doesn’t like them as source errors. I’m ignoring the join errors for now.

Every other error is handled. The only unwrap or expect method calls now are for the join errors or for Options.

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

     println!("cargo:rustc-env=GIT_HEAD={hash}");
     println!("cargo:rustc-rerun-if-changed=.git/HEAD");
     subplot_build::codegen("ci-broker.subplot").expect("failed to generate code with Subplot");
     if let Err(e) = subplot_build::codegen("ci-broker.subplot") {
         eprintln!("failed to generate code with Subplot: {e}");
         std::process::exit(1);
     }
 }

         test::{log_in_tests, mock_adapter, trigger_request, TestResult},
     };
     fn run() -> Run {
         Run::new(
             RepoId::from_urn("rad:zwTxygwuz5LDGBq255RA2CbNGrz8").unwrap(),
     fn run() -> anyhow::Result<Run> {
         Ok(Run::new(
             RepoId::from_urn("rad:zwTxygwuz5LDGBq255RA2CbNGrz8")?,
             "test.repo",
             Whence::branch(
                 "main",
                 Oid::try_from("ff3099ba5de28d954c41d0b5a84316f943794ea4").unwrap(),
                 Oid::try_from("ff3099ba5de28d954c41d0b5a84316f943794ea4")?,
                 Some("J. Random Hacker <random@example.com>"),
             ),
             "2024-02-29T12:58:12+02:00".into(),
         )
         ))
     }
     #[test]

         let bin = tmp.path().join("adapter.sh");
         mock_adapter(&bin, ADAPTER)?;
         let mut run = run();
         let mut run = run()?;
         Adapter::new(&bin).run(&trigger_request()?, &mut run)?;
         assert_eq!(run.result(), Some(&RunResult::Success));

         let bin = tmp.path().join("adapter.sh");
         mock_adapter(&bin, ADAPTER)?;
         let mut run = run();
         let mut run = run()?;
         let x = Adapter::new(&bin).run(&trigger_request()?, &mut run);
         match x {

         let bin = tmp.path().join("adapter.sh");
         mock_adapter(&bin, ADAPTER)?;
         let mut run = run();
         let mut run = run()?;
         let x = Adapter::new(&bin).run(&trigger_request()?, &mut run);
         eprintln!("{x:#?}");
         assert!(x.is_err());

 }
 impl ConfigCmd {
     fn run(&self, _args: &Args, config: &Config) -> Result<(), CibError> {
         let json = config.to_json();
     fn run(&self, args: &Args, config: &Config) -> Result<(), CibError> {
         let json = config
             .to_json()
             .map_err(|e| CibError::to_json(&args.config, e))?;
         if let Some(output) = &self.output {
             write(output, json.as_bytes()).map_err(|e| CibError::write_config(output, e))?;

     #[error("failed to write config as JSON to file {0}")]
     WriteConfig(PathBuf, #[source] std::io::Error),
     #[error("failed to convert config as JSON")]
     ToJson(PathBuf, #[source] ConfigError),
     #[error("failed to look up node profile")]
     Profile(#[source] radicle::profile::Error),

         Self::WriteConfig(filename.into(), e)
     }
     fn to_json(filename: &Path, e: ConfigError) -> Self {
         Self::ToJson(filename.into(), e)
     }
     fn profile(e: radicle::profile::Error) -> Self {
         Self::Profile(e)
     }

             self.lookup_nid()?,
             self.name.as_str()
         );
         let name = RefString::try_from(name).expect("RefString");
         let name =
             RefString::try_from(name.clone()).map_err(|e| CibToolError::RefString(name, e))?;
         let event = BrokerEvent::new(&rid, &name, &oid, self.base);

             println!("{id}");
             if let Some(filename) = &self.id_file {
                 write(filename, id.to_string().as_bytes()).expect("write id file");
                 write(filename, id.to_string().as_bytes())
                     .map_err(|e| CibToolError::WriteEventId(filename.into(), e))?;
             }
         }
         Ok(())

         let id = if let Some(id) = &self.id {
             id.clone()
         } else {
             assert!(self.id_file.is_some());
             let file = self.id_file.as_ref().unwrap();
             let id = read(file).expect("read id file");
         } else if let Some(filename) = &self.id_file {
             let id = read(filename).map_err(|e| CibToolError::ReadEventId(filename.into(), e))?;
             let id = String::from_utf8_lossy(&id).to_string();
             QueueId::from(&id)
         } else {
             return Err(CibToolError::MissingId);
         };
         if let Some(event) = db.get_queued_event(&id)? {

             RunResult::Failure
         });
         db.push_run(run).unwrap();
         db.push_run(run)?;
         Ok(())
     }

         if self.json {
             let runs: Vec<RunInfo> = db.get_all_runs()?.iter().map(RunInfo::from).collect();
             println!("{}", serde_json::to_string_pretty(&runs).expect("JSON"));
             println!(
                 "{}",
                 serde_json::to_string_pretty(&runs).map_err(CibToolError::RunToJson)?
             );
         } else {
             for run in db.get_all_runs()? {
                 println!(

     #[error("failed to serialize broker event to JSON: {0:#?}")]
     EventToJson(BrokerEvent, #[source] serde_json::Error),
     #[error("failed to serialize CI run information to JSON")]
     RunToJson(#[source] serde_json::Error),
     #[error("failed to write file: {0}")]
     Write(PathBuf, #[source] std::io::Error),
     #[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),
     #[error("failed to write event ID to file {0}")]
     WriteEventId(PathBuf, #[source] std::io::Error),
     #[error("one of --id or --id-file is required")]
     MissingId,
 }

                         panic!("neither push not patch event");
                     };
                     let mut run = Run::new(*rid, &common.repository.name, whence, now());
                     let mut run = Run::new(*rid, &common.repository.name, whence, now()?);
                     // We run the adapter, but if that fails, we just
                     // log the error. The `Run` value records the

     }
 }
 fn now() -> String {
 fn now() -> Result<String, time::error::Format> {
     let fmt = format_description!("[year]-[month]-[day] [hour]:[minute]:[second]Z");
     OffsetDateTime::now_utc().format(fmt).expect("format time")
     OffsetDateTime::now_utc().format(fmt)
 }
 /// 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)]
     Timeformat(#[from] time::error::Format),
     /// Error from an node event subscriber.
     #[error(transparent)]
     NodeEvent(#[from] crate::event::NodeEventError),

         test::{log_in_tests, mock_adapter, trigger_request, TestResult},
     };
     fn broker(filename: &Path) -> Broker {
         Broker::new(filename).unwrap()
     fn broker(filename: &Path) -> anyhow::Result<Broker> {
         Ok(Broker::new(filename)?)
     }
     fn rid() -> RepoId {
     fn rid() -> anyhow::Result<RepoId> {
         const RID: &str = "rad:zwTxygwuz5LDGBq255RA2CbNGrz8";
         RepoId::from_urn(RID).unwrap()
         Ok(RepoId::from_urn(RID)?)
     }
     fn rid2() -> RepoId {
     fn rid2() -> anyhow::Result<RepoId> {
         const RID: &str = "rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5";
         RepoId::from_urn(RID).unwrap()
         Ok(RepoId::from_urn(RID)?)
     }
     #[test]
     fn has_no_adapters_initially() -> TestResult<()> {
         let tmp = tempdir().unwrap();
         let tmp = tempdir()?;
         let db = tmp.path().join("db.db");
         let broker = broker(&db);
         let rid = rid();
         let broker = broker(&db)?;
         let rid = rid()?;
         assert_eq!(broker.adapter(&rid), None);
         Ok(())
     }
     #[test]
     fn adds_adapter() -> TestResult<()> {
         let tmp = tempdir().unwrap();
         let tmp = tempdir()?;
         let db = tmp.path().join("db.db");
         let mut broker = broker(&db);
         let mut broker = broker(&db)?;
         let adapter = Adapter::default();
         let rid = rid();
         let rid = rid()?;
         broker.set_repository_adapter(&rid, &adapter);
         assert_eq!(broker.adapter(&rid), Some(&adapter));
         Ok(())

         let bin = tmp.path().join("adapter.sh");
         let adapter = mock_adapter(&bin, ADAPTER)?;
         let tmp = tempdir().unwrap();
         let tmp = tempdir()?;
         let db = tmp.path().join("db.db");
         let mut broker = broker(&db);
         let mut broker = broker(&db)?;
         broker.set_default_adapter(&adapter);
         let trigger = trigger_request()?;
         let x = broker.execute_ci(&trigger);
         assert!(x.is_ok());
         let run = x.unwrap();
         let run = x?;
         assert_eq!(run.adapter_run_id(), Some(&RunId::from("xyzzy")));
         assert_eq!(run.state(), RunState::Finished);
         assert_eq!(run.result(), Some(&RunResult::Success));

         &self.db
     }
     pub fn to_json(&self) -> String {
         serde_json::to_string_pretty(self).expect("serialize config to JSON")
     pub fn to_json(&self) -> Result<String, ConfigError> {
         serde_json::to_string_pretty(self).map_err(ConfigError::ToJson)
     }
 }

     /// Can't parse config file as YAML.
     #[error("failed to parse configuration file as YAML: {0}")]
     ParseConfig(PathBuf, #[source] serde_yaml::Error),
     /// Can't convert configuration into JSON.
     #[error("failed to convert configuration into JSON")]
     ToJson(#[source] serde_json::Error),
 }

     /// Add a new event to the event queue, returning its id.
     pub fn push_queued_event(&self, event: BrokerEvent) -> Result<QueueId, DbError> {
         let json = serde_json::to_string(&event).expect("serialize BrokerEvent to JSON");
         let json = serde_json::to_string(&event).map_err(DbError::event_to_json)?;
         let id = QueueId::default();
         let ts = now();
         let ts = now().map_err(DbError::time_format)?;
         let mut insert =
             self.prepare("INSERT INTO event_queue (id, timestamp, event) VALUES (:id, :ts, :e)")?;

     pub fn push_run(&self, run: Run) -> Result<RunId, DbError> {
         let id = run.adapter_run_id().ok_or(DbError::without_id())?.clone();
         let json = serde_json::to_string(&run).expect("serialize BrokerEvent to JSON");
         let json = serde_json::to_string(&run).map_err(DbError::event_to_json)?;
         let mut insert = self.prepare("INSERT INTO ci_runs (run_id, json) VALUES (:id, :json)")?;
         insert

     #[error("failed to parse queued event as JSON: {0}")]
     EventFromJson(String, #[source] serde_json::Error),
     /// Can't convert broker event into JSON.
     #[error("failed to convert broker event into JSON")]
     EventToJson(#[source] serde_json::Error),
     #[error("failed to insert an event into queue")]
     PushEvent(String, #[source] sqlite::Error),

 }
 impl DbError {
     fn time_format(e: time::error::Format) -> Self {
         Self::Timeformat(e)
     }
     fn busy_timer(filename: &Path, e: sqlite::Error) -> Self {
         Self::BusyTimer(filename.into(), e)
     }

         Self::EventFromJson(json.into(), e)
     }
     fn event_to_json(e: serde_json::Error) -> Self {
         Self::EventToJson(e)
     }
     fn push_event(sql: &str, e: sqlite::Error) -> Self {
         Self::PushEvent(sql.into(), e)
     }

         self.allowed.push(filter);
     }
     fn allowed(&self, event: &BrokerEvent) -> bool {
     fn allowed(&self, event: &BrokerEvent) -> Result<bool, NodeEventError> {
         for filter in self.allowed.iter() {
             if !event.is_allowed(filter) {
             if !event.is_allowed(filter)? {
                 trace!("event is not allowed");
                 return false;
                 return Ok(false);
             }
         }
         trace!("event is allowed");
         true
         Ok(true)
     }
     /// Get the allowed next event from an event source. This will

                         if let Some(broker_events) = BrokerEvent::from_event(&event) {
                             info!("node event became {} broker events", broker_events.len());
                             for e in broker_events {
                                 if self.allowed(&e) {
                                 if self.allowed(&e)? {
                                     info!("allowed event {e:?}");
                                     result.push(e);
                                 }

 /// Possible errors from accessing the local Radicle node.
 #[derive(Debug, thiserror::Error)]
 pub enum NodeEventError {
     /// Regex compilation error.
     #[error("programming error in regular expression {0:?}")]
     Regex(&'static str, regex::Error),
     /// Node control socket does not exist.
     #[error("node control socket does not exist: {0}")]
     NoControlSocket(PathBuf),

     /// An error parsing JSON as filters, from an in-memory string.
     #[error("failed to parser filters as JSON")]
     FiltersJsonString(#[source] serde_json::Error),
     /// An error parsing a Git object id as string into an Oid.
     #[error("failed to parse string as a Git object id: {0:?}")]
     ParseOid(String, #[source] radicle::git::raw::Error),
 }
 /// An event filter for allowing events. Or an "AND" combination of events.

     }
     /// Is this broker event allowed by a filter?
     fn is_allowed(&self, filter: &EventFilter) -> bool {
     fn is_allowed(&self, filter: &EventFilter) -> Result<bool, NodeEventError> {
         debug!("is_allowed called: filter={filter:?}");
         let res = self.is_allowed_helper(filter, 0);
         let res = self.is_allowed_helper(filter, 0)?;
         debug!("is_allowed: res={res}");
         res
         Ok(res)
     }
     fn is_allowed_helper(&self, filter: &EventFilter, level: usize) -> bool {
     fn is_allowed_helper(
         &self,
         filter: &EventFilter,
         level: usize,
     ) -> Result<bool, NodeEventError> {
         let prefix = format!("{:width$}", " ", width = level * 4);
         trace!("is_allowed: {prefix} called {self:?}");

                 trace!("is_allowed: {prefix} old={old:?}");
                 trace!("is_allowed: {prefix} filter={filter:?}");
                 let parsed = parse_ref(name);
                 let parsed = parse_ref(name)?;
                 trace!("is_allowed: {prefix} parsed={parsed:?}");
                 match filter {

                     EventFilter::Branch(wanted) => parsed == Some(ParsedRef::Push(wanted.into())),
                     EventFilter::AnyPatch => matches!(parsed, Some(ParsedRef::Patch(_))),
                     EventFilter::Patch(wanted) => {
                         parsed == Some(ParsedRef::Patch(Oid::try_from(wanted.as_str()).unwrap()))
                         let oid = Oid::try_from(wanted.as_str())
                             .map_err(|e| NodeEventError::ParseOid(wanted.into(), e))?;
                         parsed == Some(ParsedRef::Patch(oid))
                     }
                     EventFilter::AnyPatchRef => matches!(parsed, Some(ParsedRef::Patch(_))),
                     EventFilter::AnyPushRef => matches!(parsed, Some(ParsedRef::Push(_))),
                     EventFilter::PatchRef(wanted) => {
                         parsed == Some(ParsedRef::Patch(Oid::try_from(wanted.as_str()).unwrap()))
                         let oid = Oid::try_from(wanted.as_str())
                             .map_err(|e| NodeEventError::ParseOid(wanted.into(), e))?;
                         parsed == Some(ParsedRef::Patch(oid))
                     }
                     EventFilter::And(conds) => conds
                         .iter()
                         .all(|cond| self.is_allowed_helper(cond, level + 1)),
                         .all(|cond| self.is_allowed_helper(cond, level + 1).unwrap_or(false)),
                     EventFilter::Or(conds) => conds
                         .iter()
                         .any(|cond| self.is_allowed_helper(cond, level + 1)),
                         .any(|cond| self.is_allowed_helper(cond, level + 1).unwrap_or(false)),
                     EventFilter::Not(conds) => !conds
                         .iter()
                         .any(|cond| self.is_allowed_helper(cond, level + 1)),
                         .any(|cond| self.is_allowed_helper(cond, level + 1).unwrap_or(false)),
                 }
             }
         };
         trace!("is_allowed: {prefix} allowed={allowed}");
         allowed
         Ok(allowed)
     }
     pub fn name(&self) -> Option<&RefString> {

     /// Extract the NID from the RefString.
     /// The RefString will start with `refs/namespaces/<nid>/...`
     pub fn nid(&self) -> Option<NodeId> {
     pub fn nid(&self) -> Result<Option<NodeId>, NodeEventError> {
         if let Some(name) = self.name() {
             parse_nid_from_refstring(name)
             Ok(parse_nid_from_refstring(name)?)
         } else {
             None
             Ok(None)
         }
     }
     pub fn patch_id(&self) -> Option<Oid> {
     pub fn patch_id(&self) -> Result<Option<Oid>, NodeEventError> {
         if let Some(name) = self.name() {
             if let Some(ParsedRef::Patch(oid)) = parse_ref(name) {
                 return Some(oid);
             if let Some(ParsedRef::Patch(oid)) = parse_ref(name)? {
                 return Ok(Some(oid));
             }
         }
         None
         Ok(None)
     }
 }
 /// Extract the NID from a the ref string in a repository.
 /// The RefString should start with `refs/namespaces/<nid>/...`
 pub fn parse_nid_from_refstring(name: &RefString) -> Option<NodeId> {
     let pat = Regex::new(r"^refs/namespaces/(?P<nid>[^/]+)/").unwrap();
 pub fn parse_nid_from_refstring(name: &RefString) -> Result<Option<NodeId>, NodeEventError> {
     const PAT: &str = r"^refs/namespaces/(?P<nid>[^/]+)/";
     let pat = Regex::new(PAT).map_err(|e| NodeEventError::Regex(PAT, e))?;
     if let Some(captures) = pat.captures(name.as_str()) {
         if let Some(m) = captures.name("nid") {
             if let Ok(parsed) = m.as_str().parse() {
                 return Some(parsed);
                 return Ok(Some(parsed));
             }
         }
     }
     None
     Ok(None)
 }
 #[cfg(test)]

     use super::{BrokerEvent, NodeId, Oid, RefString, RepoId};
     #[test]
     fn name_for_branch() {
         let rid = RepoId::from_urn("rad:zwTxygwuz5LDGBq255RA2CbNGrz8").expect("RepoId");
         let name = RefString::try_from("main").expect("RefString");
         let oid = Oid::from_str("11d03559fb10183b0f14331175f254fbb077159a").expect("Oid");
     fn name_for_branch() -> anyhow::Result<()> {
         let rid = RepoId::from_urn("rad:zwTxygwuz5LDGBq255RA2CbNGrz8")?;
         let name = RefString::try_from("main")?;
         let oid = Oid::from_str("11d03559fb10183b0f14331175f254fbb077159a")?;
         let be = BrokerEvent::new(&rid, &name, &oid, None);
         assert_eq!(be.name(), Some(&name));
         Ok(())
     }
     #[test]

 ///     }
 /// }
 /// ```
 pub fn parse_ref(s: &str) -> Option<ParsedRef> {
 pub fn parse_ref(s: &str) -> Result<Option<ParsedRef>, NodeEventError> {
     trace!("parse_ref: s={s:?}");
     let patch_re = Regex::new(r"^refs/namespaces/[^/]+/refs/heads/patches/([^/]+)$").unwrap();
     const PAT_PATCH: &str = r"^refs/namespaces/[^/]+/refs/heads/patches/([^/]+)$";
     let patch_re = Regex::new(PAT_PATCH).map_err(|e| NodeEventError::Regex(PAT_PATCH, e))?;
     if let Some(patch_captures) = patch_re.captures(s) {
         trace!("parse_ref: patch_captures={patch_captures:?}");
         if let Some(patch_id) = patch_captures.get(1) {
             trace!("parse_ref: patch_id={patch_id:?}");
             let patch_id_str = patch_id.as_str();
             let oid = Oid::try_from(patch_id_str).unwrap();
             let oid = Oid::try_from(patch_id_str)
                 .map_err(|e| NodeEventError::ParseOid(patch_id_str.into(), e))?;
             trace!("parse_ref: patch oid={oid:?}");
             return Some(ParsedRef::Patch(oid));
             return Ok(Some(ParsedRef::Patch(oid)));
         }
     }
     let push_re = Regex::new(r"^refs/namespaces/[^/]+/refs/heads/(.+)$").unwrap();
     const PAT_BRANCH: &str = r"^refs/namespaces/[^/]+/refs/heads/(.+)$";
     let push_re = Regex::new(PAT_BRANCH).map_err(|e| NodeEventError::Regex(PAT_BRANCH, e))?;
     if let Some(push_captures) = push_re.captures(s) {
         trace!("parse_ref: push_captures={push_captures:?}");
         if let Some(branch) = push_captures.get(1) {
             trace!("parse_ref: branch={branch:?}");
             return Some(ParsedRef::Push(branch.as_str().to_string()));
             return Ok(Some(ParsedRef::Push(branch.as_str().to_string())));
         }
     }
     trace!("parse_ref: neither push nor patch");
     None
     Ok(None)
 }
 #[cfg(test)]