stream-tungstenite 0.6.1

A streaming implementation of the Tungstenite WebSocket protocol
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
84
85
86
87
88

//! Transport layer abstraction for establishing underlying connections.

use async_trait::async_trait;
use std::time::Duration;
use tokio::io::{AsyncRead, AsyncWrite};

use crate::error::ConnectError;

/// Transport layer abstraction - responsible for establishing raw byte stream connections.
///
/// This trait allows for different transport implementations (TCP, TLS, Unix sockets, etc.)
/// and enables testing with mock transports.
#[async_trait]
pub trait Transport: Send + Sync + 'static {
    /// The underlying stream type produced by this transport
    type Stream: AsyncRead + AsyncWrite + Unpin + Send + 'static;

    /// Establish a connection to the given host and port
    async fn connect(&self, host: &str, port: u16) -> Result<Self::Stream, ConnectError>;

    /// Get the transport name (for logging/debugging)
    fn name(&self) -> &'static str;

    /// Get the default port for this transport
    fn default_port(&self) -> u16 {
        80
    }
}

/// Transport configuration options
#[derive(Debug, Clone)]
pub struct TransportConfig {
    /// Connection timeout
    pub connect_timeout: Duration,
    /// Whether to disable Nagle's algorithm (`TCP_NODELAY`)
    pub disable_nagle: bool,
    /// Keep-alive settings
    pub keep_alive: Option<Duration>,
}

impl Default for TransportConfig {
    fn default() -> Self {
        Self {
            connect_timeout: Duration::from_secs(30),
            disable_nagle: false,
            keep_alive: Some(Duration::from_secs(60)),
        }
    }
}

impl TransportConfig {
    /// Create a new transport config with default values
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Set connection timeout
    #[must_use]
    pub const fn with_connect_timeout(mut self, timeout: Duration) -> Self {
        self.connect_timeout = timeout;
        self
    }

    /// Enable or disable Nagle's algorithm
    #[must_use]
    pub const fn with_nagle(mut self, enable: bool) -> Self {
        self.disable_nagle = !enable;
        self
    }

    /// Set keep-alive duration (None to disable)
    #[must_use]
    pub const fn with_keep_alive(mut self, duration: Option<Duration>) -> Self {
        self.keep_alive = duration;
        self
    }

    /// Preset for low-latency connections
    #[must_use]
    pub const fn low_latency() -> Self {
        Self {
            connect_timeout: Duration::from_secs(10),
            disable_nagle: true,
            keep_alive: Some(Duration::from_secs(30)),
        }
    }
}