@feltdb/core 0.15.0 → 0.16.0

package/dist/create/server-source/crates/feltdb/src/adversarial_transport.rs

@@ -1,539 +0,0 @@
-/// Adversarial Transport Layer (Gate 8)
-///
-/// Network fault injection that proves FeltDB converges despite:
-///   delivery delays, reordering, duplication, drops,
-///   partitions, asymmetric connectivity, and arbitrary restarts
-///
-/// Critical constraint: Transport has NO knowledge of FeltDB's replication logic.
-/// Transport only controls what happens to a message:
-///   send → maybe delay → maybe duplicate → maybe drop → eventually deliver
-///
-/// FeltDB must converge itself. Simulator cannot help.
-use std::collections::{HashMap, VecDeque};
-
-/// Reproducible fault seed
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
-pub struct FaultSeed(pub u64);
-
-/// Unique message identifier (for tracking through faults)
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
-pub struct MessageId(pub u64);
-
-/// Node identifier
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
-pub struct NodeId(pub u64);
-
-/// Connection between two nodes
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
-pub struct ConnectionId {
-    pub from: NodeId,
-    pub to: NodeId,
-}
-
-/// State of a network link
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum LinkState {
-    /// Connected, messages delivered
-    Connected,
-    /// Partitioned, all messages dropped
-    Partitioned,
-}
-
-/// Explicit network event (deterministic from seed)
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum NetworkEvent {
-    /// Delay a message by N ticks
-    Delay { message_id: MessageId, ticks: u64 },
-    /// Drop a message permanently
-    Drop { message_id: MessageId },
-    /// Duplicate a message
-    Duplicate { message_id: MessageId },
-    /// Partition a directional link
-    Partition { from: NodeId, to: NodeId },
-    /// Heal a directional link
-    Heal { from: NodeId, to: NodeId },
-    /// Reorder messages on a connection
-    Reorder { connection: ConnectionId },
-}
-
-/// Deterministic network schedule (fully reproducible from seed)
-#[derive(Clone, Debug)]
-pub struct NetworkSchedule {
-    pub seed: FaultSeed,
-    pub events: Vec<NetworkEvent>,
-}
-
-impl NetworkSchedule {
-    pub fn new(seed: FaultSeed) -> Self {
-        Self {
-            seed,
-            events: Vec::new(),
-        }
-    }
-
-    pub fn add_event(&mut self, event: NetworkEvent) {
-        self.events.push(event);
-    }
-
-    pub fn get_seed(&self) -> FaultSeed {
-        self.seed
-    }
-}
-
-/// In-flight message
-#[derive(Clone, Debug)]
-struct InFlightMessage {
-    id: MessageId,
-    from: NodeId,
-    to: NodeId,
-    payload: Vec<u8>,
-    delivery_tick: u64,
-}
-
-/// Connectivity matrix for asymmetric partitions
-#[derive(Clone, Debug)]
-pub struct ConnectivityMatrix {
-    links: HashMap<ConnectionId, LinkState>,
-}
-
-impl ConnectivityMatrix {
-    pub fn new() -> Self {
-        Self {
-            links: HashMap::new(),
-        }
-    }
-
-    pub fn can_reach(&self, from: NodeId, to: NodeId) -> bool {
-        let conn = ConnectionId { from, to };
-        matches!(self.links.get(&conn), Some(LinkState::Connected) | None)
-    }
-
-    pub fn partition(&mut self, from: NodeId, to: NodeId) {
-        self.links
-            .insert(ConnectionId { from, to }, LinkState::Partitioned);
-    }
-
-    pub fn heal(&mut self, from: NodeId, to: NodeId) {
-        self.links
-            .insert(ConnectionId { from, to }, LinkState::Connected);
-    }
-
-    pub fn get_state(&self, from: NodeId, to: NodeId) -> LinkState {
-        let conn = ConnectionId { from, to };
-        *self.links.get(&conn).unwrap_or(&LinkState::Connected)
-    }
-}
-
-impl Default for ConnectivityMatrix {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// Trait: Replication transport (decoupled from FeltDB logic)
-pub trait ReplicationTransport: Send + Sync {
-    /// Send a message from one node to another
-    fn send(&mut self, from: NodeId, to: NodeId, message: Vec<u8>) -> MessageId;
-
-    /// Advance simulation by one tick
-    fn tick(&mut self);
-
-    /// Receive all messages waiting for a node
-    fn receive(&mut self, node: NodeId) -> Vec<(NodeId, Vec<u8>)>;
-
-    /// Apply a fault event
-    fn apply_fault(&mut self, event: NetworkEvent);
-
-    /// Get current tick
-    fn current_tick(&self) -> u64;
-
-    /// Get connectivity status
-    fn get_connectivity(&self, from: NodeId, to: NodeId) -> LinkState;
-}
-
-/// In-memory transport with no faults (baseline)
-pub struct InMemoryTransport {
-    current_tick: u64,
-    message_counter: u64,
-    queues: HashMap<NodeId, VecDeque<(NodeId, Vec<u8>)>>,
-}
-
-impl InMemoryTransport {
-    pub fn new() -> Self {
-        Self {
-            current_tick: 0,
-            message_counter: 0,
-            queues: HashMap::new(),
-        }
-    }
-}
-
-impl Default for InMemoryTransport {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl ReplicationTransport for InMemoryTransport {
-    fn send(&mut self, from: NodeId, to: NodeId, message: Vec<u8>) -> MessageId {
-        let id = MessageId(self.message_counter);
-        self.message_counter += 1;
-
-        self.queues
-            .entry(to)
-            .or_insert_with(VecDeque::new)
-            .push_back((from, message));
-
-        id
-    }
-
-    fn tick(&mut self) {
-        self.current_tick += 1;
-    }
-
-    fn receive(&mut self, node: NodeId) -> Vec<(NodeId, Vec<u8>)> {
-        self.queues
-            .remove(&node)
-            .map(|q| q.into_iter().collect())
-            .unwrap_or_default()
-    }
-
-    fn apply_fault(&mut self, _event: NetworkEvent) {
-        // No-op for in-memory transport
-    }
-
-    fn current_tick(&self) -> u64 {
-        self.current_tick
-    }
-
-    fn get_connectivity(&self, _from: NodeId, _to: NodeId) -> LinkState {
-        LinkState::Connected
-    }
-}
-
-/// Adversarial transport with full fault injection
-pub struct AdversarialTransport {
-    current_tick: u64,
-    message_counter: u64,
-    in_flight: Vec<InFlightMessage>,
-    delivered_queues: HashMap<NodeId, VecDeque<(NodeId, Vec<u8>)>>,
-    connectivity: ConnectivityMatrix,
-    dropped_messages: std::collections::HashSet<MessageId>,
-}
-
-impl AdversarialTransport {
-    pub fn new() -> Self {
-        Self {
-            current_tick: 0,
-            message_counter: 0,
-            in_flight: Vec::new(),
-            delivered_queues: HashMap::new(),
-            connectivity: ConnectivityMatrix::new(),
-            dropped_messages: std::collections::HashSet::new(),
-        }
-    }
-
-    pub fn get_in_flight_count(&self) -> usize {
-        self.in_flight.len()
-    }
-
-    pub fn get_delivered_count(&self, node: NodeId) -> usize {
-        self.delivered_queues
-            .get(&node)
-            .map(|q| q.len())
-            .unwrap_or(0)
-    }
-}
-
-impl Default for AdversarialTransport {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl ReplicationTransport for AdversarialTransport {
-    fn send(&mut self, from: NodeId, to: NodeId, message: Vec<u8>) -> MessageId {
-        let id = MessageId(self.message_counter);
-        self.message_counter += 1;
-
-        // Check if link is partitioned
-        if !self.connectivity.can_reach(from, to) {
-            // Message is dropped by partition
-            self.dropped_messages.insert(id);
-            return id;
-        }
-
-        // Message enters in-flight, scheduled for immediate delivery
-        self.in_flight.push(InFlightMessage {
-            id,
-            from,
-            to,
-            payload: message,
-            delivery_tick: self.current_tick,
-        });
-
-        id
-    }
-
-    fn tick(&mut self) {
-        self.current_tick += 1;
-
-        // Deliver messages that are ready
-        let mut to_deliver = Vec::new();
-        let mut remaining = Vec::new();
-
-        for msg in self.in_flight.drain(..) {
-            if msg.delivery_tick <= self.current_tick {
-                to_deliver.push(msg);
-            } else {
-                remaining.push(msg);
-            }
-        }
-
-        self.in_flight = remaining;
-
-        // Queue delivered messages
-        for msg in to_deliver {
-            if !self.dropped_messages.contains(&msg.id) {
-                self.delivered_queues
-                    .entry(msg.to)
-                    .or_insert_with(VecDeque::new)
-                    .push_back((msg.from, msg.payload));
-            }
-        }
-    }
-
-    fn receive(&mut self, node: NodeId) -> Vec<(NodeId, Vec<u8>)> {
-        self.delivered_queues
-            .remove(&node)
-            .map(|q| q.into_iter().collect())
-            .unwrap_or_default()
-    }
-
-    fn apply_fault(&mut self, event: NetworkEvent) {
-        match event {
-            NetworkEvent::Delay { message_id, ticks } => {
-                // Find message and delay delivery
-                for msg in &mut self.in_flight {
-                    if msg.id == message_id {
-                        msg.delivery_tick += ticks;
-                        break;
-                    }
-                }
-            }
-            NetworkEvent::Drop { message_id } => {
-                self.dropped_messages.insert(message_id);
-            }
-            NetworkEvent::Duplicate { message_id } => {
-                // Clone the in-flight message
-                if let Some(orig) = self.in_flight.iter().find(|m| m.id == message_id) {
-                    let dup = InFlightMessage {
-                        id: MessageId(self.message_counter),
-                        from: orig.from,
-                        to: orig.to,
-                        payload: orig.payload.clone(),
-                        delivery_tick: orig.delivery_tick,
-                    };
-                    self.message_counter += 1;
-                    self.in_flight.push(dup);
-                }
-            }
-            NetworkEvent::Partition { from, to } => {
-                self.connectivity.partition(from, to);
-            }
-            NetworkEvent::Heal { from, to } => {
-                self.connectivity.heal(from, to);
-            }
-            NetworkEvent::Reorder { connection } => {
-                // Reorder messages on this connection
-                let mut msgs_on_conn: Vec<_> = self
-                    .in_flight
-                    .iter()
-                    .enumerate()
-                    .filter(|(_, m)| m.from == connection.from && m.to == connection.to)
-                    .collect();
-
-                if msgs_on_conn.len() > 1 {
-                    // Reverse order of messages on this connection
-                    msgs_on_conn.reverse();
-                    let indices: Vec<_> = msgs_on_conn.iter().map(|(i, _)| *i).collect();
-
-                    for (new_pos, &old_pos) in indices.iter().enumerate() {
-                        if new_pos != old_pos {
-                            self.in_flight.swap(new_pos, old_pos);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    fn current_tick(&self) -> u64 {
-        self.current_tick
-    }
-
-    fn get_connectivity(&self, from: NodeId, to: NodeId) -> LinkState {
-        self.connectivity.get_state(from, to)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_in_memory_transport_basic() {
-        let mut transport = InMemoryTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-
-        transport.send(n1, n2, vec![1, 2, 3]);
-        let messages = transport.receive(n2);
-
-        assert_eq!(messages.len(), 1);
-        assert_eq!(messages[0].0, n1);
-        assert_eq!(messages[0].1, vec![1, 2, 3]);
-    }
-
-    #[test]
-    fn test_adversarial_transport_basic() {
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-
-        let msg_id = transport.send(n1, n2, vec![1, 2, 3]);
-        assert!(msg_id.0 >= 0);
-
-        transport.tick();
-        let messages = transport.receive(n2);
-
-        assert_eq!(messages.len(), 1);
-        assert_eq!(messages[0].0, n1);
-    }
-
-    #[test]
-    fn test_partition() {
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-
-        // Partition n1 → n2
-        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n2 });
-
-        // Message should be dropped
-        let _msg_id = transport.send(n1, n2, vec![1, 2, 3]);
-        transport.tick();
-
-        let messages = transport.receive(n2);
-        assert_eq!(messages.len(), 0);
-    }
-
-    #[test]
-    fn test_delay() {
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-
-        let msg_id = transport.send(n1, n2, vec![1, 2, 3]);
-
-        // Delay the message by 5 ticks
-        transport.apply_fault(NetworkEvent::Delay {
-            message_id: msg_id,
-            ticks: 5,
-        });
-
-        // Tick 1-4: no messages
-        for _ in 0..4 {
-            transport.tick();
-            let messages = transport.receive(n2);
-            assert_eq!(messages.len(), 0);
-        }
-
-        // Tick 5: message delivered
-        transport.tick();
-        let messages = transport.receive(n2);
-        assert_eq!(messages.len(), 1);
-    }
-
-    #[test]
-    fn test_duplicate() {
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-
-        let msg_id = transport.send(n1, n2, vec![1, 2, 3]);
-
-        // Duplicate the message
-        transport.apply_fault(NetworkEvent::Duplicate { message_id: msg_id });
-
-        transport.tick();
-        let messages = transport.receive(n2);
-
-        assert_eq!(messages.len(), 2);
-        assert_eq!(messages[0].1, vec![1, 2, 3]);
-        assert_eq!(messages[1].1, vec![1, 2, 3]);
-    }
-
-    #[test]
-    fn test_drop() {
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-
-        let msg_id = transport.send(n1, n2, vec![1, 2, 3]);
-
-        transport.apply_fault(NetworkEvent::Drop { message_id: msg_id });
-
-        transport.tick();
-        let messages = transport.receive(n2);
-
-        assert_eq!(messages.len(), 0);
-    }
-
-    #[test]
-    fn test_asymmetric_partition() {
-        let mut transport = AdversarialTransport::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-
-        // Partition n1 → n2 only (asymmetric)
-        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n2 });
-
-        // n1 → n2 blocked
-        let _msg_id = transport.send(n1, n2, vec![1, 2, 3]);
-        transport.tick();
-        assert_eq!(transport.receive(n2).len(), 0);
-
-        // n2 → n1 allowed
-        let msg_id = transport.send(n2, n1, vec![4, 5, 6]);
-        assert!(msg_id.0 >= 0);
-        transport.tick();
-        assert_eq!(transport.receive(n1).len(), 1);
-    }
-
-    #[test]
-    fn test_connectivity_matrix() {
-        let mut connectivity = ConnectivityMatrix::new();
-
-        let n1 = NodeId(1);
-        let n2 = NodeId(2);
-
-        // Initially connected
-        assert!(connectivity.can_reach(n1, n2));
-
-        // Partition
-        connectivity.partition(n1, n2);
-        assert!(!connectivity.can_reach(n1, n2));
-
-        // Heal
-        connectivity.heal(n1, n2);
-        assert!(connectivity.can_reach(n1, n2));
-    }
-}