Split client into a cached and uncached client

Cached client uses the uncached client internally too.

Author: foresterre

crates/rust-releases-io/src/client.rs

@@ -3,6 +3,13 @@ use crate::document::RetrievedDocument;
 #[cfg(feature = "http_client")]
 pub mod cached_client;
 
+#[cfg(feature = "http_client")]
+#[allow(clippy::module_inception)]
+pub mod client;
+
+#[cfg(feature = "http_client")]
+pub mod errors;
+
 /// Fetch a document, given a `resource` description.
 pub trait RustReleasesClient {
     /// The type of error returned by the client implementation.

crates/rust-releases-io/src/client/cached_client.rs

@@ -1,6 +1,8 @@
+use crate::client::client::Client;
+use crate::client::errors::{HttpError, IoError};
 use crate::{
-    is_stale, Document, IsStaleError, ResourceFile, RetrievalLocation, RetrievedDocument,
-    RustReleasesClient,
+    is_stale, ClientError, Document, IsStaleError, ResourceFile, RetrievalLocation,
+    RetrievedDocument, RustReleasesClient,
 };
 use std::fs;
 use std::io::{self, BufReader, BufWriter, Read, Write};
@@ -9,61 +11,7 @@ use std::time::Duration;
 
 const DEFAULT_MEMORY_SIZE: usize = 4096;
 
-/// A list of errors which may be produced by [`CachedClient::fetch`].
-#[derive(Debug, thiserror::Error)]
-#[non_exhaustive]
-pub enum CachedClientError {
-    /// Returned if the fetched file was empty.
-    #[error("Received empty file")]
-    EmptyFile,
-
-    /// Returned if the HTTP client could not fetch an item
-    #[error(transparent)]
-    Http(#[from] HttpError),
-
-    /// Returned in case of an `std::io::Error`.
-    #[error(transparent)]
-    Io(#[from] IoError),
-
-    /// Returned in case it wasn't possible to check whether the cache file is
-    /// stale or not.
-    #[error(transparent)]
-    IsStale(#[from] IsStaleError),
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum IoError {
-    #[error("I/O error: {error}{}", format!(" at '{}'", .path.display()))]
-    Inaccessible { error: io::Error, path: PathBuf },
-
-    #[error("I/O error: path at '{path}' is a file, but expected a directory")]
-    IsFile { path: PathBuf },
-
-    #[error("I/O error: {error}")]
-    Auxiliary { error: io::Error },
-}
-
-impl IoError {
-    pub fn auxiliary(error: io::Error) -> Self {
-        Self::Auxiliary { error }
-    }
-
-    pub fn inaccessible(error: io::Error, path: PathBuf) -> Self {
-        Self::Inaccessible { error, path }
-    }
-
-    pub fn is_file(path: PathBuf) -> Self {
-        Self::IsFile { path }
-    }
-}
-
-/// An error which is returned for a fault which occurred during processing of an HTTP request.
-#[derive(Debug, thiserror::Error)]
-#[error("HTTP error: {error}")]
-pub struct HttpError {
-    // We box the error since it can be very large.
-    error: Box<ureq::Error>,
-}
+const DEFAULT_TIMEOUT: Duration = Duration::from_secs(150);
 
 /// The client to download and cache rust releases.
 ///
@@ -99,34 +47,34 @@ impl RustReleasesClient for CachedClient {
     type Error = CachedClientError;
 
     fn fetch(&self, resource: ResourceFile) -> Result<RetrievedDocument, Self::Error> {
-        let manifest_path = self.cache_folder.join(resource.name());
-        let exists = manifest_path.exists();
+        let path = self.cache_folder.join(resource.name());
+        let exists = path.exists();
 
         // Returned the cached document if it exists and is not stale
-        if exists && !is_stale(&manifest_path, self.cache_timeout)? {
-            let buffer = read_from_path(&manifest_path)?;
+        if exists && !is_stale(&path, self.cache_timeout)? {
+            let buffer = read_from_path(&path)?;
             let document = Document::new(buffer);
 
             return Ok(RetrievedDocument::new(
                 document,
-                RetrievalLocation::Cache(manifest_path),
+                RetrievalLocation::Cache(path),
             ));
         }
 
         // Ensure we have a place to put the cached document.
         if !exists {
-            setup_cache_folder(&manifest_path)?;
+            setup_cache_folder(&path)?;
         }
 
-        let mut reader = fetch_file(resource.url())?;
+        let client = Client::new(DEFAULT_TIMEOUT);
+        let mut retrieved = client.fetch(resource).map_err(CachedClientError::from)?;
+
+        let document = retrieved.mut_document();
 
         // write to memory
-        let document = write_document_and_cache(&mut reader, &manifest_path)?;
+        write_document_and_cache(document, &path)?;
 
-        Ok(RetrievedDocument::new(
-            document,
-            RetrievalLocation::RemoteUrl(resource.url.to_string()),
-        ))
+        Ok(retrieved)
     }
 }
 
@@ -169,44 +117,49 @@ fn setup_cache_folder(manifest_path: &Path) -> Result<(), CachedClientError> {
     Ok(())
 }
 
-fn fetch_file(url: &str) -> Result<Box<dyn Read + Send + Sync>, CachedClientError> {
-    let config = ureq::Agent::config_builder()
-        .user_agent("rust-releases (github.com/foresterre/rust-releases/issues)")
-        .proxy(ureq::Proxy::try_from_env())
-        .build();
-
-    let agent = config.new_agent();
-
-    let response = agent.get(url).call().map_err(|err| HttpError {
-        error: Box::new(err),
-    })?;
-
-    let reader = Box::new(response.into_body().into_reader());
-
-    Ok(reader)
-}
-
 fn write_document_and_cache(
-    reader: &mut Box<dyn Read + Send + Sync>,
+    document: &mut Document,
     file_path: &Path,
-) -> Result<Document, CachedClientError> {
-    let mut buffer = Vec::with_capacity(DEFAULT_MEMORY_SIZE);
-
-    let bytes_read = reader
-        .read_to_end(&mut buffer)
-        .map_err(|err| IoError::inaccessible(err, file_path.to_path_buf()))?;
-
-    if bytes_read == 0 {
-        return Err(CachedClientError::EmptyFile);
-    }
-
+) -> Result<(), CachedClientError> {
     let mut file = fs::File::create(file_path)
         .map_err(|err| IoError::inaccessible(err, file_path.to_path_buf()))?;
 
     let mut writer = BufWriter::new(&mut file);
     writer
-        .write_all(&buffer)
+        .write_all(document.buffer())
         .map_err(|err| IoError::inaccessible(err, file_path.to_path_buf()))?;
 
-    Ok(Document::new(buffer))
+    Ok(())
+}
+
+/// A list of errors which may be produced by [`CachedClient::fetch`].
+#[derive(Debug, thiserror::Error)]
+#[non_exhaustive]
+pub enum CachedClientError {
+    /// Returned if the fetched file was empty.
+    #[error("Received empty file")]
+    EmptyFile,
+
+    /// Returned if the HTTP client could not fetch an item
+    #[error(transparent)]
+    Http(#[from] HttpError),
+
+    /// Returned in case of an `std::io::Error`.
+    #[error(transparent)]
+    Io(#[from] IoError),
+
+    /// Returned in case it wasn't possible to check whether the cache file is
+    /// stale or not.
+    #[error(transparent)]
+    IsStale(#[from] IsStaleError),
+}
+
+impl From<ClientError> for CachedClientError {
+    fn from(err: ClientError) -> Self {
+        match err {
+            ClientError::Empty => CachedClientError::EmptyFile,
+            ClientError::Http(err) => CachedClientError::Http(err),
+            ClientError::Io(err) => CachedClientError::Io(err),
+        }
+    }
 }

crates/rust-releases-io/src/client/client.rs

@@ -0,0 +1,113 @@
+use crate::client::errors::{HttpError, IoError};
+use crate::{Document, ResourceFile, RetrievalLocation, RetrievedDocument, RustReleasesClient};
+use std::io::Read;
+use std::time::Duration;
+
+const DEFAULT_MEMORY_SIZE: usize = 4096;
+
+const DEFAULT_TIMEOUT: Duration = Duration::from_secs(150);
+
+/// The client to download and cache rust releases.
+///
+/// If a cached file is not present, or if a cached file is present, but the copy is outdated,
+/// the client will download a new copy of the given resource and store it to the `cache_folder`.
+/// If a cached file is present, and the copy is not outdated, the cached file will be returned
+/// instead.
+pub struct Client {
+    timeout: Duration,
+}
+
+impl Client {
+    /// Create a new [`Client`].
+    ///
+    /// ```
+    /// use std::time::Duration;
+    /// use rust_releases_io::Client;
+    /// let timeout = Duration::from_secs(86_400);
+    ///
+    /// let _client = Client::new(timeout);
+    /// ```
+    pub fn new(timeout: Duration) -> Self {
+        Self { timeout }
+    }
+}
+
+impl Default for Client {
+    /// Create a new [`Client`].
+    ///
+    /// ```
+    /// use rust_releases_io::Client;
+    ///
+    /// let _client = Client::default();
+    /// ```
+    fn default() -> Self {
+        Self {
+            timeout: DEFAULT_TIMEOUT,
+        }
+    }
+}
+
+impl RustReleasesClient for Client {
+    type Error = ClientError;
+
+    fn fetch(&self, resource: ResourceFile) -> Result<RetrievedDocument, Self::Error> {
+        let mut reader = fetch_file(resource.url(), self.timeout)?;
+
+        // write to memory
+        let document = write_document(&mut reader)?;
+
+        Ok(RetrievedDocument::new(
+            document,
+            RetrievalLocation::RemoteUrl(resource.url.to_string()),
+        ))
+    }
+}
+
+fn fetch_file(url: &str, timeout: Duration) -> Result<Box<dyn Read + Send + Sync>, ClientError> {
+    let config = ureq::Agent::config_builder()
+        .user_agent("rust-releases (github.com/foresterre/rust-releases/issues)")
+        .proxy(ureq::Proxy::try_from_env())
+        .timeout_global(Some(timeout))
+        .build();
+
+    let agent = config.new_agent();
+
+    let response = agent.get(url).call().map_err(|err| HttpError {
+        error: Box::new(err),
+    })?;
+
+    let reader = Box::new(response.into_body().into_reader());
+
+    Ok(reader)
+}
+
+fn write_document(reader: &mut Box<dyn Read + Send + Sync>) -> Result<Document, ClientError> {
+    let mut buffer = Vec::with_capacity(DEFAULT_MEMORY_SIZE);
+
+    let bytes_read = reader
+        .read_to_end(&mut buffer)
+        .map_err(IoError::auxiliary)?;
+
+    if bytes_read == 0 {
+        return Err(ClientError::Empty);
+    }
+
+    Ok(Document::new(buffer))
+}
+
+/// A list of errors which may be produced by [`Client::fetch`].
+#[derive(Debug, thiserror::Error)]
+#[non_exhaustive]
+pub enum ClientError {
+    /// Returned if an empty document was fetched.
+    #[error("Received empty file")]
+    Empty,
+
+    /// Returned if the HTTP client could not fetch an item
+    #[error(transparent)]
+    Http(#[from] HttpError),
+
+    /// Returned in case of an `std::io::Error`.
+    #[error(transparent)]
+    Io(#[from] IoError),
+}

crates/rust-releases-io/src/client/errors.rs

@@ -0,0 +1,36 @@
+use std::io;
+use std::path::PathBuf;
+
+#[derive(Debug, thiserror::Error)]
+pub enum IoError {
+    #[error("I/O error: {error}{}", format!(" at '{}'", .path.display()))]
+    InaccessiblePath { error: io::Error, path: PathBuf },
+
+    #[error("I/O error: path at '{path}' is a file, but expected a directory")]
+    DirectoryPathIsFile { path: PathBuf },
+
+    #[error("I/O error: {error}")]
+    Auxiliary { error: io::Error },
+}
+
+impl IoError {
+    pub fn auxiliary(error: io::Error) -> Self {
+        Self::Auxiliary { error }
+    }
+
+    pub fn inaccessible(error: io::Error, path: PathBuf) -> Self {
+        Self::InaccessiblePath { error, path }
+    }
+
+    pub fn is_file(path: PathBuf) -> Self {
+        Self::DirectoryPathIsFile { path }
+    }
+}
+
+/// An error which is returned for a fault which occurred during processing of an HTTP request.
+#[derive(Debug, thiserror::Error)]
+#[error("HTTP error: {error}")]
+pub struct HttpError {
+    // We box the error since it can be very large.
+    pub(crate) error: Box<ureq::Error>,
+}

crates/rust-releases-io/src/document.rs

@@ -25,6 +25,11 @@ impl RetrievedDocument {
     pub fn retrieval_location(&self) -> &RetrievalLocation {
         &self.retrieval_location
     }
+
+    /// Exclusive access to the document
+    pub fn mut_document(&mut self) -> &mut Document {
+        &mut self.document
+    }
 }
 
 /// A `Document` represents a resource which can be used as an input to construct a `ReleaseIndex`.

crates/rust-releases-io/src/lib.rs

@@ -16,7 +16,10 @@ pub use crate::{
 };
 
 #[cfg(feature = "http_client")]
-pub use crate::client::cached_client::{CachedClient, CachedClientError};
+pub use crate::client::{
+    cached_client::CachedClient, cached_client::CachedClientError, client::Client,
+    client::ClientError,
+};
 
 /// A macro used to feature gate tests which fetch resources from third party services.
 ///