use core::any::Any;
use std::sync::Arc;
use jiff::SignedDuration;
use smol_bytes::Utf8Bytes;
use crate::BoxedError;
use super::PollUpstream;
mod gate;
pub use gate::{Deadlines, Handover, Retries, Sheds, Ticks};
#[cfg(test)]
mod tests;
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
PartialOrd,
Ord,
Hash,
derive_more::Display,
derive_more::IsVariant,
)]
#[display("{}", self.as_str())]
#[non_exhaustive]
pub enum Concern {
Tick,
Retry,
Overflow,
Deadline,
}
impl Concern {
#[inline]
#[must_use]
pub const fn as_str(&self) -> &'static str {
match self {
Self::Tick => "tick",
Self::Retry => "retry",
Self::Overflow => "overflow",
Self::Deadline => "deadline",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Missed {
upstream: PollUpstream,
missed: u32,
}
impl Missed {
#[inline]
#[must_use]
pub const fn new(upstream: PollUpstream, missed: u32) -> Self {
Self { upstream, missed }
}
#[inline]
#[must_use]
pub const fn upstream(&self) -> PollUpstream {
self.upstream
}
#[inline]
#[must_use]
pub const fn missed(&self) -> u32 {
self.missed
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, derive_more::IsVariant)]
pub enum TickDecision {
Coalesce,
CatchUp,
}
pub trait TickPolicy: Send + Sync {
fn on_missed(&self, missed: Missed) -> Result<TickDecision, BoxedError>;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct Coalesce;
impl TickPolicy for Coalesce {
#[inline]
fn on_missed(&self, _missed: Missed) -> Result<TickDecision, BoxedError> {
Ok(TickDecision::Coalesce)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct CatchUp;
impl TickPolicy for CatchUp {
#[inline]
fn on_missed(&self, _missed: Missed) -> Result<TickDecision, BoxedError> {
Ok(TickDecision::CatchUp)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, derive_more::IsVariant)]
pub enum RetryDecision {
Retry {
after: Option<SignedDuration>,
},
GiveUp,
}
pub trait RetryPolicy: Send + Sync {
fn on_failure(
&self,
attempt: u32,
error: &(dyn core::error::Error + 'static),
) -> Result<RetryDecision, BoxedError>;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct NoRetry;
impl RetryPolicy for NoRetry {
#[inline]
fn on_failure(
&self,
_attempt: u32,
_error: &(dyn core::error::Error + 'static),
) -> Result<RetryDecision, BoxedError> {
Ok(RetryDecision::GiveUp)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Occupancy {
queued: usize,
capacity: Option<usize>,
}
impl Occupancy {
#[inline]
#[must_use]
pub const fn bounded(queued: usize, capacity: usize) -> Self {
Self {
queued,
capacity: Some(capacity),
}
}
#[inline]
#[must_use]
pub const fn unbounded(queued: usize) -> Self {
Self {
queued,
capacity: None,
}
}
#[inline]
#[must_use]
pub const fn queued(&self) -> usize {
self.queued
}
#[inline]
#[must_use]
pub const fn capacity(&self) -> Option<usize> {
self.capacity
}
#[inline]
#[must_use]
pub const fn is_full(&self) -> bool {
match self.capacity {
Some(capacity) => self.queued >= capacity,
None => false,
}
}
}
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
PartialOrd,
Ord,
Hash,
derive_more::Display,
derive_more::IsVariant,
)]
#[display("{}", self.as_str())]
pub enum OverflowDecision {
Block,
DropOldest,
DropNewest,
}
impl OverflowDecision {
#[inline]
#[must_use]
pub const fn as_str(&self) -> &'static str {
match self {
Self::Block => "block",
Self::DropOldest => "drop_oldest",
Self::DropNewest => "drop_newest",
}
}
#[inline]
#[must_use]
pub const fn is_shed(&self) -> bool {
matches!(self, Self::DropOldest | Self::DropNewest)
}
}
pub trait OverflowPolicy: Send + Sync {
fn on_full(&self, occupancy: Occupancy) -> Result<OverflowDecision, BoxedError>;
#[inline]
fn sheds(&self) -> bool {
true
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct Backpressure;
impl OverflowPolicy for Backpressure {
#[inline]
fn on_full(&self, _occupancy: Occupancy) -> Result<OverflowDecision, BoxedError> {
Ok(OverflowDecision::Block)
}
#[inline]
fn sheds(&self) -> bool {
false
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct DropOldest;
impl OverflowPolicy for DropOldest {
#[inline]
fn on_full(&self, _occupancy: Occupancy) -> Result<OverflowDecision, BoxedError> {
Ok(OverflowDecision::DropOldest)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct DropNewest;
impl OverflowPolicy for DropNewest {
#[inline]
fn on_full(&self, _occupancy: Occupancy) -> Result<OverflowDecision, BoxedError> {
Ok(OverflowDecision::DropNewest)
}
}
pub trait DeadlinePolicy: Send + Sync {
fn deadline(&self) -> Result<Option<SignedDuration>, BoxedError>;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct NoDeadline;
impl DeadlinePolicy for NoDeadline {
#[inline]
fn deadline(&self) -> Result<Option<SignedDuration>, BoxedError> {
Ok(None)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct QueryDeadline(SignedDuration);
impl QueryDeadline {
#[inline]
#[must_use]
pub const fn of(budget: SignedDuration) -> Self {
Self(budget)
}
#[inline]
#[must_use]
pub const fn budget(&self) -> SignedDuration {
self.0
}
}
impl DeadlinePolicy for QueryDeadline {
#[inline]
fn deadline(&self) -> Result<Option<SignedDuration>, BoxedError> {
Ok(Some(self.0))
}
}
#[derive(Clone)]
pub struct ShedKey {
named: Arc<Named>,
}
struct Named {
key: Box<dyn Any + Send + Sync>,
rendered: Utf8Bytes,
}
impl ShedKey {
#[inline]
#[must_use]
pub fn new<K>(key: K) -> Self
where
K: Any + core::fmt::Display + Send + Sync,
{
let rendered = Utf8Bytes::from(key.to_string());
Self {
named: Arc::new(Named {
key: Box::new(key),
rendered,
}),
}
}
#[inline]
#[must_use]
pub fn key<K: Any>(&self) -> Option<&K> {
self.named.key.downcast_ref()
}
#[inline]
#[must_use]
pub fn rendered(&self) -> &str {
self.named.rendered.as_str()
}
}
impl core::fmt::Debug for ShedKey {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_tuple("ShedKey").field(&self.rendered()).finish()
}
}
impl core::fmt::Display for ShedKey {
#[inline]
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str(self.rendered())
}
}
#[derive(Clone)]
pub struct Policies {
tick: Arc<dyn TickPolicy>,
retry: Arc<dyn RetryPolicy>,
overflow: Arc<dyn OverflowPolicy>,
deadline: Arc<dyn DeadlinePolicy>,
}
impl Policies {
#[inline]
#[must_use]
pub fn new() -> Self {
Self {
tick: Arc::new(Coalesce),
retry: Arc::new(NoRetry),
overflow: Arc::new(Backpressure),
deadline: Arc::new(NoDeadline),
}
}
#[inline]
#[must_use]
pub fn with_tick_policy(mut self, policy: Box<dyn TickPolicy>) -> Self {
self.tick = Arc::from(policy);
self
}
#[inline]
#[must_use]
pub fn with_retry_policy(mut self, policy: Box<dyn RetryPolicy>) -> Self {
self.retry = Arc::from(policy);
self
}
#[inline]
#[must_use]
pub fn with_overflow_policy(mut self, policy: Box<dyn OverflowPolicy>) -> Self {
self.overflow = Arc::from(policy);
self
}
#[inline]
#[must_use]
pub fn with_deadline_policy(mut self, policy: Box<dyn DeadlinePolicy>) -> Self {
self.deadline = Arc::from(policy);
self
}
#[inline]
#[must_use]
pub fn tick_policy(&self) -> &dyn TickPolicy {
&*self.tick
}
#[inline]
#[must_use]
pub fn retry_policy(&self) -> &dyn RetryPolicy {
&*self.retry
}
#[inline]
#[must_use]
pub fn overflow_policy(&self) -> &dyn OverflowPolicy {
&*self.overflow
}
#[inline]
#[must_use]
pub fn deadline_policy(&self) -> &dyn DeadlinePolicy {
&*self.deadline
}
#[inline]
#[must_use]
pub fn ticks(&self, node: impl Into<Utf8Bytes>, taps: super::Taps) -> Ticks {
Ticks::new(Arc::clone(&self.tick), node.into(), taps)
}
#[inline]
#[must_use]
pub fn retries(&self, node: impl Into<Utf8Bytes>, taps: super::Taps) -> Retries {
Retries::new(Arc::clone(&self.retry), node.into(), taps)
}
#[inline]
#[must_use]
pub fn sheds(&self, node: impl Into<Utf8Bytes>, taps: super::Taps) -> Sheds {
Sheds::new(Arc::clone(&self.overflow), node.into(), taps)
}
#[inline]
#[must_use]
pub fn deadlines(&self, node: impl Into<Utf8Bytes>, taps: super::Taps) -> Deadlines {
Deadlines::new(Arc::clone(&self.deadline), node.into(), taps)
}
}
impl Default for Policies {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl core::fmt::Debug for Policies {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("Policies")
.field("overflow_sheds", &self.overflow.sheds())
.finish_non_exhaustive()
}
}