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

wasm_pkg_client/caching/
file.rs
