vt-muxer 0.1.0

Mux one TCP stream into many
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

# VT-Muxer

the Vrtgs Tcp Muxer

```toml
[dependencies]
vt-muxer = "0.1.0"
```

### Basic Example
```rust
use vt_muxer::{MuxListener, MuxPipe, MuxConnection};
use tokio::net::TcpStream;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

// Server side
async fn run_server(tcp_stream: TcpStream) {
    let mux = MuxListener::new(tcp_stream);
    
    // Accept new multiplexed connections
    while let Ok(mut connection) = mux.accept().await {
        tokio::spawn(async move {
            let mut buf = vec![0; 1024];
            while let Ok(n) = connection.read(&mut buf).await {
                if n == 0 { break; }
                // Handle data...
            }
        });
    }
}

// Client side
async fn run_client(tcp_stream: TcpStream) {
    let mux = MuxPipe::new(tcp_stream);
    
    // Create a new multiplexed connection
    let addr = "127.0.0.1:12345".parse().unwrap();
    let mut connection = mux.add_connection(addr).await.unwrap();
    
    // Use the connection
    connection.write_all(b"Hello world!").await.unwrap();
}
```
## Core Types

### MuxListener

The server-side multiplexer that accepts new logical connections:

- `new(stream: TcpStream) -> MuxListener` - Create a new multiplexer from a TCP stream
- `accept() -> Future<Result<MuxConnection>>` - Accept a new multiplexed connection
- `add_connection(addr: SocketAddr) -> Future<Result<MuxConnection>>` - Explicitly add a new connection

### MuxPipe

The client-side interface for creating new multiplexed connections:

- `new(stream: TcpStream) -> MuxPipe` - Create a new multiplexer from a TCP stream
- `add_connection(addr: SocketAddr) -> Future<Result<MuxConnection>>` - Create a new multiplexed connection

### MuxConnection

Represents a single _**Buffered**_ multiplexed connection:

- Implements `AsyncRead` and `AsyncWrite` for standard async I/O operations
- `addr() -> SocketAddr` - Get the address associated with this connection


MuxConnection should always be shutdown, otherwise a task will be spawned to shutdown the connection

## Address Types

The library provides optimized address types that merge Ipv4 and Ipv6 addresses into one using [Ipv6 mapped/compatible addresses](https://www.rfc-editor.org/rfc/rfc4291.html#section-2.5.5.1) for network operations:

- `SocketAddr` - A compact socket address representation
- `IpAddr` - A lightweight IP address type

## Performance

- Zero-copy packet handling using `bytemuck`
- Efficient multiplexing with minimal overhead
- Optimized for high-throughput scenarios
- Spawning of tasks/threads only occurs when a MuxConnection is dropped without being shutdown