final cleanup

Author: Apostlex0

lightning-block-sync/src/http.rs

@@ -8,12 +8,11 @@ use bitreq::RequestExt;
 
 use std::convert::TryFrom;
 use std::fmt;
-use std::time::Duration;
 
-/// Timeout for requests. This is set to a high value as it is not uncommon for Bitcoin Core to be
-/// blocked waiting on UTXO cache flushes for upwards of 10 minutes on slow devices (e.g. RPis with
-/// SSDs over USB).
-const TCP_STREAM_RESPONSE_TIMEOUT: Duration = Duration::from_secs(300);
+/// Timeout for requests in seconds. This is set to a high value as it is not uncommon for Bitcoin
+/// Core to be blocked waiting on UTXO cache flushes for upwards of 10 minutes on slow devices
+/// (e.g. RPis with SSDs over USB).
+const TCP_STREAM_RESPONSE_TIMEOUT: u64 = 300;
 
 /// Maximum HTTP message body size in bytes. Enough for a hex-encoded block in JSON format and any
 /// overhead for HTTP chunked transfer encoding.
@@ -68,79 +67,25 @@ impl From<HttpError> for HttpClientError {
 	}
 }
 
-/// Endpoint for interacting with an HTTP-based API.
-#[derive(Debug)]
-pub struct HttpEndpoint {
-	host: String,
-	port: Option<u16>,
-	path: String,
-}
-
-impl HttpEndpoint {
-	/// Creates an endpoint for the given host and default HTTP port.
-	pub fn for_host(host: String) -> Self {
-		Self { host, port: None, path: String::from("/") }
-	}
-
-	/// Specifies a port to use with the endpoint.
-	pub fn with_port(mut self, port: u16) -> Self {
-		self.port = Some(port);
-		self
-	}
-
-	/// Specifies a path to use with the endpoint.
-	pub fn with_path(mut self, path: String) -> Self {
-		self.path = path;
-		self
-	}
-
-	/// Returns the endpoint host.
-	pub fn host(&self) -> &str {
-		&self.host
-	}
-
-	/// Returns the endpoint port.
-	pub fn port(&self) -> u16 {
-		match self.port {
-			None => 80,
-			Some(port) => port,
-		}
-	}
-
-	/// Returns the endpoint path.
-	pub fn path(&self) -> &str {
-		&self.path
-	}
-}
-
-impl<'a> std::net::ToSocketAddrs for &'a HttpEndpoint {
-	type Iter = <(&'a str, u16) as std::net::ToSocketAddrs>::Iter;
-
-	fn to_socket_addrs(&self) -> std::io::Result<Self::Iter> {
-		(self.host(), self.port()).to_socket_addrs()
-	}
-}
-
 /// Maximum number of cached connections in the connection pool.
 #[cfg(feature = "tokio")]
 const MAX_CONNECTIONS: usize = 10;
 
 /// Client for making HTTP requests.
 pub(crate) struct HttpClient {
-	host: String,
-	port: u16,
+	base_url: String,
 	#[cfg(feature = "tokio")]
 	client: bitreq::Client,
 }
 
 impl HttpClient {
-	/// Creates a new HTTP client for the given endpoint.
+	/// Creates a new HTTP client for the given base URL.
 	///
+	/// The base URL should include the scheme, host, and port (e.g., "http://127.0.0.1:8332").
 	/// DNS resolution is deferred until the first request is made.
-	pub fn new(endpoint: &HttpEndpoint) -> Self {
+	pub fn new(base_url: &str) -> Self {
 		Self {
-			host: endpoint.host().to_string(),
-			port: endpoint.port(),
+			base_url: base_url.to_string(),
 			#[cfg(feature = "tokio")]
 			client: bitreq::Client::new(MAX_CONNECTIONS),
 		}
@@ -154,9 +99,9 @@ impl HttpClient {
 	where
 		F: TryFrom<Vec<u8>, Error = std::io::Error>,
 	{
-		let url = format!("http://{}:{}{}", self.host, self.port, uri);
+		let url = format!("{}{}", self.base_url, uri);
 		let request = bitreq::get(url)
-			.with_timeout(TCP_STREAM_RESPONSE_TIMEOUT.as_secs())
+			.with_timeout(TCP_STREAM_RESPONSE_TIMEOUT)
 			.with_max_body_size(Some(MAX_HTTP_MESSAGE_BODY_SIZE));
 		let response_body = self.send_request(request).await?;
 		F::try_from(response_body).map_err(HttpClientError::Io)
@@ -174,11 +119,11 @@ impl HttpClient {
 	where
 		F: TryFrom<Vec<u8>, Error = std::io::Error>,
 	{
-		let url = format!("http://{}:{}{}", self.host, self.port, uri);
+		let url = format!("{}{}", self.base_url, uri);
 		let request = bitreq::post(url)
 			.with_header("Authorization", auth)
 			.with_header("Content-Type", "application/json")
-			.with_timeout(TCP_STREAM_RESPONSE_TIMEOUT.as_secs())
+			.with_timeout(TCP_STREAM_RESPONSE_TIMEOUT)
 			.with_max_body_size(Some(MAX_HTTP_MESSAGE_BODY_SIZE))
 			.with_body(content.to_string());
 		let response_body = self.send_request(request).await?;
@@ -249,6 +194,7 @@ impl TryFrom<Vec<u8>> for JsonResponse {
 pub(crate) mod client_tests {
 	use super::*;
 	use std::io::{BufRead, Read, Write};
+	use std::time::Duration;
 
 	/// Server for handling HTTP client requests with a stock response.
 	pub struct HttpServer {
@@ -392,15 +338,14 @@ pub(crate) mod client_tests {
 			Self { address, handler: Some(handler), shutdown }
 		}
 
-		pub fn endpoint(&self) -> HttpEndpoint {
-			HttpEndpoint::for_host(self.address.ip().to_string()).with_port(self.address.port())
+		pub fn endpoint(&self) -> String {
+			format!("http://{}:{}", self.address.ip(), self.address.port())
 		}
 	}
 
 	#[tokio::test]
 	async fn connect_with_invalid_host() {
-		let endpoint = HttpEndpoint::for_host("invalid.host.example".to_string()).with_port(80);
-		let client = HttpClient::new(&endpoint);
+		let client = HttpClient::new("http://invalid.host.example:80");
 		match client.get::<JsonResponse>("/foo").await {
 			Err(HttpClientError::Transport(_)) => {},
 			Err(e) => panic!("Unexpected error type: {:?}", e),

lightning-block-sync/src/rest.rs

@@ -3,7 +3,7 @@
 
 use crate::convert::GetUtxosResponse;
 use crate::gossip::UtxoSource;
-use crate::http::{BinaryResponse, HttpClient, HttpClientError, HttpEndpoint, JsonResponse};
+use crate::http::{BinaryResponse, HttpClient, HttpClientError, JsonResponse};
 use crate::{BlockData, BlockHeaderData, BlockSource, BlockSourceResult};
 
 use bitcoin::hash_types::BlockHash;
@@ -12,37 +12,27 @@ use bitcoin::OutPoint;
 use std::convert::TryFrom;
 use std::convert::TryInto;
 use std::future::Future;
-use std::sync::Mutex;
 
 /// A simple REST client for requesting resources using HTTP `GET`.
 pub struct RestClient {
-	endpoint: HttpEndpoint,
-	client: Mutex<Option<HttpClient>>,
+	client: HttpClient,
 }
 
 impl RestClient {
 	/// Creates a new REST client connected to the given endpoint.
 	///
-	/// The endpoint should contain the REST path component (e.g., http://127.0.0.1:8332/rest).
-	pub fn new(endpoint: HttpEndpoint) -> Self {
-		Self { endpoint, client: Mutex::new(None) }
+	/// The base URL should include the REST path component (e.g., "http://127.0.0.1:8332/rest").
+	pub fn new(base_url: String) -> Self {
+		Self { client: HttpClient::new(&base_url) }
 	}
 
 	/// Requests a resource encoded in `F` format and interpreted as type `T`.
 	pub async fn request_resource<F, T>(&self, resource_path: &str) -> Result<T, HttpClientError>
 	where
 		F: TryFrom<Vec<u8>, Error = std::io::Error> + TryInto<T, Error = std::io::Error>,
 	{
-		let uri = format!("{}/{}", self.endpoint.path().trim_end_matches("/"), resource_path);
-		let reserved_client = self.client.lock().unwrap().take();
-		let client = if let Some(client) = reserved_client {
-			client
-		} else {
-			HttpClient::new(&self.endpoint)
-		};
-		let res = client.get::<F>(&uri).await?.try_into().map_err(HttpClientError::Io);
-		*self.client.lock().unwrap() = Some(client);
-		res
+		let uri = format!("/{}", resource_path);
+		self.client.get::<F>(&uri).await?.try_into().map_err(HttpClientError::Io)
 	}
 }
 

lightning-block-sync/src/rpc.rs

@@ -2,14 +2,12 @@
 //! endpoint.
 
 use crate::gossip::UtxoSource;
-use crate::http::{HttpClient, HttpClientError, HttpEndpoint, JsonResponse};
+use crate::http::{HttpClient, HttpClientError, JsonResponse};
 use crate::{BlockData, BlockHeaderData, BlockSource, BlockSourceResult};
 
 use bitcoin::hash_types::BlockHash;
 use bitcoin::OutPoint;
 
-use std::sync::Mutex;
-
 use serde_json;
 
 use std::convert::TryFrom;
@@ -85,20 +83,20 @@ impl From<RpcError> for RpcClientError {
 /// [`RpcClient::call_method`] for details.
 pub struct RpcClient {
 	basic_auth: String,
-	endpoint: HttpEndpoint,
-	client: Mutex<Option<HttpClient>>,
+	client: HttpClient,
 	id: AtomicUsize,
 }
 
 impl RpcClient {
 	/// Creates a new RPC client connected to the given endpoint with the provided credentials. The
 	/// credentials should be a base64 encoding of a user name and password joined by a colon, as is
 	/// required for HTTP basic access authentication.
-	pub fn new(credentials: &str, endpoint: HttpEndpoint) -> Self {
+	///
+	/// The base URL should include the scheme, host, and port (e.g., "http://127.0.0.1:8332").
+	pub fn new(credentials: &str, base_url: String) -> Self {
 		Self {
 			basic_auth: "Basic ".to_string() + credentials,
-			endpoint,
-			client: Mutex::new(None),
+			client: HttpClient::new(&base_url),
 			id: AtomicUsize::new(0),
 		}
 	}
@@ -110,21 +108,13 @@ impl RpcClient {
 	where
 		JsonResponse: TryFrom<Vec<u8>, Error = std::io::Error> + TryInto<T, Error = std::io::Error>,
 	{
-		let uri = self.endpoint.path();
 		let content = serde_json::json!({
 			"method": method,
 			"params": params,
 			"id": &self.id.fetch_add(1, Ordering::AcqRel).to_string()
 		});
 
-		let reserved_client = self.client.lock().unwrap().take();
-		let client = if let Some(client) = reserved_client {
-			client
-		} else {
-			HttpClient::new(&self.endpoint)
-		};
-		let http_response = client.post::<JsonResponse>(&uri, &self.basic_auth, content).await;
-		*self.client.lock().unwrap() = Some(client);
+		let http_response = self.client.post::<JsonResponse>("/", &self.basic_auth, content).await;
 
 		let mut response = match http_response {
 			Ok(JsonResponse(response)) => response,