Initial public release of Warp.

Repo-Sync-Origin: warpdotdev/warp-internal@12af1d983b

crates/asset_cache/src/lib.rs

@@ -0,0 +1,176 @@
+use std::hash::{DefaultHasher, Hash, Hasher};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use anyhow::Result;
+use async_fs::{OpenOptions, create_dir_all};
+use bytes::Bytes;
+use futures::AsyncWriteExt;
+use reqwest::Url;
+use warpui_core::assets::asset_cache::{
+    Asset, AssetCache, AssetSource, AssetState, AsyncAssetId, AsyncAssetType,
+};
+
+/// Namespace marker for URL-based async asset sources without persistence.
+pub struct UrlAssetWithoutPersistence;
+impl AsyncAssetType for UrlAssetWithoutPersistence {}
+
+/// Namespace marker for URL-based async asset sources with persistence.
+///
+/// This is intentionally separate from `UrlAssetWithoutPersistence` to allow
+/// ensure we persist the asset even if we fetched it once already without
+/// persistence.
+pub struct UrlAssetWithPersistence;
+impl AsyncAssetType for UrlAssetWithPersistence {}
+
+/// Creates an [`AssetSource::Async`] that fetches bytes from the given URL
+/// without persisting them to the local filesystem.
+pub fn url_source(url: impl Into<String>) -> AssetSource {
+    let url = url.into();
+    let url_for_fetch = url.clone();
+    AssetSource::Async {
+        id: AsyncAssetId::new::<UrlAssetWithoutPersistence>(url),
+        fetch: Arc::new(move || {
+            let url = url_for_fetch.clone();
+            Box::pin(async move {
+                let parsed = Url::parse(&url)?;
+                fetch_file_to_memory(parsed).await
+            })
+        }),
+    }
+}
+
+/// Creates an [`AssetSource::Async`] that fetches bytes from the given URL,
+/// persisting them to a file under `cache_dir` for future reads.
+pub fn url_source_with_persistence(url: impl Into<String>, cache_dir: &Path) -> AssetSource {
+    let url = url.into();
+    let url_for_fetch = url.clone();
+    let cache_dir_owned = cache_dir.to_path_buf();
+    AssetSource::Async {
+        id: AsyncAssetId::new::<UrlAssetWithPersistence>(url),
+        fetch: Arc::new(move || {
+            let url = url_for_fetch.clone();
+            let cache_dir = cache_dir_owned.clone();
+            Box::pin(async move {
+                let parsed = Url::parse(&url)?;
+                let file = get_file_path_for_asset(&parsed, &cache_dir);
+                fetch_asset_from_url(parsed, Some(file)).await
+            })
+        }),
+    }
+}
+
+/// Extension trait that adds URL-based asset loading to [`AssetCache`].
+pub trait AssetCacheExt {
+    /// Loads an asset from a URL, optionally persisting the fetched bytes to
+    /// a file under `cache_dir` for future cache hits.
+    fn load_asset_from_url<T: Asset>(&self, url: &str, cache_dir: Option<&Path>) -> AssetState<T>;
+}
+
+impl AssetCacheExt for AssetCache {
+    fn load_asset_from_url<T: Asset>(&self, url: &str, cache_dir: Option<&Path>) -> AssetState<T> {
+        let source = match cache_dir {
+            Some(dir) => url_source_with_persistence(url, dir),
+            None => url_source(url),
+        };
+        self.load_asset(source)
+    }
+}
+
+/// Fetches a file from the given `url` to memory.
+async fn fetch_file_to_memory(url: Url) -> Result<Bytes, anyhow::Error> {
+    cfg_if::cfg_if! {
+        if #[cfg(target_family = "wasm")] {
+            let response = reqwest::get(url).await?;
+        } else {
+            // On non-web platforms, reqwest expects that it is operating within
+            // a Tokio-compatible runtime, so use async-compat to wrap the call
+            // so reqwest's expectations are met.
+            let response = async_compat::Compat::new(async move { reqwest::get(url).await }).await?;
+        }
+    }
+    let content = response.bytes().await?;
+    Ok(content)
+}
+
+/// Given a url and a directory where cached artifacts are stored, returns a unique
+/// file path for an asset.
+fn get_file_path_for_asset(url: &Url, cache_dir: &Path) -> PathBuf {
+    // Hash the URL so that we can derive a "safe" file name for it. We need something
+    // unique and not too long (most filesystems have a maximum length limit for file
+    // names. On MacOS it's 255).
+    let mut hasher = DefaultHasher::new();
+    url.hash(&mut hasher);
+    let digest = hasher.finish();
+    // Stringify the bytes in hexadecimal. Be careful not to use base64-digests in file
+    // names b/c base64 uses a mix of upper and lowercase chars, which is problematic on
+    // case-insensitive filesystems such as MacOS
+    let filename = format!("{digest:x}");
+    cache_dir.join(filename)
+}
+
+async fn persist_bytes(bytes: &Bytes, file: &Path) {
+    let Some(parent_folder) = file.parent() else {
+        log::error!("attempted to write cache file in filesystem root");
+        return;
+    };
+
+    if let Err(e) = create_dir_all(parent_folder).await {
+        log::error!("Error creating directory for cache files: {e:#}");
+    }
+
+    let mut file = match OpenOptions::new()
+        .create(true)
+        .write(true)
+        .truncate(true)
+        .open(file)
+        .await
+    {
+        Ok(file) => file,
+        Err(e) => {
+            log::error!("Error opening file: {e:#}");
+            return;
+        }
+    };
+
+    if let Err(e) = file.write_all(bytes).await {
+        log::error!("Error writing to file: {e:#}");
+    }
+
+    if let Err(e) = file.flush().await {
+        log::error!("Error flushing file: {e:#}");
+    };
+}
+
+async fn fetch_file_and_persist_bytes(url: Url, file: Option<PathBuf>) -> Result<Bytes> {
+    let result = fetch_file_to_memory(url).await;
+
+    // If the bytes should be written to a file, do so now.
+    if let Ok(bytes) = result.as_ref()
+        && let Some(filename) = file
+    {
+        persist_bytes(bytes, &filename).await;
+    }
+
+    result
+}
+
+async fn fetch_asset_from_url(url: Url, file: Option<PathBuf>) -> Result<Bytes> {
+    match file {
+        // If a file path is specified and that file path currently exists in the
+        // user's filesystem, read the bytes out of the file.
+        Some(filename) if filename.exists() => {
+            log::debug!("Reading bytes from cached file: {filename:?}");
+            let buffer = async_fs::read(filename.clone()).await?;
+
+            // If buffer is empty, try to fetch from url instead
+            if buffer.is_empty() {
+                return fetch_file_and_persist_bytes(url, Some(filename)).await;
+            }
+
+            Ok(buffer.into())
+        }
+        // Otherwise, fetch the bytes from the url.
+        _ => fetch_file_and_persist_bytes(url, file).await,
+    }
+}