impact computing

Author: sfavot

src/http/request.rs

@@ -128,6 +128,10 @@ impl Request {
             request.remote_addr = Some(IpAddr::from_str(ip).unwrap());
         }
 
+        if let Some(datetime) = &example.datetime {
+            request.set_created_at(Some(datetime.to_string()));
+        }
+
         Ok(request)
     }
 

src/router/mod.rs

@@ -13,7 +13,7 @@ mod transformer;
 use crate::http::Request;
 pub use config::RouterConfig;
 pub use marker_string::{Marker, MarkerString, StaticOrDynamic};
-pub use request_matcher::{HostMatcher, IpMatcher, DateTimeMatcher, WeekdayMatcher, TimeMatcher, MethodMatcher, PathAndQueryMatcher, RequestMatcher, SchemeMatcher};
+pub use request_matcher::{HostMatcher, IpMatcher, DateTimeMatcher, MethodMatcher, PathAndQueryMatcher, RequestMatcher, SchemeMatcher};
 pub use route::{Route, RouteData};
 pub use route_datetime::RouteDateTime;
 pub use route_header::{RouteHeader, RouteHeaderKind};

src/router/request_matcher/datetime.rs

@@ -1,49 +1,91 @@
 use crate::http::Request;
+use crate::router::request_matcher::{MethodMatcher, RequestMatcher};
 use crate::router::route_datetime::RouteDateTime;
-use crate::router::trace::TraceInfo;
-use crate::router::{WeekdayMatcher, RequestMatcher, Route, RouteData, Trace};
-use std::collections::HashMap;
+use crate::router::route_time::RouteTime;
+use crate::router::route_weekday::RouteWeekday;
+use crate::router::trace::{TraceInfo, TraceInfoDateTimeCondition};
+use crate::router::{Route, RouteData, Trace};
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::collections::BTreeSet;
 
 #[derive(Debug, Clone)]
 pub struct DateTimeMatcher<T: RouteData> {
-    matchers: HashMap<RouteDateTime, Box<dyn RequestMatcher<T>>>,
-    no_matcher: Box<dyn RequestMatcher<T>>,
+    any_datetime: Box<dyn RequestMatcher<T>>,
+    conditions: BTreeSet<DateTimeCondition>,
+    condition_groups: BTreeMap<BTreeSet<DateTimeCondition>, Box<dyn RequestMatcher<T>>>,
     count: usize,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone, Hash, Eq, PartialEq, Ord, PartialOrd)]
