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

wasm_pkg_client/caching/
file.rs
