use crate::error::{Error, ensure};
use crate::{error_policy::ErrorPolicy, retry::RetryPolicy};
use std::time::Duration;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum ProcessingOrder {
#[default]
PerKey,
Unordered,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct TransactionBatch {
pub max_deliveries: usize,
pub max_linger: Duration,
}
impl TransactionBatch {
pub fn new(max_deliveries: usize, max_linger: Duration) -> Self {
Self {
max_deliveries,
max_linger,
}
}
pub fn single() -> Self {
Self::new(1, Duration::ZERO)
}
pub(crate) fn validate(&self) -> Result<(), Error> {
ensure!(
self.max_deliveries > 0,
Error::config,
"transaction batch size must be positive"
);
Ok(())
}
}
impl Default for TransactionBatch {
fn default() -> Self {
Self::new(100, Duration::from_millis(10))
}
}
#[derive(Clone, Debug)]
pub struct SubscriptionConfig {
pub concurrency: usize,
pub max_in_flight: usize,
pub ordering: ProcessingOrder,
pub handler_retry: RetryPolicy,
pub receive_retry: RetryPolicy,
pub publish_retry: RetryPolicy,
pub dead_letter_retry: RetryPolicy,
pub error_policy: ErrorPolicy,
pub drain_timeout: Duration,
pub transaction_batch: TransactionBatch,
}
impl Default for SubscriptionConfig {
fn default() -> Self {
Self {
concurrency: 1,
max_in_flight: 64,
ordering: ProcessingOrder::default(),
handler_retry: RetryPolicy::default(),
receive_retry: RetryPolicy::default(),
publish_retry: RetryPolicy::default(),
dead_letter_retry: RetryPolicy::default(),
error_policy: ErrorPolicy::default(),
drain_timeout: Duration::from_secs(30),
transaction_batch: TransactionBatch::default(),
}
}
}
impl SubscriptionConfig {
pub(crate) fn validate(&self) -> Result<(), Error> {
ensure!(
self.concurrency > 0 && self.max_in_flight > 0,
Error::config,
"concurrency and max_in_flight must be positive"
);
self.handler_retry.validate()?;
self.receive_retry.validate()?;
self.publish_retry.validate()?;
self.dead_letter_retry.validate()?;
self.transaction_batch.validate()
}
}