exclude methods in agent

Author: sfavot

src/api/rule.rs

@@ -282,6 +282,7 @@ impl Rule {
     pub fn into_route(self, config: &RouterConfig) -> Route<Rule> {
         Route::new(
             self.source.methods.clone(),
+            self.source.exclude_methods,
             self.source.scheme.clone(),
             self.host(config.ignore_host_case),
             self.path_and_query(config.ignore_path_and_query_case),

src/build.rs

@@ -119,6 +119,8 @@ struct Source {
     headers: Option<Vec<SourceHeader>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     methods: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    exclude_methods: Option<bool>,
     #[serde(skip_serializing_if = "Vec::is_empty", default, with = "serde_yaml::with::singleton_map_recursive")]
     ips: Vec<IpConstraint>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -130,6 +132,8 @@ struct Source {
     #[serde(skip_serializing_if = "Option::is_none")]
     response_status_codes: Option<Vec<u16>>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    exclude_response_status_codes: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     sampling: Option<u32>,
 }
 

src/router/request_matcher/method.rs

@@ -7,6 +7,7 @@ use std::collections::HashMap;
 #[derive(Debug, Clone)]
 pub struct MethodMatcher<T: RouteData> {
     methods: HashMap<String, Box<dyn RequestMatcher<T>>>,
+    exclude_methods: HashMap<Vec<String>, Box<dyn RequestMatcher<T>>>,
     any_method: Box<dyn RequestMatcher<T>>,
     count: usize,
 }
@@ -21,6 +22,14 @@ impl<T: RouteData> RequestMatcher<T> for MethodMatcher<T> {
                 if methods.is_empty() {
                     self.any_method.insert(route);
                 } else {
+                    if route.exclude_methods().is_some() {
+                        self.exclude_methods
+                            .entry(methods.clone())
+                            .or_insert_with(|| MethodMatcher::create_sub_matcher())
+                            .insert(route.clone());
+
+                        return;
+                    }
                     for method in methods {
                         if !self.methods.contains_key(method) {
                             self.methods.insert(method.to_string(), MethodMatcher::create_sub_matcher());
@@ -48,6 +57,12 @@ impl<T: RouteData> RequestMatcher<T> for MethodMatcher<T> {
             matcher.len() > 0
         });
 
+        self.exclude_methods.retain(|_, matcher| {
+            removed = removed || matcher.remove(id);
+
+            matcher.len() > 0
+        });
+
         if removed {
             self.count -= 1;
         }
@@ -62,13 +77,47 @@ impl<T: RouteData> RequestMatcher<T> for MethodMatcher<T> {
             routes.extend(matcher.match_request(request));
         }
 
+        for (methods, matcher) in &self.exclude_methods {
+            if !methods.contains(&request.method().into()) {
+                routes.extend(matcher.match_request(request));
+            }
+        }
+
         routes
     }
 
     fn trace(&self, request: &Request) -> Vec<Trace<T>> {
         let mut traces = self.any_method.trace(request);
         let request_method = request.method();
 
+        for (methods, matcher) in &self.exclude_methods {
+            if !methods.contains(&request_method.into()) {
+                let method_traces = matcher.trace(request);
+
+                traces.push(Trace::new(
+                    true,
+                    true,
+                    matcher.len() as u64,
+                    method_traces,
+                    TraceInfo::ExcludeMethods {
+                        request: request_method.to_string(),
+                        against: Some(methods.clone()),
+                    },
+                ));
+            } else {
+                traces.push(Trace::new(
+                    false,
+                    false,
+                    matcher.len() as u64,
+                    Vec::new(),
+                    TraceInfo::ExcludeMethods {
+                        request: request_method.to_string(),
+                        against: Some(methods.clone()),
+                    },
+                ));
+            }
+        }
+
         for (method, matcher) in &self.methods {
             if method == request_method {
                 let method_traces = matcher.trace(request);
@@ -140,6 +189,7 @@ impl<T: RouteData> Default for MethodMatcher<T> {
     fn default() -> Self {
         MethodMatcher {
             methods: HashMap::new(),
+            exclude_methods: HashMap::new(),
             any_method: MethodMatcher::create_sub_matcher(),
             count: 0,
         }

src/router/route.rs

@@ -33,6 +33,7 @@ impl<T: RouteData> Route<T> {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         methods: Option<Vec<String>>,
+        exclude_methods: Option<bool>,
         scheme: Option<String>,
         host: Option<StaticOrDynamic>,
         path_and_query: StaticOrDynamic,
@@ -50,6 +51,7 @@ impl<T: RouteData> Route<T> {
             scheme,
             host,
             methods,
+            exclude_methods,
             path_and_query,
             headers,
             ips,
@@ -81,6 +83,8 @@ impl<T: RouteData> Route<T> {
         self.methods.as_ref()
     }
 
+    pub fn exclude_methods(&self) -> Option<bool> { self.exclude_methods }
+
     pub fn priority(&self) -> i64 {
         self.priority
     }

src/router/trace.rs

@@ -29,6 +29,7 @@ pub enum TraceInfo<T: RouteData> {
     Ip { request: String, against: String },
     DateTimeGroup { conditions: Vec<TraceInfoDateTimeCondition> },
     Method { request: String, against: Option<String> },
+    ExcludeMethods { request: String, against: Option<Vec<String>> },
     HeaderGroup { conditions: Vec<TraceInfoHeaderCondition> },
     PathAndQueryStatic { request: String },
     PathAndQueryRegex,

tests/redirectionio_router_test.rs

@@ -9231,7 +9231,7 @@ fn setup_rule_methods_trigger() -> Router<Rule> {
     let config: RouterConfig = serde_json::from_str(r#"{"always_match_any_host":false,"ignore_header_case":false,"ignore_host_case":false,"ignore_marketing_query_params":true,"ignore_path_and_query_case":false,"marketing_query_params":["utm_source","utm_medium","utm_campaign","utm_term","utm_content"],"pass_marketing_query_params_to_target":true}"#).expect("cannot deserialize");
     let mut router = Router::<Rule>::from_config(config);
 
-    let route_1: Rule = serde_json::from_str(r#"{"id":"rule-exclude-methods","rank":0,"source":{"methods":["GET","POST"],"path":"/exclude-methods"},"status_code":302,"target":"/bar"}"#).expect("cannot deserialize");
+    let route_1: Rule = serde_json::from_str(r#"{"id":"rule-exclude-methods","rank":0,"source":{"exclude_methods":true,"methods":["GET","POST"],"path":"/exclude-methods"},"status_code":302,"target":"/bar"}"#).expect("cannot deserialize");
     router.insert(route_1.into_route(&router.config));
 
     let route_2: Rule = serde_json::from_str(r#"{"id":"rule-include-methods","rank":0,"source":{"methods":["GET","POST"],"path":"/include-methods"},"status_code":302,"target":"/bar"}"#).expect("cannot deserialize");
@@ -9778,7 +9778,7 @@ fn setup_rule_response_status_codes_trigger() -> Router<Rule> {
     let config: RouterConfig = serde_json::from_str(r#"{"always_match_any_host":false,"ignore_header_case":false,"ignore_host_case":false,"ignore_marketing_query_params":true,"ignore_path_and_query_case":false,"marketing_query_params":["utm_source","utm_medium","utm_campaign","utm_term","utm_content"],"pass_marketing_query_params_to_target":true}"#).expect("cannot deserialize");
     let mut router = Router::<Rule>::from_config(config);
 
-    let route_1: Rule = serde_json::from_str(r#"{"id":"rule-exclude-status-codes","rank":0,"source":{"path":"/exclude-status-codes","response_status_codes":[200,201]},"status_code":302,"target":"/bar"}"#).expect("cannot deserialize");
+    let route_1: Rule = serde_json::from_str(r#"{"id":"rule-exclude-status-codes","rank":0,"source":{"exclude_response_status_codes":true,"path":"/exclude-status-codes","response_status_codes":[200,201]},"status_code":302,"target":"/bar"}"#).expect("cannot deserialize");
     router.insert(route_1.into_route(&router.config));
 
     let route_2: Rule = serde_json::from_str(r#"{"id":"rule-include-status-codes","rank":0,"source":{"path":"/include-status-codes","response_status_codes":[200,201]},"status_code":302,"target":"/bar"}"#).expect("cannot deserialize");