anchal 0.1.1

A protocol-agnostic transport layer for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use crate::error::TransportError;
use crate::protocols::tcp::connection::TcpTransportStream;
use crate::transport::{Transport, TransportClient, TransportStream};
use async_trait::async_trait;
use std::net::SocketAddr;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;

pub struct TcpClient {
    connection: Option<TcpTransportStream>,
}

impl TcpClient {
    // Initialize a new TcpClient with no active connection
    pub fn new() -> Self {
        Self { connection: None }
    }
}

#[async_trait]
impl Transport for TcpClient {
    async fn connect(&mut self, addr: SocketAddr) -> Result<(), TransportError> {
        // Attempt to connect to the specified address
        let stream = TcpStream::connect(addr).await.map_err(|e| {
            TransportError::ConnectionError(format!("Failed to connect to {}: {}", addr, e))
        })?;

        // Wrap the TcpStream in a TcpTransportStream and store it in `connection`
        self.connection = Some(TcpTransportStream::new(stream));
        println!("Connected to {}", addr);

        Ok(())
    }

    async fn disconnect(&mut self) -> Result<(), TransportError> {
        // Check if there is an active connection to disconnect
        if let Some(ref mut conn) = self.connection {
            // Shutdown the stream gracefully
            conn.stream.shutdown().await.map_err(|e| {
                TransportError::DisconnectError(format!("Failed to disconnect: {}", e))
            })?;
            println!("Disconnected from the server");
        } else {
            return Err(TransportError::DisconnectError(
                "No active connection".to_string(),
            ));
        }

        // Set the connection to None to mark it as disconnected
        self.connection = None;
        Ok(())
    }
}

#[async_trait]
impl TransportClient for TcpClient {
    fn stream(&mut self) -> &mut dyn TransportStream {
        // Return a mutable reference to the `TcpTransportStream` for data transmission
        self.connection
            .as_mut()
            .expect("Connection not established")
    }
}