+#[serde(rename_all = "snake_case")]
+#[serde(tag = "type", content = "date_time_type")]
+pub enum DateTimeCondition {
+    DateTimeRange(Vec<RouteDateTime>),
+    TimeRange(Vec<RouteTime>),
+    Weekdays(RouteWeekday),
+}
+
 impl<T: RouteData> RequestMatcher<T> for DateTimeMatcher<T> {
     fn insert(&mut self, route: Route<T>) {
         self.count += 1;
 
+        let mut condition_group = BTreeSet::new();
+        let mut conditions = BTreeSet::new();
+
         match route.datetime() {
-            Some(route_datetimes) => {
-                for route_datetime in route_datetimes {
-                    self.matchers
-                        .entry(route_datetime.clone())
-                        .or_insert_with(|| Self::create_sub_matcher())
-                        .insert(route.clone());
-                }
+            Some(route_datetime) => {
+                let condition = DateTimeCondition::DateTimeRange(route_datetime.clone());
+                condition_group.insert(condition.clone());
+                conditions.insert(condition);
             }
-            None => {
-                self.no_matcher.insert(route);
+            None => (),
+        }
+
+        match route.weekdays() {
+            Some(route_weekdays) => {
+                let condition = DateTimeCondition::Weekdays(route_weekdays.clone());
+                condition_group.insert(condition.clone());
+                conditions.insert(condition);
             }
+            None => (),
         }
-    }
 
-    fn remove(&mut self, id: &str) -> bool {
-        let mut removed = false;
+        match route.time() {
+            Some(route_time) => {
+                let condition = DateTimeCondition::TimeRange(route_time.clone());
+                condition_group.insert(condition.clone());
+                conditions.insert(condition);
+            }
+            None => (),
+        }
 
-        if self.no_matcher.remove(id) {
-            self.count -= 1;
+        if conditions.is_empty() {
+            self.any_datetime.insert(route);
+
+            return;
+        }
+
+        self.conditions.extend(conditions);
 
-            return true;
+        if !self.condition_groups.contains_key(&condition_group) {
+            self.condition_groups.insert(condition_group.clone(), Self::create_sub_matcher());
         }
 
-        self.matchers.retain(|_, matcher| {
+        let matcher = self.condition_groups.get_mut(&condition_group).unwrap();
+
+        matcher.insert(route)
+    }
+
+    fn remove(&mut self, id: &str) -> bool {
+        let mut removed = false;
+
+        for matcher in self.condition_groups.values_mut() {
             removed = removed || matcher.remove(id);
+        }
 
-            matcher.len() > 0
-        });
+        removed = removed || self.any_datetime.remove(id);
 
         if removed {
             self.count -= 1;
@@ -53,63 +95,108 @@ impl<T: RouteData> RequestMatcher<T> for DateTimeMatcher<T> {
     }
 
     fn match_request(&self, request: &Request) -> Vec<&Route<T>> {
-        let mut routes = self.no_matcher.match_request(request);
+        let mut rules = self.any_datetime.match_request(request);
+        let mut execute_conditions = BTreeMap::new();
 
         if let Some(datetime) = request.created_at.as_ref() {
-            for (datetime_matcher, matcher) in &self.matchers {
-                if datetime_matcher.match_datetime(datetime) {
-                    routes.extend(matcher.match_request(request));
+            'group: for (conditions, matcher) in &self.condition_groups {
+                for condition in conditions {
+                    match execute_conditions.get(condition) {
+                        None => {
+                            // Execute condition
+                            let result = condition.match_value(datetime);
+
+                            // Save result
+                            execute_conditions.insert(condition.clone(), result);
+
+                            if !result {
+                                continue 'group;
+                            }
+                        }
+                        Some(result) => {
+                            if !result {
+                                continue 'group;
+                            }
+                        }
+                    }
                 }
+
+                rules.extend(matcher.match_request(request));
             }
         }
 
-        routes
+        rules
     }
 
     fn trace(&self, request: &Request) -> Vec<Trace<T>> {
-        let mut traces = self.no_matcher.trace(request);
+        let mut traces = self.any_datetime.trace(request);
+        let mut execute_conditions = BTreeMap::new();
 
         if let Some(datetime) = request.created_at.as_ref() {
-            for (datetime_matcher, matcher) in &self.matchers {
-                if datetime_matcher.match_datetime(datetime) {
-                    let datetime_traces = matcher.trace(request);
-
-                    traces.push(Trace::new(
-                        true,
-                        true,
-                        matcher.len() as u64,
-                        datetime_traces,
-                        TraceInfo::DateTime {
-                            request: datetime.to_string(),
-                            against: datetime_matcher.to_string(),
-                        },
-                    ));
-                } else {
-                    traces.push(Trace::new(
-                        false,
-                        true,
-                        matcher.len() as u64,
-                        Vec::new(),
-                        TraceInfo::DateTime {
-                            request: datetime.to_string(),
-                            against: datetime_matcher.to_string(),
-                        },
-                    ))
+            for (conditions, matcher) in &self.condition_groups {
+                let mut matched = true;
+                let mut executed = true;
+                let mut traces_info_datetime = Vec::new();
+
+                for condition in conditions {
+                    match execute_conditions.get(condition) {
+                        None => {
+                            // Execute condition
+                            let result = condition.match_value(datetime);
+                            matched = matched && result;
+
+                            // Save result (only if executed to mimic cache behavior)
+                            if executed {
+                                execute_conditions.insert(condition.clone(), matched);
+                            }
+
+                            traces_info_datetime.push(TraceInfoDateTimeCondition {
+                                result: if executed { Some(result) } else { None },
+                                condition: condition.clone(),
+                                against: datetime.clone(),
+                                cached: false,
+                            });
+
+                            executed = matched;
+                        }
+                        Some(result) => {
+                            matched = matched && *result;
+
+                            traces_info_datetime.push(TraceInfoDateTimeCondition {
+                                result: if executed { Some(*result) } else { None },
+                                condition: condition.clone(),
+                                against: datetime.clone(),
+                                cached: true,
+                            });
+
+                            executed = matched;
+                        }
+                    }
                 }
+
+                traces.push(Trace::new(
+                    matched,
+                    true,
+                    matcher.len() as u64,
+                    if matched { matcher.trace(request) } else { Vec::new() },
+                    TraceInfo::DateTimeGroup {
+                        conditions: traces_info_datetime,
+                    },
+                ));
             }
         }
 
         traces
     }
 
     fn cache(&mut self, limit: u64, level: u64) -> u64 {
-        let mut new_limit = self.no_matcher.cache(limit, level);
+        let mut new_limit = limit;
 
-        for matcher in self.matchers.values_mut() {
+        for matcher in self.condition_groups.values_mut() {
             new_limit = matcher.cache(new_limit, level);
         }
 
-        new_limit
+        self.any_datetime.cache(new_limit, level)
     }
 
     fn len(&self) -> usize {
@@ -128,15 +215,40 @@ impl<T: RouteData> RequestMatcher<T> for DateTimeMatcher<T> {
 impl<T: RouteData> Default for DateTimeMatcher<T> {
     fn default() -> Self {
         DateTimeMatcher {
-            matchers: HashMap::new(),
-            no_matcher: Self::create_sub_matcher(),
+            any_datetime: DateTimeMatcher::create_sub_matcher(),
+            conditions: BTreeSet::new(),
+            condition_groups: BTreeMap::new(),
             count: 0,
         }
     }
 }
 
 impl<T: RouteData> DateTimeMatcher<T> {
     pub fn create_sub_matcher() -> Box<dyn RequestMatcher<T>> {
-        Box::<WeekdayMatcher<T>>::default()
+        Box::<MethodMatcher<T>>::default()
+    }
+}
+
+impl DateTimeCondition {
+    pub fn match_value(&self, datetime: &DateTime<Utc>) -> bool {
+        match self {
+            DateTimeCondition::DateTimeRange(route_date_time) =>  {
+                for range in route_date_time {
+                    if range.match_datetime(datetime) {
+                        return true;
+                    }
+                }
+                return false;
+            },
+            DateTimeCondition::TimeRange(route_time) => {
+                for range in route_time {
+                    if range.match_datetime(datetime) {
+                        return true;
+                    }
+                }
+                return false;
+            },
+            DateTimeCondition::Weekdays(route_weekday) => route_weekday.match_datetime(datetime),
+        }
     }
 }

src/router/request_matcher/mod.rs

@@ -7,23 +7,19 @@ mod method;
 mod path_and_query;
 mod route_matcher;
 mod scheme;
-mod time;
-mod weekday;
 
 use crate::http::Request;
 use crate::router::{Route, RouteData, Trace};
 use std::fmt::Debug;
 
-pub use datetime::DateTimeMatcher;
+pub use datetime::{DateTimeMatcher, DateTimeCondition};
 pub use header::{HeaderMatcher, ValueCondition as HeaderValueCondition};
 pub use host::HostMatcher;
 pub use ip::IpMatcher;
 pub use method::MethodMatcher;
 pub use path_and_query::PathAndQueryMatcher;
 pub use route_matcher::RouteMatcher;
 pub use scheme::SchemeMatcher;
-pub use time::TimeMatcher;
-pub use weekday::WeekdayMatcher;
 
 pub trait RequestMatcher<T: RouteData>: Debug + Send + Sync {
     fn insert(&mut self, route: Route<T>);