voltlane 0.1.0

Voltlane TCP multiplexer, turning N TCP streams intoa a single "firehose" stream.
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

use std::future::Future;
use crate::net;

use net::TaggedPacket;
use tokio::net::{
    tcp::{OwnedReadHalf, OwnedWriteHalf},
    TcpStream,
};

pub trait MasterDuplex: Send + Sync {
    /// Send a tagged packet to the master.
    fn send_packet(&mut self, packet: TaggedPacket) -> impl Future<Output = anyhow::Result<()>> + Send;
    /// Receive a tagged packet from the master.
    fn recv_packet(&mut self) -> impl Future<Output = anyhow::Result<TaggedPacket>> + Send;
}

pub struct TcpMasterDuplex {
    write: OwnedWriteHalf,
    read: net::FramedReader<OwnedReadHalf>,
}

impl TcpMasterDuplex {
    pub async fn connect(address: &str) -> anyhow::Result<Self> {
        let mut stream = TcpStream::connect(address).await?;
        net::configure_performance_tcp_socket(&mut stream)?;
        let (read, write) = stream.into_split();
        Ok(Self {
            write: write,
            read: net::new_framed_reader(read),
        })
    }
}

impl MasterDuplex for TcpMasterDuplex {
    async fn send_packet(&mut self, packet: TaggedPacket) -> anyhow::Result<()> {
        net::send_tagged_packet(&mut self.write, packet).await
    }

    async fn recv_packet(&mut self) -> anyhow::Result<TaggedPacket> {
        net::recv_tagged_packet(&mut self.read).await
    }
}