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 = StreamReader::new(data.map_err(std::io::Error::other));
85        tokio::io::copy(&mut buf, &mut file)
86            .await
87            .map_err(|e| Error::CacheError(e.into()))
88            .map(|_| ())
89    }
90
91    async fn get_data(&self, digest: &ContentDigest) -> Result<Option<ContentStream>, Error> {
92        let path = self.root.join(digest.to_string());
93        let exists = tokio::fs::try_exists(&path)
94            .await
95            .map_err(|e| Error::CacheError(e.into()))?;
96        if !exists {
97            return Ok(None);
98        }
99        let file = tokio::fs::File::open(path)
100            .await
101            .map_err(|e| Error::CacheError(e.into()))?;
102
103        Ok(Some(
104            ReaderStream::new(file).map_err(Error::IoError).boxed(),
105        ))
106    }
107
108    async fn put_release(&self, package: &PackageRef, release: &Release) -> Result<(), Error> {
109        let path = self
110            .root
111            .join(format!("{}-{}.json", package, release.version));
112        tokio::fs::write(
113            path,
114            serde_json::to_string(&ReleaseInfoBorrowed::from(release)).map_err(|e| {
115                Error::CacheError(anyhow::anyhow!("Error serializing data to disk: {e}"))
116            })?,
117        )
118        .await
119        .map(|_| ())
120        .map_err(|e| Error::CacheError(anyhow::anyhow!("Error writing to disk: {e}")))
121    }
122
123    async fn get_release(
124        &self,
125        package: &PackageRef,
126        version: &Version,
127    ) -> Result<Option<Release>, Error> {
128        let path = self.root.join(format!("{}-{}.json", package, version));
129        let exists = tokio::fs::try_exists(&path).await.map_err(|e| {
130            Error::CacheError(anyhow::anyhow!("Error checking if file exists: {e}"))
131        })?;
132        if !exists {
133            return Ok(None);
134        }
135        let data = tokio::fs::read(path)
136            .await
137            .map_err(|e| Error::CacheError(anyhow::anyhow!("Error reading from disk: {e}")))?;
138        let release: ReleaseInfoOwned = serde_json::from_slice(&data).map_err(|e| {
139            Error::CacheError(anyhow::anyhow!("Error deserializing data from disk: {e}"))
140        })?;
141        Ok(Some(release.into()))
142    }
143}
wasm_pkg_client/caching/file.rs

wasm_pkg_client/caching/
file.rs
