wasm_pkg_client/caching/
file.rs

1//! A `Cache` implementation for a filesystem
2
3use std::path::{Path, PathBuf};
4
5use anyhow::Context;
6use etcetera::BaseStrategy;
7use futures_util::{StreamExt, TryStreamExt};
8use tokio_util::io::{ReaderStream, StreamReader};
9use wasm_pkg_common::{
10    Error,
11    digest::ContentDigest,
12    package::{PackageRef, Version},
13};
14
15use crate::{ContentStream, Release};
16
17use super::Cache;
18
19#[derive(Clone)]
20pub struct FileCache {
21    root: PathBuf,
22}
23
24impl std::fmt::Display for FileCache {
25    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
26        write!(f, "{}", self.root.display())
27    }
28}
29
30impl FileCache {
31    /// Creates a new file cache that stores data in the given directory.
32    pub async fn new(root: impl AsRef<Path>) -> anyhow::Result<Self> {
33        tokio::fs::create_dir_all(&root)
34            .await
35            .context("Unable to create cache directory")?;
36        Ok(Self {
37            root: root.as_ref().to_path_buf(),
38        })
39    }
40
41    /// Returns a cache setup to use the global default cache path if it can be determined,
42    /// otherwise this will error
43    pub async fn global_cache() -> anyhow::Result<Self> {
44        Self::new(Self::global_cache_path().context("couldn't find global cache path")?).await
45    }
46
47    /// Returns the global default cache path if it can be determined, otherwise returns None
48    pub fn global_cache_path() -> Option<PathBuf> {
49        etcetera::choose_base_strategy()
50            .ok()
51            .map(|strat| strat.cache_dir().join("wasm-pkg"))
52    }
53}
54
55#[derive(serde::Serialize)]
56struct ReleaseInfoBorrowed<'a> {
57    version: &'a Version,
58    content_digest: &'a ContentDigest,
59}
60
61impl<'a> From<&'a Release> for ReleaseInfoBorrowed<'a> {
62    fn from(release: &'a Release) -> Self {
63        Self {
64            version: &release.version,
65            content_digest: &release.content_digest,
66        }
67    }
68}
69
70#[derive(serde::Deserialize)]
71struct ReleaseInfoOwned {
72    version: Version,
73    content_digest: ContentDigest,
74}
75
76impl From<ReleaseInfoOwned> for Release {
77    fn from(info: ReleaseInfoOwned) -> Self {
78        Self {
79            version: info.version,
80            content_digest: info.content_digest,
81        }
82    }
83}
84
85impl Cache for FileCache {
86    async fn put_data(&self, digest: ContentDigest, data: ContentStream) -> Result<(), Error> {
87        let path = self.root.join(digest.to_string());
88        let mut file = tokio::fs::File::create(&path).await.map_err(|e| {
89            Error::CacheError(anyhow::anyhow!("Unable to create file for cache {e}"))
90        })?;
91        let mut buf = StreamReader::new(data.map_err(std::io::Error::other));
92        tokio::io::copy(&mut buf, &mut file)
93            .await
94            .map_err(|e| Error::CacheError(e.into()))
95            .map(|_| ())
96    }
97
98    async fn get_data(&self, digest: &ContentDigest) -> Result<Option<ContentStream>, Error> {
99        let path = self.root.join(digest.to_string());
100        let exists = tokio::fs::try_exists(&path)
101            .await
102            .map_err(|e| Error::CacheError(e.into()))?;
103        if !exists {
104            return Ok(None);
105        }
106        let file = tokio::fs::File::open(path)
107            .await
108            .map_err(|e| Error::CacheError(e.into()))?;
109
110        Ok(Some(
111            ReaderStream::new(file).map_err(Error::IoError).boxed(),
112        ))
113    }
114
115    async fn put_release(&self, package: &PackageRef, release: &Release) -> Result<(), Error> {
116        let path = self
117            .root
118            .join(format!("{}-{}.json", package, release.version));
119        tokio::fs::write(
120            path,
121            serde_json::to_string(&ReleaseInfoBorrowed::from(release)).map_err(|e| {
122                Error::CacheError(anyhow::anyhow!("Error serializing data to disk: {e}"))
123            })?,
124        )
125        .await
126        .map(|_| ())
127        .map_err(|e| Error::CacheError(anyhow::anyhow!("Error writing to disk: {e}")))
128    }
129
130    async fn get_release(
131        &self,
132        package: &PackageRef,
133        version: &Version,
134    ) -> Result<Option<Release>, Error> {
135        let path = self.root.join(format!("{}-{}.json", package, version));
136        let exists = tokio::fs::try_exists(&path).await.map_err(|e| {
137            Error::CacheError(anyhow::anyhow!("Error checking if file exists: {e}"))
138        })?;
139        if !exists {
140            return Ok(None);
141        }
142        let data = tokio::fs::read(path)
143            .await
144            .map_err(|e| Error::CacheError(anyhow::anyhow!("Error reading from disk: {e}")))?;
145        let release: ReleaseInfoOwned = serde_json::from_slice(&data).map_err(|e| {
146            Error::CacheError(anyhow::anyhow!("Error deserializing data from disk: {e}"))
147        })?;
148        Ok(Some(release.into()))
149    }
150}
wasm_pkg_client/caching/file.rs

wasm_pkg_client/caching/
file.rs
