Implement read-only local cache

docs/Configuration.md

@@ -100,6 +100,7 @@ configuration variables
 * `SCCACHE_DIR` local on disk artifact cache directory
 * `SCCACHE_CACHE_SIZE` maximum size of the local on disk cache i.e. `2G` - default is 10G
 * `SCCACHE_DIRECT` enable/disable preprocessor caching (see [the local doc](Local.md))
+* `SCCACHE_LOCAL_RW_MODE` the mode that the cache will operate in (`READ_ONLY` or `READ_WRITE`)
 
 #### s3 compatible
 

docs/Local.md

@@ -43,3 +43,7 @@ Configuration options and their default values:
 See where to write the config in [the configuration doc](Configuration.md).
 
 *Note that preprocessor caching is currently only implemented for GCC and Clang and when using local storage.*
+
+## Read-only cache mode
+
+By default, the local cache operates in read/write mode. The `SCCACHE_LOCAL_RW_MODE` environment variable can be set to `READ_ONLY` (or `READ_WRITE`) to modify this behavior.

src/cache/cache.rs

@@ -16,7 +16,7 @@
 use crate::cache::azure::AzureBlobCache;
 use crate::cache::disk::DiskCache;
 #[cfg(feature = "gcs")]
-use crate::cache::gcs::{GCSCache, RWMode};
+use crate::cache::gcs::GCSCache;
 #[cfg(feature = "gha")]
 use crate::cache::gha::GHACache;
 #[cfg(feature = "memcached")]
@@ -112,7 +112,7 @@ impl fmt::Debug for Cache {
     }
 }
 
