wtx 0.51.1

A collection of different transport implementations and related tools focused primarily on web technologies.
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use crate::{
  http::{
    HttpRecvParams,
    http2_client_pool::{Http2ClientPool, Http2RM},
    push_h2_alpn,
  },
  net::TcpParams,
  pool::{ResourceManager, SimplePool},
  rng::ChaCha20,
  sync::{AsyncMutex, AtomicCell},
  tls::TlsConfig,
};

/// Allows the customization of parameters that control HTTP requests and responses.
#[derive(Debug)]
pub struct Http2ClientPoolBuilder<AUX, EX, TM> {
  aux_fn: fn() -> AUX,
  disable_auto_sni: bool,
  executor: EX,
  hrp: HttpRecvParams,
  len: usize,
  rng: ChaCha20,
  tcp_params: TcpParams,
  tls_config: TlsConfig<TM>,
}

impl<EX, TM> Http2ClientPoolBuilder<(), EX, TM> {
  /// Creates a new builder with the maximum number of connections delimited by `len`.
  ///
  /// The "h2" ALPN will always be pushed into the TLS configuration.
  #[inline]
  pub fn new(
    executor: EX,
    len: usize,
    rng: ChaCha20,
    mut tls_config: TlsConfig<TM>,
  ) -> crate::Result<Self> {
    push_h2_alpn(&mut tls_config)?;
    Ok(Self {
      aux_fn: || {},
      disable_auto_sni: false,
      executor,
      hrp: HttpRecvParams::with_optioned_params(),
      len,
      rng,
      tcp_params: TcpParams::default(),
      tls_config,
    })
  }
}

#[cfg(feature = "tokio")]
impl<TM> Http2ClientPoolBuilder<(), crate::executor::TokioExecutor, TM> {
  /// Calls [`Self::new`] using the elements provided by the tokio project
  #[inline]
  pub fn tokio(len: usize, tls_config: TlsConfig<TM>) -> crate::Result<Self> {
    use crate::rng::CryptoSeedableRng as _;
    Self::new(
      crate::executor::TokioExecutor::default(),
      len,
      ChaCha20::from_std_random()?,
      tls_config,
    )
  }
}

impl<AUX, EX, TM> Http2ClientPoolBuilder<AUX, EX, TM> {
  /// If `true`, then the SNI TLS extension won't be added with the hostname of the URL.
  #[inline]
  pub const fn disable_auto_sni_mut(&mut self) -> &mut bool {
    &mut self.disable_auto_sni
  }

  /// See [`HttpRecvParams`].
  #[inline]
  pub const fn http_conn_params_mut(&mut self) -> &mut HttpRecvParams {
    &mut self.hrp
  }

  /// See [`ChaCha20`].
  #[inline]
  pub const fn rng_mut(&mut self) -> &mut ChaCha20 {
    &mut self.rng
  }

  /// Function that returns auxiliary data.
  #[inline]
  pub fn set_aux_fn<_AUX>(self, value: fn() -> _AUX) -> Http2ClientPoolBuilder<_AUX, EX, TM> {
    Http2ClientPoolBuilder {
      aux_fn: value,
      disable_auto_sni: self.disable_auto_sni,
      executor: self.executor,
      hrp: self.hrp,
      len: self.len,
      rng: self.rng,
      tcp_params: self.tcp_params,
      tls_config: self.tls_config,
    }
  }

  /// See [`TcpParams`].
  #[inline]
  pub const fn tcp_params_mut(&mut self) -> &mut TcpParams {
    &mut self.tcp_params
  }
}

impl<AUX, EX, TM> Http2ClientPoolBuilder<AUX, EX, TM>
where
  Http2RM<AUX, EX, TM>: ResourceManager,
{
  /// Creates a new client with inner parameters.
  #[inline]
  pub fn build(self) -> Http2ClientPool<AUX, EX, TM> {
    Http2ClientPool {
      pool: SimplePool::new(
        self.len,
        Http2RM {
          aux_fn: self.aux_fn,
          disable_auto_sni: self.disable_auto_sni,
          executor: self.executor,
          hrp: self.hrp,
          rng: AtomicCell::new(self.rng),
          tcp_params: self.tcp_params,
          tls_config: AsyncMutex::new(self.tls_config),
        },
      ),
    }
  }
}