use std::collections::BTreeSet;
use std::error::Error;
use std::fmt;
use std::time::Duration;
use crate::{validate_consumer, AccountNames, ConsumerSpec, LimitError, NamingError};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EventConsumer {
pub module_id: &'static str,
pub durable: &'static str,
pub filter_subjects: &'static [&'static str],
}
impl EventConsumer {
pub fn durable_name(&self) -> Result<String, NamingError> {
AccountNames::module_consumer_name(self.module_id)
}
}
pub const EVENT_CONSUMERS: &[EventConsumer] = &[
EventConsumer {
module_id: "prefrontal-core",
durable: "m_prefrontal-core",
filter_subjects: &["event.broca.>"],
},
EventConsumer {
module_id: "astrocyte",
durable: "m_astrocyte",
filter_subjects: &["event.insula.>"],
},
];
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AckPolicy {
Explicit,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DeliverPolicy {
All,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ModuleEventConsumerSpec {
pub consumer: ConsumerSpec,
pub pull: bool,
pub ack_policy: AckPolicy,
pub deliver_policy: DeliverPolicy,
pub ack_wait: Duration,
pub max_ack_pending: i64,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum EventConsumerError {
Naming(NamingError),
Limits(LimitError),
DuplicateModule(&'static str),
DuplicateDurable(&'static str),
DurableMismatch(&'static str),
InvalidFilters(String),
}
impl fmt::Display for EventConsumerError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Naming(error) => error.fmt(f),
Self::Limits(error) => error.fmt(f),
Self::DuplicateModule(id) => write!(f, "duplicate event-consumer module {id:?}"),
Self::DuplicateDurable(name) => write!(f, "duplicate event-consumer durable {name:?}"),
Self::DurableMismatch(id) => write!(f, "event-consumer durable must be m_{id}"),
Self::InvalidFilters(id) => {
write!(
f,
"event-consumer {id:?} needs nonempty filters under event."
)
}
}
}
}
impl Error for EventConsumerError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::Naming(error) => Some(error),
Self::Limits(error) => Some(error),
_ => None,
}
}
}
pub fn flow_engine_consumer_spec(
account: &AccountNames,
module_id: &str,
) -> Result<ModuleEventConsumerSpec, EventConsumerError> {
module_event_spec(account, module_id, &["event.>"])
}
pub fn event_consumer_specs(
account: &AccountNames,
) -> Result<Vec<ModuleEventConsumerSpec>, EventConsumerError> {
validate_table(EVENT_CONSUMERS)?;
EVENT_CONSUMERS
.iter()
.map(|entry| module_event_spec(account, entry.module_id, entry.filter_subjects))
.collect()
}
fn validate_table(entries: &[EventConsumer]) -> Result<(), EventConsumerError> {
let mut modules = BTreeSet::new();
let mut durables = BTreeSet::new();
for entry in entries {
if !modules.insert(entry.module_id) {
return Err(EventConsumerError::DuplicateModule(entry.module_id));
}
if !durables.insert(entry.durable) {
return Err(EventConsumerError::DuplicateDurable(entry.durable));
}
if entry.durable_name().map_err(EventConsumerError::Naming)? != entry.durable {
return Err(EventConsumerError::DurableMismatch(entry.module_id));
}
validate_filters(entry.module_id, entry.filter_subjects)?;
}
Ok(())
}
fn validate_filters(module_id: &str, filters: &[&str]) -> Result<(), EventConsumerError> {
if filters.is_empty()
|| filters
.iter()
.any(|filter| !filter.starts_with("event.") || filter.len() == "event.".len())
{
return Err(EventConsumerError::InvalidFilters(module_id.to_owned()));
}
Ok(())
}
fn module_event_spec(
account: &AccountNames,
module_id: &str,
filters: &[&str],
) -> Result<ModuleEventConsumerSpec, EventConsumerError> {
validate_filters(module_id, filters)?;
let consumer = ConsumerSpec {
durable: AccountNames::module_consumer_name(module_id)
.map_err(EventConsumerError::Naming)?,
stream: account.streams().event.clone(),
filter_subjects: filters
.iter()
.map(|filter| format!("ck.{}.{filter}", account.account()))
.collect(),
};
validate_consumer(&consumer, &crate::shipped_streams(account))
.map_err(EventConsumerError::Limits)?;
Ok(ModuleEventConsumerSpec {
consumer,
pull: true,
ack_policy: AckPolicy::Explicit,
deliver_policy: DeliverPolicy::All,
ack_wait: Duration::from_secs(30),
max_ack_pending: 1_000,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn event_consumer_table_rejects_duplicate_modules() {
let entry = EVENT_CONSUMERS[0];
assert_eq!(
validate_table(&[
entry,
EventConsumer {
durable: "m_other",
..entry
}
]),
Err(EventConsumerError::DuplicateModule("prefrontal-core"))
);
}
#[test]
fn event_consumer_table_rejects_duplicate_durables() {
let entry = EVENT_CONSUMERS[0];
assert_eq!(
validate_table(&[
entry,
EventConsumer {
module_id: "other",
..entry
}
]),
Err(EventConsumerError::DuplicateDurable("m_prefrontal-core"))
);
}
#[test]
fn event_consumer_table_requires_canonical_durable_names() {
let entry = EventConsumer {
durable: "m_other",
..EVENT_CONSUMERS[0]
};
assert_eq!(
validate_table(&[entry]),
Err(EventConsumerError::DurableMismatch("prefrontal-core"))
);
}
#[test]
fn event_consumer_filters_must_be_nonempty_and_under_event() {
for filters in [
&[][..],
&["peer.>"][..],
&["event"][..],
&["event."][..],
&["> "][..],
] {
let entry = EventConsumer {
filter_subjects: filters,
..EVENT_CONSUMERS[0]
};
assert!(matches!(
validate_table(&[entry]),
Err(EventConsumerError::InvalidFilters(_))
));
}
let names = AccountNames::derive("box_readers").unwrap();
assert!(module_event_spec(&names, "reader", &["event.broca.>.run"]).is_err());
}
}