645c543 feat: improve logging of event filtering — radicle-ci-broker

Radicle CI broker

feat: improve logging of event filtering

Lars Wirzenius committed 1 year ago

commit 645c5436cb3bffc5fc5f9157d31ea9412f62ac35
parent e16308414b7076dcf4aad60e9695bc541adb0f44

1 file changed +60 -58

modified src/event.rs

@@ -121,7 +121,6 @@ impl NodeEventSource {

                         if let Some(broker_events) = BrokerEvent::from_event(&event) {
                             for e in broker_events {
                                 if self.allowed(&e) {
                                     debug!("allowed {:#?}", e);
                                     result.push(e);
                                 }
                             }

@@ -366,53 +365,61 @@ impl BrokerEvent {

     /// Is this broker event allowed by a filter?
     pub fn is_allowed(&self, filter: &EventFilter) -> bool {
         trace!("is_allowed: called");
         let (rid, name) = match self {
             Self::Shutdown => return true,
         debug!("is_allowed called: filter={filter:?}");
         let res = self.is_allowed_helper(filter, 0);
         debug!("is_allowed: res={res}");
         res
     }
     fn is_allowed_helper(&self, filter: &EventFilter, level: usize) -> bool {
         let prefix = format!("{:width$}", " ", width = level * 4);
         trace!("is_allowed: {prefix} called {self:?}");
         let allowed = match self {
             Self::Shutdown => true,
             Self::RefChanged {
                 rid,
                 name,
                 oid: _,
                 old: _,
             } => (rid, name),
         };
         trace!("is_allowed: rid={rid:?}");
         trace!("is_allowed: name={name:?}");
         let allowed = match filter {
             EventFilter::Repository(wanted) => {
                 trace!("is_allowed: Repository: wanted={wanted:?}");
                 rid == wanted
             }
             EventFilter::RefSuffix(wanted) => name.ends_with(wanted),
             EventFilter::Branch(wanted) => {
                 trace!("is_allowed: Branch: wanted={wanted:?}");
                 let suffix = format!("refs/heads/{}", wanted);
                 let abs_suffix = format!("/{}", suffix);
                 trace!("is_allowed: Branch: suffix={suffix:?}");
                 trace!("is_allowed: Branch: abs_suffix={suffix:?}");
                 let is_branch = name.as_str() == suffix || name.ends_with(&abs_suffix);
                 trace!("is_allowed: Branch: is_branch={}", is_branch);
                 is_branch
             }
             EventFilter::AnyPatch => is_patch_update(name).is_some(),
             EventFilter::Patch(wanted) => is_patch_update(name) == Some(wanted),
             EventFilter::AnyPatchRef => {
                 matches!(parse_ref(name), Some(ParsedRef::Patch(_)))
             }
             EventFilter::AnyPushRef => {
                 matches!(parse_ref(name), Some(ParsedRef::Push(_)))
             }
             EventFilter::PatchRef(wanted) => {
                 if let Some(ParsedRef::Patch(ref_oid)) = parse_ref(name) {
                     return ref_oid == Oid::try_from(wanted.as_str()).unwrap();
                 oid,
                 old,
             } => {
                 trace!("is_allowed: {prefix} rid={rid:?}");
                 trace!("is_allowed: {prefix} name={name:?}");
                 trace!("is_allowed: {prefix} oid={oid:?}");
                 trace!("is_allowed: {prefix} old={old:?}");
                 trace!("is_allowed: {prefix} filter={filter:?}");
                 let parsed = parse_ref(name);
                 trace!("is_allowed: {prefix} parsed={parsed:?}");
                 match filter {
                     EventFilter::Repository(wanted) => rid == wanted,
                     EventFilter::RefSuffix(wanted) => name.ends_with(wanted),
                     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()))
                     }
                     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()))
                     }
                     EventFilter::And(conds) => conds
                         .iter()
                         .all(|cond| self.is_allowed_helper(cond, level + 1)),
                     EventFilter::Or(conds) => conds
                         .iter()
                         .any(|cond| self.is_allowed_helper(cond, level + 1)),
                     EventFilter::Not(conds) => !conds
                         .iter()
                         .any(|cond| self.is_allowed_helper(cond, level + 1)),
                 }
                 false
             }
             EventFilter::And(conds) => conds.iter().all(|cond| self.is_allowed(cond)),
             EventFilter::Or(conds) => conds.iter().any(|cond| self.is_allowed(cond)),
             EventFilter::Not(conds) => !conds.iter().any(|cond| self.is_allowed(cond)),
         };
         trace!("is_allowed: allowed={allowed}");
         trace!("is_allowed: {prefix} allowed={allowed}");
         allowed
     }

@@ -426,20 +433,15 @@ impl BrokerEvent {

     /// Extract the NID from the RefString.
     /// The RefString will start with `refs/namespaces/<nid>/...`
     pub fn nid(&self) -> Option<NodeId> {
         debug!("BrokerEvent::nid: name={:?}", self.name());
         if let Some(name) = self.name() {
             debug!("BrokerEvent::nid: Some(name)={name:?}");
             let mut parts = name.split('/');
             if let Some(nid) = parts.nth(2) {
                 debug!("BrokerEvent::nid: nid={nid:?}");
                 let parsed = nid.parse();
                 debug!("BrokerEvent::nid: parsed={parsed:?}");
                 if parsed.is_ok() {
                     return parsed.ok();
                 }
             }
         }
         debug!("BrokerEvent::nid: nope");
         None
     }

@@ -456,6 +458,7 @@ impl BrokerEvent {

 /// Parsed reference to one of the supported types
 /// Patch with patch ID
 /// Push with branch name
 #[derive(Debug, Eq, PartialEq)]
 pub enum ParsedRef {
     Patch(Oid),
     Push(String),

@@ -485,12 +488,14 @@ pub fn parse_ref(s: &str) -> Option<ParsedRef> {

             return Some(ParsedRef::Patch(oid));
         }
     }
     let push_re = Regex::new(r"^refs/namespaces/[^/]+/refs/heads/([^/]+)$").unwrap();
     if let Some(push_captures) = push_re.captures(s) {
         if let Some(branch) = push_captures.get(1) {
             return Some(ParsedRef::Push(branch.as_str().to_string()));
         }
     }
     None
 }

@@ -516,22 +521,19 @@ pub fn push_branch(name: &str) -> String {

 #[cfg(test)]
 mod test {
     use super::{is_patch_update, parse_ref, push_branch, ParsedRef};
     use super::{is_patch_update, parse_ref, push_branch, Oid, ParsedRef};
     #[test]
     fn test_parse_patch_ref() {
         let patch_ref =
             "refs/namespaces/NID/refs/heads/patches/9183ed6232687d3105482960cecb01a53018b80a";
         let parsed_ref = parse_ref(patch_ref);
         assert!(parsed_ref.is_some());
         if let Some(ref parsed) = parsed_ref {
             match parsed {
                 ParsedRef::Patch(oid) => {
                     assert_eq!(oid.to_string(), "9183ed6232687d3105482960cecb01a53018b80a")
                 }
                 _ => panic!("Expected Patch ref"),
             }
         }
         assert_eq!(
             parse_ref(patch_ref),
             Some(ParsedRef::Patch(
                 Oid::try_from("9183ed6232687d3105482960cecb01a53018b80a").unwrap()
             ))
         );
     }
     #[test]