-/// CacheMode is used to repreent which mode we are using.
+/// CacheMode is used to represent which mode we are using.
 #[derive(Debug)]
 pub enum CacheMode {
     /// Only read cache from storage.
@@ -121,6 +121,15 @@ pub enum CacheMode {
     ReadWrite,
 }
 
+impl From<config::CacheRWMode> for CacheMode {
+    fn from(value: config::CacheRWMode) -> Self {
+        match value {
+            config::CacheRWMode::ReadOnly => CacheMode::ReadOnly,
+            config::CacheRWMode::ReadWrite => CacheMode::ReadWrite,
+        }
+    }
+}
+
 /// Trait objects can't be bounded by more than one non-builtin trait.
 pub trait ReadSeek: Read + Seek + Send {}
 
@@ -575,17 +584,12 @@ pub fn storage_from_config(
             }) => {
                 debug!("Init gcs cache with bucket {bucket}, key_prefix {key_prefix}");
 
-                let gcs_read_write_mode = match rw_mode {
-                    config::GCSCacheRWMode::ReadOnly => RWMode::ReadOnly,
-                    config::GCSCacheRWMode::ReadWrite => RWMode::ReadWrite,
-                };
-
                 let storage = GCSCache::build(
                     bucket,
                     key_prefix,
                     cred_path.as_deref(),
                     service_account.as_deref(),
-                    gcs_read_write_mode,
+                    (*rw_mode).into(),
                     credential_url.as_deref(),
                 )
                 .map_err(|err| anyhow!("create gcs cache failed: {err:?}"))?;
@@ -660,12 +664,14 @@ pub fn storage_from_config(
 
     let (dir, size) = (&config.fallback_cache.dir, config.fallback_cache.size);
     let preprocessor_cache_mode_config = config.fallback_cache.preprocessor_cache_mode;
+    let rw_mode = config.fallback_cache.rw_mode;
     debug!("Init disk cache with dir {:?}, size {}", dir, size);
     Ok(Arc::new(DiskCache::new(
         dir,
         size,
         pool,
         preprocessor_cache_mode_config,
+        rw_mode,
     )))
 }
 

src/cache/disk.rs

@@ -12,8 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::cache::{Cache, CacheRead, CacheWrite, Storage};
+use crate::cache::{Cache, CacheMode, CacheRead, CacheWrite, Storage};
 use crate::compiler::PreprocessorCacheEntry;
+use crate::config::CacheRWMode;
 use crate::lru_disk_cache::LruDiskCache;
 use crate::lru_disk_cache::{Error as LruError, ReadSeek};
 use async_trait::async_trait;
@@ -65,6 +66,7 @@ pub struct DiskCache {
     pool: tokio::runtime::Handle,
     preprocessor_cache_mode_config: PreprocessorCacheModeConfig,
     preprocessor_cache: Arc<Mutex<LazyDiskCache>>,
+    rw_mode: CacheRWMode,
 }
 
 impl DiskCache {
@@ -74,6 +76,7 @@ impl DiskCache {
         max_size: u64,
         pool: &tokio::runtime::Handle,
         preprocessor_cache_mode_config: PreprocessorCacheModeConfig,
+        rw_mode: CacheRWMode,
     ) -> DiskCache {
         DiskCache {
             lru: Arc::new(Mutex::new(LazyDiskCache::Uninit {
@@ -88,6 +91,7 @@ impl DiskCache {
                     .into_os_string(),
                 max_size,
             })),
+            rw_mode,
         }
     }
 }
@@ -130,6 +134,11 @@ impl Storage for DiskCache {
         // We should probably do this on a background thread if we're going to buffer
         // everything in memory...
         trace!("DiskCache::finish_put({})", key);
+
+        if self.rw_mode == CacheRWMode::ReadOnly {
+            return Err(anyhow!("Cannot write to a read-only cache1"));
+        }
+
         let lru = self.lru.clone();
         let key = make_key_path(key);
 
@@ -143,6 +152,10 @@ impl Storage for DiskCache {
             .await?
     }
 
+    async fn check(&self) -> Result<CacheMode> {
+        Ok(self.rw_mode.into())
+    }
+
     fn location(&self) -> String {
         format!("Local disk: {:?}", self.lru.lock().unwrap().path())
     }
@@ -171,6 +184,10 @@ impl Storage for DiskCache {
         key: &str,
         preprocessor_cache_entry: PreprocessorCacheEntry,
     ) -> Result<()> {
+        if self.rw_mode == CacheRWMode::ReadOnly {
+            return Err(anyhow!("Cannot write to a read-only cache2"));
+        }
+
         let key = normalize_key(key);
         let mut buf = vec![];
         preprocessor_cache_entry.serialize_to(&mut buf)?;

src/cache/gcs.rs

@@ -13,6 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use crate::config;
 use crate::errors::*;
 use opendal::Operator;
 use opendal::{layers::LoggingLayer, services::Gcs};
@@ -36,6 +37,15 @@ impl RWMode {
     }
 }
 
+impl From<config::CacheRWMode> for RWMode {
+    fn from(value: config::CacheRWMode) -> Self {
+        match value {
+            config::CacheRWMode::ReadOnly => RWMode::ReadOnly,
+            config::CacheRWMode::ReadWrite => RWMode::ReadWrite,
+        }
+    }
+}
+
 /// A cache that stores entries in Google Cloud Storage
 pub struct GCSCache;
 

src/compiler/c.rs

@@ -340,42 +340,51 @@ where
                     let mut updated = false;
                     let hit = preprocessor_cache_entry
                         .lookup_result_digest(preprocessor_cache_mode_config, &mut updated);
+
+                    let mut update_failed = false;
                     if updated {
                         // Time macros have been found, we need to update
                         // the preprocessor cache entry. See [`PreprocessorCacheEntry::result_matches`].
                         debug!(
                             "Preprocessor cache updated because of time macros: {preprocessor_key}"
                         );
-                        storage.put_preprocessor_cache_entry(
+
+                        if let Err(e) = storage.put_preprocessor_cache_entry(
                             preprocessor_key,
                             preprocessor_cache_entry,
-                        )?;
+                        ) {
+                            debug!("Failed to update preprocessor cache: {}", e);
+                            update_failed = true;
+                        }
                     }
-                    if let Some(key) = hit {
-                        debug!("Preprocessor cache hit: {preprocessor_key}");
-                        // A compiler binary may be a symlink to another and
-                        // so has the same digest, but that means
-                        // the toolchain will not contain the correct path
-                        // to invoke the compiler! Add the compiler
-                        // executable path to try and prevent this
-                        let weak_toolchain_key =
-                            format!("{}-{}", executable.to_string_lossy(), executable_digest);
-                        return Ok(HashResult {
-                            key,
-                            compilation: Box::new(CCompilation {
-                                parsed_args: parsed_args.to_owned(),
-                                #[cfg(feature = "dist-client")]
-                                // TODO or is it never relevant since dist?
-                                preprocessed_input: vec![],
-                                executable: executable.to_owned(),
-                                compiler: compiler.to_owned(),
-                                cwd: cwd.to_owned(),
-                                env_vars: env_vars.to_owned(),
-                            }),
-                            weak_toolchain_key,
-                        });
-                    } else {
-                        debug!("Preprocessor cache miss: {preprocessor_key}");
+
+                    if !update_failed {
+                        if let Some(key) = hit {
+                            debug!("Preprocessor cache hit: {preprocessor_key}");
+                            // A compiler binary may be a symlink to another and
+                            // so has the same digest, but that means
+                            // the toolchain will not contain the correct path
+                            // to invoke the compiler! Add the compiler
+                            // executable path to try and prevent this
+                            let weak_toolchain_key =
+                                format!("{}-{}", executable.to_string_lossy(), executable_digest);
+                            return Ok(HashResult {
+                                key,
+                                compilation: Box::new(CCompilation {
+                                    parsed_args: parsed_args.to_owned(),
+                                    #[cfg(feature = "dist-client")]
+                                    // TODO or is it never relevant since dist?
+                                    preprocessed_input: vec![],
+                                    executable: executable.to_owned(),
+                                    compiler: compiler.to_owned(),
+                                    cwd: cwd.to_owned(),
+                                    env_vars: env_vars.to_owned(),
+                                }),
+                                weak_toolchain_key,
+                            });
+                        } else {
+                            debug!("Preprocessor cache miss: {preprocessor_key}");
+                        }
                     }
                 }
             }
@@ -491,8 +500,12 @@ where
                     .collect();
                 files.sort_unstable_by(|a, b| a.1.cmp(&b.1));
                 preprocessor_cache_entry.add_result(start_of_compilation, &key, files);
-                storage
-                    .put_preprocessor_cache_entry(&preprocessor_key, preprocessor_cache_entry)?;
+
+                if let Err(e) = storage
+                    .put_preprocessor_cache_entry(&preprocessor_key, preprocessor_cache_entry)
+                {
+                    debug!("Failed to update preprocessor cache: {}", e);
+                }
             }
         }
 

