f379481 refactor: error types — radicle-ci-broker

modified src/bin/ci-broker.rs

@@ -9,9 +9,10 @@ use log::{debug, info};

 use radicle::prelude::{Id, Profile};
 use radicle_ci_broker::{
     error::BrokerError,
     event::NodeEventSource,
     filter::{BrokerEvent, EventFilter},
     msg::{BrokerError, Request, Response, RunResult},
     msg::{Request, Response, RunResult},
 };
 use radicle_git_ext::Oid;

@@ -76,7 +77,8 @@ fn run(bin: &str, repo: Id, commit: Oid) -> Result<Option<RunResult>, BrokerErro

     let mut child = Command::new(bin)
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
         .spawn()?;
         .spawn()
         .map_err(|e| BrokerError::SpawnAdapter(bin.into(), e))?;
     {
         let stdin = child.stdin.take().expect("get stdin");

modified src/bin/node-events.rs

@@ -3,7 +3,7 @@ use std::error::Error;

 use log::info;
 use radicle::Profile;
 use radicle_ci_broker::{event::NodeEventSource, filter::EventFilter, msg::BrokerError};
 use radicle_ci_broker::{error::BrokerError, event::NodeEventSource, filter::EventFilter};
 fn main() {
     if let Err(e) = fallible_main() {

added src/error.rs

@@ -0,0 +1,23 @@

 //! Possible errors returned by the CI broker library.
 use crate::msg::MessageError;
 /// All possible errors from the CI broker messages.
 #[derive(Debug, thiserror::Error)]
 pub enum BrokerError {
     /// A message related error.
     #[error(transparent)]
     Message(#[from] MessageError),
     /// Error from an node event subscriber.
     #[error(transparent)]
     NodeEvent(#[from] crate::event::NodeEventError),
     /// Error from Radicle.
     #[error(transparent)]
     RadicleProfile(#[from] radicle::profile::Error),
     /// Error from spawning a sub-process.
     #[error("failed to spawn a CI adapter sub-process: {0}")]
     SpawnAdapter(String, #[source] std::io::Error),
 }

modified src/lib.rs

@@ -5,6 +5,7 @@

 //! node, filter the events, and to communicate with a adapter spawned
 //! as a child process.
 pub mod error;
 pub mod event;
 pub mod filter;
 pub mod msg;

modified src/msg.rs

@@ -84,23 +84,23 @@ impl Request {

     /// Serialize the request as a single-line JSON, including the
     /// newline. This is meant for the broker to use.
     pub fn to_writer<W: Write>(&self, mut writer: W) -> Result<(), BrokerError> {
         let mut line = serde_json::to_string(&self).map_err(BrokerError::SerializeRequest)?;
     pub fn to_writer<W: Write>(&self, mut writer: W) -> Result<(), MessageError> {
         let mut line = serde_json::to_string(&self).map_err(MessageError::SerializeRequest)?;
         line.push('\n');
         writer
             .write(line.as_bytes())
             .map_err(BrokerError::WriteRequest)?;
             .map_err(MessageError::WriteRequest)?;
         Ok(())
     }
     /// Read a request from a reader. This is meant for the adapter to
     /// use.
     pub fn from_reader<R: Read>(reader: R) -> Result<Self, BrokerError> {
     pub fn from_reader<R: Read>(reader: R) -> Result<Self, MessageError> {
         let mut line = String::new();
         let mut r = BufReader::new(reader);
         r.read_line(&mut line).map_err(BrokerError::ReadLine)?;
         r.read_line(&mut line).map_err(MessageError::ReadLine)?;
         let req: Self =
             serde_json::from_slice(line.as_bytes()).map_err(BrokerError::DeserializeRequest)?;
             serde_json::from_slice(line.as_bytes()).map_err(MessageError::DeserializeRequest)?;
         Ok(req)
     }
 }

@@ -145,27 +145,27 @@ impl Response {

     /// Serialize a response as a single-line JSON, including the
     /// newline. This is meant for the adapter to use.
     pub fn to_writer<W: Write>(&self, mut writer: W) -> Result<(), BrokerError> {
         let mut line = serde_json::to_string(&self).map_err(BrokerError::SerializeResponse)?;
     pub fn to_writer<W: Write>(&self, mut writer: W) -> Result<(), MessageError> {
         let mut line = serde_json::to_string(&self).map_err(MessageError::SerializeResponse)?;
         line.push('\n');
         writer
             .write(line.as_bytes())
             .map_err(BrokerError::WriteResponse)?;
             .map_err(MessageError::WriteResponse)?;
         Ok(())
     }
     /// Read a response from a reader. This is meant for the broker to
     /// use.
     pub fn from_reader<R: Read + BufRead>(reader: &mut R) -> Result<Option<Self>, BrokerError> {
     pub fn from_reader<R: Read + BufRead>(reader: &mut R) -> Result<Option<Self>, MessageError> {
         let mut line = String::new();
         let mut r = BufReader::new(reader);
         let n = r.read_line(&mut line).map_err(BrokerError::ReadLine)?;
         let n = r.read_line(&mut line).map_err(MessageError::ReadLine)?;
         if n == 0 {
             // Child's stdout was closed.
             Ok(None)
         } else {
             let req: Self = serde_json::from_slice(line.as_bytes())
                 .map_err(BrokerError::DeserializeResponse)?;
                 .map_err(MessageError::DeserializeResponse)?;
             Ok(Some(req))
         }
     }

@@ -173,7 +173,7 @@ impl Response {

 /// All possible errors from the CI broker messages.
 #[derive(Debug, thiserror::Error)]
 pub enum BrokerError {
 pub enum MessageError {
     /// Failed to serialize a request message as JSON. This should
     /// never happen and likely indicate a programming failure.
     #[error("failed to serialize a request into JSON to a file handle")]

@@ -205,15 +205,7 @@ pub enum BrokerError {

     #[error("failed to read a JSON request from a file handle")]
     DeserializeResponse(#[source] serde_json::Error),
     /// Error from an node event subscriber.
     #[error(transparent)]
     NodeEvent(#[from] crate::event::NodeEventError),
     /// Error from Radicle.
     #[error(transparent)]
     RadicleProfile(#[from] radicle::profile::Error),
     /// Error from spawning a sub-process.
     #[error(transparent)]
     Spawn(#[from] std::io::Error),
 }