edc6cb4 refactor: rename NodeEventError to BrokerEventError, for clarity — radicle-ci-broker

modified src/bin/cibtool.rs

@@ -30,7 +30,7 @@ use radicle_git_ext::Oid;

 use radicle_ci_broker::{
     broker::BrokerError,
     db::{Db, DbError, QueueId, QueuedEvent},
     event::{BrokerEvent, NodeEventError},
     event::{BrokerEvent, BrokerEventError},
     logger,
     msg::{RunId, RunResult},
     notif::NotificationChannel,

@@ -314,10 +314,10 @@ enum CibToolError {

     NoDb,
     #[error("failed to subscribe to node events")]
     EventSubscribe(#[source] radicle_ci_broker::event::NodeEventError),
     EventSubscribe(#[source] radicle_ci_broker::event::BrokerEventError),
     #[error("failed to get next node event")]
     GetNodeEvent(#[source] radicle_ci_broker::event::NodeEventError),
     GetNodeEvent(#[source] radicle_ci_broker::event::BrokerEventError),
     #[error("failed to create file for node events: {0}")]
     CreateEventsFile(PathBuf, #[source] std::io::Error),

@@ -344,8 +344,11 @@ enum CibToolError {

     CreateBrokerEventsFile(PathBuf, #[source] std::io::Error),
     #[error("failed to read filters from YAML file {0}")]
     ReadFilters(PathBuf, #[source] radicle_ci_broker::event::NodeEventError),
     ReadFilters(
         PathBuf,
         #[source] radicle_ci_broker::event::BrokerEventError,
     ),
     #[error("failed to check if event is allowed: {0:#?}")]
     EventIsAllowed(BrokerEvent, #[source] NodeEventError),
     EventIsAllowed(BrokerEvent, #[source] BrokerEventError),
 }

modified src/broker.rs

@@ -135,7 +135,7 @@ pub enum BrokerError {

     /// Error from an node event subscriber.
     #[error(transparent)]
     NodeEvent(#[from] crate::event::NodeEventError),
     NodeEvent(#[from] crate::event::BrokerEventError),
     /// Error from Radicle.
     #[error(transparent)]

modified src/event.rs

@@ -56,8 +56,8 @@ pub struct BrokerEventSource {

 impl BrokerEventSource {
     /// Create a new source of node events, for a given Radicle
     /// profile.
     pub fn new(profile: &Profile) -> Result<Self, NodeEventError> {
         let source = NodeEventSource::new(profile).map_err(NodeEventError::CannotSubscribe)?;
     pub fn new(profile: &Profile) -> Result<Self, BrokerEventError> {
         let source = NodeEventSource::new(profile).map_err(BrokerEventError::CannotSubscribe)?;
         Ok(Self {
             source,
             allowed: vec![],

@@ -69,7 +69,7 @@ impl BrokerEventSource {

         self.allowed.push(filter);
     }
     fn allowed(&self, event: &BrokerEvent) -> Result<bool, NodeEventError> {
     fn allowed(&self, event: &BrokerEvent) -> Result<bool, BrokerEventError> {
         for filter in self.allowed.iter() {
             if !event.is_allowed(filter)? {
                 return Ok(false);

@@ -82,15 +82,15 @@ impl BrokerEventSource {

     /// filtering. This will block until there is an event, or until
     /// there will be no more events from this source, or there's an
     /// error.
     pub fn node_event(&mut self) -> Result<Option<Event>, NodeEventError> {
     pub fn node_event(&mut self) -> Result<Option<Event>, BrokerEventError> {
         match self.source.node_event() {
             Err(crate::event_source::NodeEventError::BrokenConnection) => {
                 logger::event_disconnected();
                 Err(NodeEventError::BrokenConnection)
                 Err(BrokerEventError::BrokenConnection)
             }
             Err(err) => {
                 logger::error("error reading event from node", &err);
                 Err(NodeEventError::NodeEventError(err))
                 Err(BrokerEventError::NodeEventError(err))
             }
             Ok(maybe_event) => Ok(maybe_event),
         }

@@ -99,16 +99,16 @@ impl BrokerEventSource {

     /// Get the allowed next event from an event source. This will
     /// block until there is an allowed event, or until there will be
     /// no more events from this source, or there's an error.
     pub fn event(&mut self) -> Result<Vec<BrokerEvent>, NodeEventError> {
     pub fn event(&mut self) -> Result<Vec<BrokerEvent>, BrokerEventError> {
         loop {
             match self.source.node_event() {
                 Err(crate::event_source::NodeEventError::BrokenConnection) => {
                     logger::event_disconnected();
                     return Err(NodeEventError::BrokenConnection);
                     return Err(BrokerEventError::BrokenConnection);
                 }
                 Err(err) => {
                     logger::error("error reading event from node", &err);
                     return Err(NodeEventError::NodeEventError(err));
                     return Err(BrokerEventError::NodeEventError(err));
                 }
                 Ok(None) => {
                     logger::event_end();

@@ -134,7 +134,7 @@ impl BrokerEventSource {

 /// Possible errors from accessing the local Radicle node.
 #[derive(Debug, thiserror::Error)]
 pub enum NodeEventError {
 pub enum BrokerEventError {
     /// Can't create a [`NodeEventSource`].
     #[error("failed to subscribe to node events")]
     CannotSubscribe(#[source] crate::event_source::NodeEventError),

@@ -226,12 +226,12 @@ pub enum EventFilter {

 impl EventFilter {
     /// Create a filter for a repository.
     pub fn repository(rid: &str) -> Result<Self, NodeEventError> {
     pub fn repository(rid: &str) -> Result<Self, BrokerEventError> {
         Ok(Self::Repository(RepoId::from_urn(rid)?))
     }
     /// Create a filter for a git ref that ends with a string.
     pub fn glob(pattern: &str) -> Result<Self, NodeEventError> {
     pub fn glob(pattern: &str) -> Result<Self, BrokerEventError> {
         Ok(Self::RefSuffix(pattern.into()))
     }

@@ -257,20 +257,20 @@ impl EventFilter {

     /// instead of a `Filter`.
     ///
     /// See the module description for an example of the file content.
     pub fn from_file(filename: &Path) -> Result<Vec<Self>, NodeEventError> {
     pub fn from_file(filename: &Path) -> Result<Vec<Self>, BrokerEventError> {
         let filters =
             read(filename).map_err(|e| NodeEventError::ReadFilterFile(filename.into(), e))?;
             read(filename).map_err(|e| BrokerEventError::ReadFilterFile(filename.into(), e))?;
         let filters: Filters = serde_json::from_slice(&filters)
             .map_err(|e| NodeEventError::FiltersJsonFile(filename.into(), e))?;
             .map_err(|e| BrokerEventError::FiltersJsonFile(filename.into(), e))?;
         Ok(filters.filters)
     }
     /// Read filters from a YAML file.
     pub fn from_yaml_file(filename: &Path) -> Result<Vec<Self>, NodeEventError> {
     pub fn from_yaml_file(filename: &Path) -> Result<Vec<Self>, BrokerEventError> {
         let filters =
             read(filename).map_err(|e| NodeEventError::ReadFilterFile(filename.into(), e))?;
             read(filename).map_err(|e| BrokerEventError::ReadFilterFile(filename.into(), e))?;
         let filters: Filters = serde_yml::from_slice(&filters)
             .map_err(|e| NodeEventError::FiltersYamlFile(filename.into(), e))?;
             .map_err(|e| BrokerEventError::FiltersYamlFile(filename.into(), e))?;
         Ok(filters.filters)
     }
 }

@@ -284,10 +284,10 @@ pub struct Filters {

 }
 impl TryFrom<&str> for Filters {
     type Error = NodeEventError;
     type Error = BrokerEventError;
     fn try_from(s: &str) -> Result<Self, Self::Error> {
         serde_json::from_str(s).map_err(NodeEventError::FiltersJsonString)
         serde_json::from_str(s).map_err(BrokerEventError::FiltersJsonString)
     }
 }

@@ -364,12 +364,12 @@ impl BrokerEvent {

     }
     /// Is this broker event allowed by a filter?
     pub fn is_allowed(&self, filter: &EventFilter) -> Result<bool, NodeEventError> {
     pub fn is_allowed(&self, filter: &EventFilter) -> Result<bool, BrokerEventError> {
         let res = self.is_allowed_helper(filter)?;
         Ok(res)
     }
     fn is_allowed_helper(&self, filter: &EventFilter) -> Result<bool, NodeEventError> {
     fn is_allowed_helper(&self, filter: &EventFilter) -> Result<bool, BrokerEventError> {
         let allowed = match self {
             Self::Shutdown => true,
             Self::RefChanged {

@@ -387,14 +387,14 @@ impl BrokerEvent {

                     EventFilter::AnyPatch => matches!(parsed, Some(ParsedRef::Patch(_))),
                     EventFilter::Patch(wanted) => {
                         let oid = Oid::try_from(wanted.as_str())
                             .map_err(|e| NodeEventError::ParseOid(wanted.into(), e))?;
                             .map_err(|e| BrokerEventError::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) => {
                         let oid = Oid::try_from(wanted.as_str())
                             .map_err(|e| NodeEventError::ParseOid(wanted.into(), e))?;
                             .map_err(|e| BrokerEventError::ParseOid(wanted.into(), e))?;
                         parsed == Some(ParsedRef::Patch(oid))
                     }
                     EventFilter::And(conds) => conds

@@ -422,7 +422,7 @@ impl BrokerEvent {

     /// Extract the NID from the RefString.
     /// The RefString will start with `refs/namespaces/<nid>/...`
     pub fn nid(&self) -> Result<Option<NodeId>, NodeEventError> {
     pub fn nid(&self) -> Result<Option<NodeId>, BrokerEventError> {
         if let Some(name) = self.name() {
             Ok(parse_nid_from_refstring(name)?)
         } else {

@@ -430,7 +430,7 @@ impl BrokerEvent {

         }
     }
     pub fn patch_id(&self) -> Result<Option<Oid>, NodeEventError> {
     pub fn patch_id(&self) -> Result<Option<Oid>, BrokerEventError> {
         if let Some(name) = self.name() {
             if let Some(ParsedRef::Patch(oid)) = parse_ref(name)? {
                 return Ok(Some(oid));

@@ -442,9 +442,9 @@ impl BrokerEvent {

 /// 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) -> Result<Option<NodeId>, NodeEventError> {
 pub fn parse_nid_from_refstring(name: &RefString) -> Result<Option<NodeId>, BrokerEventError> {
     const PAT: &str = r"^refs/namespaces/(?P<nid>[^/]+)/";
     let pat = Regex::new(PAT).map_err(|e| NodeEventError::Regex(PAT, e))?;
     let pat = Regex::new(PAT).map_err(|e| BrokerEventError::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() {

@@ -535,20 +535,20 @@ pub enum ParsedRef {

 ///     }
 /// }
 /// ```
 pub fn parse_ref(s: &str) -> Result<Option<ParsedRef>, NodeEventError> {
 pub fn parse_ref(s: &str) -> Result<Option<ParsedRef>, BrokerEventError> {
     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))?;
     let patch_re = Regex::new(PAT_PATCH).map_err(|e| BrokerEventError::Regex(PAT_PATCH, e))?;
     if let Some(patch_captures) = patch_re.captures(s) {
         if let Some(patch_id) = patch_captures.get(1) {
             let patch_id_str = patch_id.as_str();
             let oid = Oid::try_from(patch_id_str)
                 .map_err(|e| NodeEventError::ParseOid(patch_id_str.into(), e))?;
                 .map_err(|e| BrokerEventError::ParseOid(patch_id_str.into(), e))?;
             return Ok(Some(ParsedRef::Patch(oid)));
         }
     }
     const PAT_BRANCH: &str = r"^refs/namespaces/[^/]+/refs/heads/(.+)$";
     let push_re = Regex::new(PAT_BRANCH).map_err(|e| NodeEventError::Regex(PAT_BRANCH, e))?;
     let push_re = Regex::new(PAT_BRANCH).map_err(|e| BrokerEventError::Regex(PAT_BRANCH, e))?;
     if let Some(push_captures) = push_re.captures(s) {
         if let Some(branch) = push_captures.get(1) {
             return Ok(Some(ParsedRef::Push(branch.as_str().to_string())));

modified src/msg.rs

@@ -769,7 +769,7 @@ pub enum MessageError {

     /// Error from event module.
     #[error(transparent)]
     EventError(#[from] crate::event::NodeEventError),
     EventError(#[from] crate::event::BrokerEventError),
     /// Error from Radicle repository.
     #[error(transparent)]

modified src/queueadd.rs

@@ -4,7 +4,7 @@ use radicle::Profile;

 use crate::{
     db::{Db, DbError},
     event::{BrokerEvent, BrokerEventSource, EventFilter, NodeEventError},
     event::{BrokerEvent, BrokerEventError, BrokerEventSource, EventFilter},
     logger,
     notif::NotificationSender,
 };

@@ -112,7 +112,7 @@ pub enum AdderError {

     Profile(#[from] radicle::profile::Error),
     #[error(transparent)]
     NodeEvent(#[from] NodeEventError),
     NodeEvent(#[from] BrokerEventError),
     #[error(transparent)]
     Db(#[from] DbError),