Struct FloodProtection 

pub struct FloodProtection {
    pub config: FloodConfig,
    pub global_tokens: f64,
    pub global_last_refill: u64,
    pub peers: HashMap<String, PeerState>,
    pub seen_messages: VecDeque<(MessageId, u64)>,
    pub violations: VecDeque<ViolationRecord>,
    pub total_allowed: u64,
    pub total_blocked: u64,
}

Multi-layer flood/DoS protection for P2P networks.

See the module-level documentation for a detailed description of each protection layer and usage examples.

Fields

config: FloodConfig

Immutable configuration.

global_tokens: f64

Global token-bucket state.

global_last_refill: u64

Timestamp of last global token refill.

peers: HashMap<String, PeerState>

Per-peer token-bucket and ban state.

seen_messages: VecDeque<(MessageId, u64)>

Sliding-window deduplication cache: (message_id, insertion_timestamp_ms).

violations: VecDeque<ViolationRecord>

Ring buffer of recent violations (capped at 1 000).

total_allowed: u64

Monotonically increasing count of allowed messages.

total_blocked: u64

Monotonically increasing count of blocked messages.

Implementations

impl FloodProtection

pub fn new(config: FloodConfig) -> Self

Create a new FloodProtection instance with the given configuration.

pub fn check( &mut self, peer_id: &str, message_id: MessageId, now: u64, ) -> CheckResult

Run all protection checks in priority order.

The checks are applied in this order:

1. Peer ban check.
2. Global rate limit.
3. Per-peer rate limit.
4. Message deduplication.

This method is read-only: it does not consume tokens or register the message. Call record_allowed after receiving CheckResult::Allow to commit the state change.

Violations triggered here are recorded automatically.

pub fn record_allowed(&mut self, peer_id: &str, message_id: MessageId, now: u64)

Consume one token from the global and per-peer buckets and record the message in the deduplication cache.

This must be called after check returns CheckResult::Allow and before the next call to check for the same peer, otherwise the token counts will be stale.

pub fn record_violation( &mut self, peer_id: &str, vtype: ViolationType, msg_id: Option<MessageId>, now: u64, )

Record a violation for peer_id and ban them if they hit the threshold.

The violations ring-buffer is capped at 1 000 entries; oldest entries are silently dropped when the buffer is full.

pub fn is_banned(&mut self, peer_id: &str, now: u64) -> bool

Return true if peer_id is currently banned.

If a ban has expired at now the peer’s banned_until field is cleared automatically (lazy unban).

pub fn unban(&mut self, peer_id: &str)

Unconditionally lift the ban on peer_id.

pub fn evict_expired_dedup(&mut self, now: u64) -> usize

Remove deduplication entries older than FloodConfig::dedup_window_ms.

Returns the number of entries removed.

pub fn evict_stale_peers(&mut self, max_age_ms: u64, now: u64) -> usize

Remove unbanned peers whose last_refill is older than max_age_ms.

Banned peers are never evicted regardless of age. Returns the number of peer entries removed.

pub fn violation_summary(&self, since: u64) -> HashMap<String, usize>

Summarise violations recorded since since (ms timestamp).

Returns a map from violation-type name to occurrence count.

pub fn stats(&self, now: u64) -> FloodStats

Return a point-in-time statistics snapshot.