Replace reqwest with simple-request

reqwest was replaced with hyper and hyper-rustls within monero-serai due to reqwest *solely* offering a connection pool API. In the process, it was demonstrated how quickly we can achieve equivalent functionality to reqwest for our use cases with a fraction of the code. This adds our own reqwest alternative to the tree, applying it to both bitcoin-serai and message-queue. By doing so, bitcoin-serai decreases its tree by 21 packages and the processor by 18. Cargo.lock decreases by 8 dependencies, solely adding simple-request. Notably removed is openssl-sys and openssl. One noted decrease functionality is the requirement on the system having installed CA certificates. While we could fallback to the rustls certificates if the system doesn't have any, that's blocked by https://github.com/rustls/hyper-rustls/pulls/228.
2025-12-08 12:19:24 +00:00 · 2023-11-06 09:14:46 -05:00
parent cddb44ae3f
commit b9983bf133
11 changed files with 204 additions and 119 deletions
--- a/common/request/src/lib.rs
+++ b/common/request/src/lib.rs
@@ -0,0 +1,97 @@
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![doc = include_str!("../README.md")]
+
+use hyper_rustls::{HttpsConnectorBuilder, HttpsConnector};
+use hyper::{
+  StatusCode,
+  header::{HeaderValue, HeaderMap},
+  body::{Buf, Body},
+  Response as HyperResponse,
+  client::HttpConnector,
+};
+pub use hyper::{self, Request};
+
+#[derive(Debug)]
+pub struct Response(HyperResponse<Body>);
+impl Response {
+  pub fn status(&self) -> StatusCode {
+    self.0.status()
+  }
+  pub fn headers(&self) -> &HeaderMap<HeaderValue> {
+    self.0.headers()
+  }
+  pub async fn body(self) -> Result<impl std::io::Read, hyper::Error> {
+    Ok(hyper::body::aggregate(self.0.into_body()).await?.reader())
+  }
+}
+
+#[derive(Clone, Debug)]
+enum Connection {
+  ConnectionPool(hyper::Client<HttpsConnector<HttpConnector>>),
+}
+
+#[derive(Clone, Debug)]
+pub struct Client {
+  connection: Connection,
+}
+
+#[derive(Debug)]
+pub enum Error {
+  InvalidHost,
+  Hyper(hyper::Error),
+}
+
+impl Client {
+  fn https_builder() -> HttpsConnector<HttpConnector> {
+    HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()
+  }
+
+  pub fn with_connection_pool() -> Client {
+    Client {
+      connection: Connection::ConnectionPool(hyper::Client::builder().build(Self::https_builder())),
+    }
+  }
+
+  /*
+  fn without_connection_pool() -> Client {}
+  */
+
+  pub async fn request(&self, mut request: Request<Body>) -> Result<Response, Error> {
+    if request.headers().get(hyper::header::HOST).is_none() {
+      let host = request.uri().host().ok_or(Error::InvalidHost)?.to_string();
+      request
+        .headers_mut()
+        .insert(hyper::header::HOST, HeaderValue::from_str(&host).map_err(|_| Error::InvalidHost)?);
+    }
+
+    #[cfg(feature = "basic-auth")]
+    if request.headers().get(hyper::header::AUTHORIZATION).is_none() {
+      if let Some(authority) = request.uri().authority() {
+        let authority = authority.as_str();
+        if authority.contains('@') {
+          // Decode the username and password from the URI
+          let mut userpass = authority.split('@').next().unwrap().to_string();
+          // If the password is "", the URI may omit :, yet the authentication will still expect it
+          if !userpass.contains(':') {
+            userpass.push(':');
+          }
+
+          use zeroize::Zeroize;
+          use base64ct::{Encoding, Base64};
+
+          let mut encoded = Base64::encode_string(userpass.as_bytes());
+          userpass.zeroize();
+          request.headers_mut().insert(
+            hyper::header::AUTHORIZATION,
+            HeaderValue::from_str(&format!("Basic {encoded}")).unwrap(),
+          );
+          encoded.zeroize();
+        }
+      }
+    }
+
+    Ok(Response(match &self.connection {
+      Connection::ConnectionPool(client) => client.request(request).await.map_err(Error::Hyper)?,
+    }))
+  }
+}