@feltdb/core 0.4.11 → 0.4.13

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

@@ -0,0 +1,366 @@
+/// TCP-based replication transport
+///
+/// Implements ProtocolTransport over real TCP sockets using message framing.
+///
+/// Wire Format: serde_json
+/// - Chosen for compatibility with Operation::command.fields (serde_json::Value)
+/// - bincode incompatible with untagged enums used by serde_json internally
+/// - JSON is self-describing and provides stable framing for protocol evolution
+/// - Length-prefix framing: 4-byte big-endian length + JSON payload
+///
+/// Transport Guarantees:
+/// - TCP connection establishment/closure
+/// - Message framing (length prefix + payload)
+/// - Ordered delivery within a single TCP connection (TCP's byte-stream ordering)
+/// - Serialization integrity (JSON encoder/decoder with bincode-compatible semantics)
+/// - Connection state tracking (connect, disconnect, is_connected)
+/// - Bounded buffers (prevent unbounded growth)
+///
+/// Deduplication/idempotency/retry logic is the protocol's responsibility via DistributedTransactionExecutor.
+
+use crate::distributed_transactions::ReplicationMessage;
+use crate::replication_protocol::{ProtocolError, ProtocolMetrics, ProtocolTransport};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::{TcpListener, TcpStream};
+use tokio::sync::Mutex;
+
+const MESSAGE_BUFFER_SIZE: usize = 100;
+
+/// TCP-based transport for ReplicationMessage
+#[derive(Clone)]
+pub struct TcpTransport {
+    local_addr: String,
+    peer_addr: Arc<Mutex<Option<String>>>,
+    stream: Arc<Mutex<Option<TcpStream>>>,
+    metrics: Arc<ProtocolMetrics>,
+    is_connected: Arc<AtomicBool>,
+    receive_buffer: Arc<Mutex<Vec<ReplicationMessage>>>,
+}
+
+impl TcpTransport {
+    /// Create a new TCP transport that will listen on the given address
+    pub fn new(local_addr: String) -> Self {
+        Self {
+            local_addr,
+            peer_addr: Arc::new(Mutex::new(None)),
+            stream: Arc::new(Mutex::new(None)),
+            metrics: Arc::new(ProtocolMetrics::new()),
+            is_connected: Arc::new(AtomicBool::new(false)),
+            receive_buffer: Arc::new(Mutex::new(Vec::with_capacity(MESSAGE_BUFFER_SIZE))),
+        }
+    }
+
+    /// Listen for incoming TCP connections
+    pub async fn listen(&mut self) -> Result<(), ProtocolError> {
+        let listener = TcpListener::bind(&self.local_addr)
+            .await
+            .map_err(|e| ProtocolError::ConnectionError(e.to_string()))?;
+
+        let stream = listener
+            .accept()
+            .await
+            .map_err(|e| ProtocolError::ConnectionError(e.to_string()))?
+            .0;
+
+        *self.stream.lock().await = Some(stream);
+        self.is_connected.store(true, Ordering::Relaxed);
+        self.metrics.record_connection_state_change();
+
+        Ok(())
+    }
+
+    pub fn metrics(&self) -> &ProtocolMetrics {
+        &self.metrics
+    }
+}
+
+#[async_trait::async_trait]
+impl ProtocolTransport for TcpTransport {
+    async fn send(&self, message: ReplicationMessage) -> Result<(), ProtocolError> {
+        let mut stream_guard = self.stream.lock().await;
+        let stream = stream_guard
+            .as_mut()
+            .ok_or(ProtocolError::ConnectionError("not connected".to_string()))?;
+
+        // Serialize message using serde_json (bincode has issues with serde_json::Value)
+        let payload = serde_json::to_vec(&message)
+            .map_err(|e| ProtocolError::SerializationError(e.to_string()))?;
+
+        let payload_len = payload.len() as u32;
+
+        // Send length prefix (4 bytes, big-endian)
+        stream
+            .write_all(&payload_len.to_be_bytes())
+            .await
+            .map_err(|e| ProtocolError::TransportError(e.to_string()))?;
+
+        // Send payload
+        stream
+            .write_all(&payload)
+            .await
+            .map_err(|e| ProtocolError::TransportError(e.to_string()))?;
+
+        stream
+            .flush()
+            .await
+            .map_err(|e| ProtocolError::TransportError(e.to_string()))?;
+
+        self.metrics.record_send(4 + payload.len());
+
+        Ok(())
+    }
+
+    async fn receive(&self) -> Result<Vec<ReplicationMessage>, ProtocolError> {
+        let mut buffer = self.receive_buffer.lock().await;
+
+        // If we have buffered messages, return them
+        if !buffer.is_empty() {
+            let messages = std::mem::take(&mut *buffer);
+            return Ok(messages);
+        }
+
+        // Try to receive one message from the socket
+        let mut stream_guard = self.stream.lock().await;
+        let stream = stream_guard
+            .as_mut()
+            .ok_or(ProtocolError::ConnectionError("not connected".to_string()))?;
+
+        // Set non-blocking read
+        let mut len_bytes = [0u8; 4];
+        match stream.read_exact(&mut len_bytes).await {
+            Ok(0) => {
+                // Connection closed
+                return Err(ProtocolError::ConnectionError(
+                    "connection closed by peer".to_string(),
+                ));
+            }
+            Ok(_) => {
+                let payload_len = u32::from_be_bytes(len_bytes) as usize;
+
+                if payload_len > 1024 * 1024 {
+                    // Sanity check: don't allow messages larger than 1MB
+                    return Err(ProtocolError::TransportError(
+                        "message too large".to_string(),
+                    ));
+                }
+
+                let mut payload = vec![0u8; payload_len];
+                stream
+                    .read_exact(&mut payload)
+                    .await
+                    .map_err(|e| ProtocolError::TransportError(e.to_string()))?;
+
+                let message: ReplicationMessage = serde_json::from_slice(&payload)
+                    .map_err(|e| ProtocolError::SerializationError(e.to_string()))?;
+
+                self.metrics.record_receive(4 + payload_len);
+
+                Ok(vec![message])
+            }
+            Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
+                // No data available right now
+                Ok(Vec::new())
+            }
+            Err(e) => Err(ProtocolError::TransportError(e.to_string())),
+        }
+    }
+
+    async fn connect(&mut self, peer_addr: &str) -> Result<(), ProtocolError> {
+        let stream = TcpStream::connect(peer_addr)
+            .await
+            .map_err(|e| ProtocolError::ConnectionError(e.to_string()))?;
+
+        *self.stream.lock().await = Some(stream);
+        *self.peer_addr.lock().await = Some(peer_addr.to_string());
+        self.is_connected.store(true, Ordering::Relaxed);
+        self.metrics.record_connection_state_change();
+
+        Ok(())
+    }
+
+    async fn disconnect(&mut self) -> Result<(), ProtocolError> {
+        *self.stream.lock().await = None;
+        self.is_connected.store(false, Ordering::Relaxed);
+        self.metrics.record_connection_state_change();
+
+        Ok(())
+    }
+
+    fn is_connected(&self) -> bool {
+        self.is_connected.load(Ordering::Relaxed)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::task;
+
+    #[tokio::test]
+    async fn tcp_bidirectional_message_exchange() {
+        let server_addr = "127.0.0.1:19001";
+
+        let mut server = TcpTransport::new(server_addr.to_string());
+        let mut client = TcpTransport::new("127.0.0.1:19002".to_string());
+
+        // Spawn server listening task
+        let _server_handle = {
+            let mut srv = server.clone();
+            task::spawn(async move {
+                srv.listen().await.expect("listen");
+            })
+        };
+
+        // Give server time to start listening
+        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+
+        // Client connects
+        client
+            .connect(server_addr)
+            .await
+            .expect("client connect");
+
+        // Wait for server to process connection
+        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+
+        // Create a test message
+        let msg = ReplicationMessage::new(
+            crate::distributed_transactions::TransactionEnvelope::new(
+                "test_node".to_string(),
+                1,
+                "tx-1".to_string(),
+                vec![],
+                crate::transactions::ConsistencyContract::local(),
+            ),
+            "test_node".to_string(),
+            "peer_node".to_string(),
+            1,
+        );
+
+        // Client sends
+        client.send(msg.clone()).await.expect("send");
+
+        // Server receives (wait briefly for message to arrive)
+        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+        let received = server.receive().await.expect("receive");
+
+        println!("Server received {} messages", received.len());
+        assert_eq!(received.len(), 1);
+        assert_eq!(received[0].from_node, "test_node");
+        assert_eq!(received[0].to_node, "peer_node");
+
+        // Now try bidirectional: server sends back to client
+        let response = ReplicationMessage::new(
+            crate::distributed_transactions::TransactionEnvelope::new(
+                "server_node".to_string(),
+                1,
+                "tx-2".to_string(),
+                vec![],
+                crate::transactions::ConsistencyContract::local(),
+            ),
+            "server_node".to_string(),
+            "client_node".to_string(),
+            1,
+        );
+
+        server.send(response.clone()).await.expect("server send");
+
+        // Client receives (wait briefly for message to arrive)
+        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+        let client_received = client.receive().await.expect("client receive");
+
+        println!("Client received {} messages", client_received.len());
+        assert_eq!(client_received.len(), 1);
+        assert_eq!(client_received[0].from_node, "server_node");
+    }
+
+    #[tokio::test]
+    async fn tcp_connection_status_tracked() {
+        let mut transport = TcpTransport::new("127.0.0.1:19003".to_string());
+
+        assert!(!transport.is_connected());
+
+        transport
+            .connect("127.0.0.1:9999")
+            .await
+            .expect_err("should fail - nobody listening");
+
+        assert!(!transport.is_connected());
+        assert_eq!(transport.metrics().get_connection_state_changes(), 0);
+    }
+
+    #[test]
+    fn bincode_serialization_roundtrip() {
+        let msg = ReplicationMessage::new(
+            crate::distributed_transactions::TransactionEnvelope::new(
+                "test_node".to_string(),
+                1,
+                "tx-1".to_string(),
+                vec![],
+                crate::transactions::ConsistencyContract::local(),
+            ),
+            "test_node".to_string(),
+            "peer_node".to_string(),
+            1,
+        );
+
+        let serialized = serde_json::to_vec(&msg).expect("serialize");
+        let deserialized: ReplicationMessage = serde_json::from_slice(&serialized).expect("deserialize");
+
+        assert_eq!(msg.from_node, deserialized.from_node);
+        assert_eq!(msg.to_node, deserialized.to_node);
+        assert_eq!(msg.sequence_number, deserialized.sequence_number);
+    }
+
+    #[test]
+    fn bincode_serialization_with_operation() {
+        use crate::convergence::VectorClock;
+        use crate::transactions::{Operation, OperationCommand, OperationId, StateVersion};
+        use std::collections::HashMap;
+        use serde_json::json;
+
+        let mut fields = HashMap::new();
+        fields.insert("key1".to_string(), json!("value1"));
+
+        let mut parent_vc = VectorClock::new();
+        parent_vc.increment("node_a");
+        let parent_version = StateVersion::new(parent_vc, "hash_initial_a".to_string());
+
+        let op = Operation::new(
+            OperationId::new("node_a".to_string(), 1),
+            parent_version.clone(),
+            "set_operation".to_string(),
+            OperationCommand {
+                op_type: "set".to_string(),
+                collection: "items".to_string(),
+                record_id: "item1".to_string(),
+                fields,
+            },
+            "node_a".to_string(),
+        );
+
+        let msg = ReplicationMessage::new(
+            crate::distributed_transactions::TransactionEnvelope::new(
+                "node_a".to_string(),
+                1,
+                "tx-1".to_string(),
+                vec![op],
+                crate::transactions::ConsistencyContract::local(),
+            ),
+            "node_a".to_string(),
+            "node_b".to_string(),
+            1,
+        );
+
+        let serialized = serde_json::to_vec(&msg).expect("serialize");
+        println!("Serialized {} bytes", serialized.len());
+
+        let deserialized: ReplicationMessage = serde_json::from_slice(&serialized).expect("deserialize");
+
+        assert_eq!(msg.from_node, deserialized.from_node);
+        assert_eq!(msg.to_node, deserialized.to_node);
+        assert_eq!(deserialized.envelope.operations.len(), 1);
+    }
+}