use crate::rules::{PatternRules, TargetIdSet};
use hashbrown::HashMap;
use rustfs_s3_types::EventName;
use rustfs_targets::arn::TargetID;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RulesMap {
map: HashMap<EventName, PatternRules>,
total_events_mask: u64,
}
impl RulesMap {
pub fn new() -> Self {
Default::default()
}
pub fn add_rule_config(&mut self, event_names: &[EventName], pattern: String, target_id: TargetID) {
let effective_pattern = if pattern.is_empty() {
"*".to_string() } else {
pattern
};
for event_name_spec in event_names {
for expanded_event_name in event_name_spec.expand() {
self.map
.entry(expanded_event_name)
.or_default()
.add(effective_pattern.clone(), target_id.clone());
self.total_events_mask |= expanded_event_name.mask();
}
}
}
pub fn add_map(&mut self, other_map: &Self) {
for (event_name, other_pattern_rules) in &other_map.map {
self.map.entry(*event_name).or_default().union_in_place(other_pattern_rules);
}
self.total_events_mask |= other_map.total_events_mask;
}
pub fn remove_map(&mut self, other_map: &Self) {
let mut events_to_remove = Vec::new();
for (event_name, self_pattern_rules) in &mut self.map {
if let Some(other_pattern_rules) = other_map.map.get(event_name) {
self_pattern_rules.difference_in_place(other_pattern_rules);
if self_pattern_rules.is_empty() {
events_to_remove.push(*event_name);
}
}
}
for event_name in events_to_remove {
self.map.remove(&event_name);
}
self.recalculate_mask();
}
pub fn has_subscriber(&self, event_name: &EventName) -> bool {
(self.total_events_mask & event_name.mask()) != 0
}
pub fn match_rules(&self, event_name: EventName, object_key: &str) -> TargetIdSet {
if (self.total_events_mask & event_name.mask()) == 0 {
return TargetIdSet::new(); }
self.map
.get(&event_name)
.map_or_else(TargetIdSet::new, |pr| pr.match_targets(object_key))
}
pub fn is_empty(&self) -> bool {
self.map.is_empty()
}
pub fn contains_target_id(&self, target_id: &TargetID) -> bool {
self.map.values().any(|pr| pr.contains_target_id(target_id))
}
pub fn inner(&self) -> &HashMap<EventName, PatternRules> {
&self.map
}
fn recalculate_mask(&mut self) {
let mut new_mask = 0u64;
for event_name in self.map.keys() {
new_mask |= event_name.mask();
}
self.total_events_mask = new_mask;
}
pub fn remove_rule(&mut self, event_name: &EventName, pattern: &str) {
let mut remove_event = false;
if let Some(pattern_rules) = self.map.get_mut(event_name) {
pattern_rules.remove_pattern(pattern);
if pattern_rules.is_empty() {
remove_event = true;
}
}
if remove_event {
self.map.remove(event_name);
}
self.recalculate_mask(); }
pub fn remove_rules(&mut self, event_names: &[EventName]) {
for event_name in event_names {
self.map.remove(event_name);
}
self.recalculate_mask(); }
pub fn update_rule(&mut self, event_name: EventName, pattern: String, target_id: TargetID) {
self.map.entry(event_name).or_default().add(pattern, target_id);
self.total_events_mask |= event_name.mask(); }
#[inline]
pub fn iter_events(&self) -> impl Iterator<Item = EventName> + '_ {
self.inner().keys().copied()
}
}