mithril_cardano_node_internal_database/digesters/cache/
json_provider_builder.rs

1use anyhow::Context;
2use slog::{Logger, info};
3use std::path::Path;
4use tokio::fs;
5
6use mithril_common::StdResult;
7use mithril_common::logging::LoggerExtensions;
8
9use crate::digesters::cache::{
10    ImmutableFileDigestCacheProvider, JsonImmutableFileDigestCacheProvider,
11};
12
13/// A [JsonImmutableFileDigestCacheProvider] builder.
14pub struct JsonImmutableFileDigestCacheProviderBuilder<'a> {
15    cache_dir: &'a Path,
16    filename: &'a str,
17    ensure_dir_exist: bool,
18    reset_digests_cache: bool,
19    logger: Logger,
20}
21
22impl<'a> JsonImmutableFileDigestCacheProviderBuilder<'a> {
23    /// [JsonImmutableFileDigestCacheProviderBuilder] factory.
24    pub fn new(cache_dir: &'a Path, filename: &'a str) -> Self {
25        Self {
26            cache_dir,
27            filename,
28            ensure_dir_exist: false,
29            reset_digests_cache: false,
30            logger: Logger::root(slog::Discard, slog::o!()),
31        }
32    }
33
34    /// If set will create the cache directory if it doesn't already exist.
35    pub fn ensure_dir_exist(&mut self) -> &mut Self {
36        self.ensure_dir_exist = true;
37        self
38    }
39
40    /// Set if existing cached values in the provider must be reset.
41    pub fn should_reset_digests_cache(&mut self, should_reset: bool) -> &mut Self {
42        self.reset_digests_cache = should_reset;
43        self
44    }
45
46    /// Set the [Logger] to use.
47    pub fn with_logger(&mut self, logger: Logger) -> &mut Self {
48        self.logger = logger.new_with_component_name::<Self>();
49        self
50    }
51
52    /// Build a [JsonImmutableFileDigestCacheProvider] based on the parameters previously set.
53    pub async fn build(&self) -> StdResult<JsonImmutableFileDigestCacheProvider> {
54        let cache_file = self.cache_dir.join(self.filename);
55        let cache_provider = JsonImmutableFileDigestCacheProvider::new(&cache_file);
56
57        if self.ensure_dir_exist {
58            fs::create_dir_all(&self.cache_dir).await.with_context(|| {
59                format!(
60                    "Failure when creating cache directory `{}`",
61                    self.cache_dir.display(),
62                )
63            })?;
64        }
65
66        if self.reset_digests_cache {
67            cache_provider.reset().await.with_context(|| {
68                format!(
69                    "Failure when resetting digests cache file `{}`",
70                    cache_file.display(),
71                )
72            })?;
73        }
74
75        info!(
76            self.logger,
77            "Storing/Getting immutables digests cache from: {}",
78            cache_file.display()
79        );
80
81        Ok(cache_provider)
82    }
83}
84
85#[cfg(test)]
86mod tests {
87    use std::path::PathBuf;
88
89    use mithril_common::test_utils::TempDir;
90
91    use crate::digesters::cache::JsonImmutableFileDigestCacheProviderBuilder;
92
93    fn get_test_dir(subdir_name: &str) -> PathBuf {
94        TempDir::new("json_provider_builder", subdir_name).build_path()
95    }
96
97    #[tokio::test]
98    async fn create_dir_if_ensure_dir_exist_is_set() {
99        let dir = get_test_dir("create_dir_if_ensure_dir_exist_is_set");
100
101        JsonImmutableFileDigestCacheProviderBuilder::new(&dir, "test.json")
102            .ensure_dir_exist()
103            .build()
104            .await
105            .expect("Build should not fail");
106
107        assert!(dir.exists());
108    }
109
110    #[tokio::test]
111    async fn dont_create_dir_if_ensure_dir_exist_is_not_set() {
112        let dir = get_test_dir("dont_create_dir_if_ensure_dir_exist_is_not_set");
113
114        JsonImmutableFileDigestCacheProviderBuilder::new(&dir, "test.json")
115            .build()
116            .await
117            .expect("Build should not fail");
118
119        assert!(!dir.exists());
120    }
121}