src/compiler/compiler.rs

@@ -1382,6 +1382,7 @@ mod test {
     use super::*;
     use crate::cache::disk::DiskCache;
     use crate::cache::{CacheRead, PreprocessorCacheModeConfig};
+    use crate::config::CacheRWMode;
     use crate::mock_command::*;
     use crate::test::mock_storage::MockStorage;
     use crate::test::utils::*;
@@ -1824,6 +1825,7 @@ LLVM version: 6.0",
                 use_preprocessor_cache_mode: preprocessor_cache_mode,
                 ..Default::default()
             },
+            CacheRWMode::ReadWrite,
         );
         // Write a dummy input file so the preprocessor cache mode can work
         std::fs::write(f.tempdir.path().join("foo.c"), "whatever").unwrap();
@@ -1949,6 +1951,7 @@ LLVM version: 6.0",
                 use_preprocessor_cache_mode: preprocessor_cache_mode,
                 ..Default::default()
             },
+            CacheRWMode::ReadWrite,
         );
         // Write a dummy input file so the preprocessor cache mode can work
         std::fs::write(f.tempdir.path().join("foo.c"), "whatever").unwrap();
@@ -2236,6 +2239,7 @@ LLVM version: 6.0",
                 use_preprocessor_cache_mode: preprocessor_cache_mode,
                 ..Default::default()
             },
+            CacheRWMode::ReadWrite,
         );
         let storage = Arc::new(storage);
         // Write a dummy input file so the preprocessor cache mode can work
@@ -2361,6 +2365,7 @@ LLVM version: 6.0",
                 use_preprocessor_cache_mode: preprocessor_cache_mode,
                 ..Default::default()
             },
+            CacheRWMode::ReadWrite,
         );
         let storage = Arc::new(storage);
         // Pretend to be GCC.  Also inject a fake object file that the subsequent
@@ -2454,6 +2459,7 @@ LLVM version: 6.0",
                 use_preprocessor_cache_mode: preprocessor_cache_mode,
                 ..Default::default()
             },
+            CacheRWMode::ReadWrite,
         );
         let storage = Arc::new(storage);
         // Pretend to be GCC.