Rename write_policy to write_error_policy

Author: Felixoid

docs/MultiLevel.md

@@ -132,7 +132,7 @@ export SCCACHE_MULTILEVEL_CHAIN="disk,redis,s3"
 
 ### Write Policy Configuration
 
-Control how sccache handles write failures across cache levels using `SCCACHE_MULTILEVEL_WRITE_POLICY`:
+Control how sccache handles write failures across cache levels using `SCCACHE_MULTILEVEL_WRITE_ERROR_POLICY`:
 
 **Available policies**:
 - **`ignore`** - Never fail on write errors, log warnings only (most permissive)
@@ -146,21 +146,21 @@ Control how sccache handles write failures across cache levels using `SCCACHE_MU
 **Example 1: Default Behavior (l0 policy)**
 ```bash
 export SCCACHE_MULTILEVEL_CHAIN="disk,redis,s3"
-export SCCACHE_MULTILEVEL_WRITE_POLICY="l0"  # or omit, it's the default
+export SCCACHE_MULTILEVEL_WRITE_ERROR_POLICY="l0"  # or omit, it's the default
 ```
 Compilation succeeds if disk write succeeds. Redis/S3 failures are logged but don't block compilation. Ensures local cache is always populated. **Best for most use cases.**
 
 **Example 2: Best Effort (ignore policy)**
 ```bash
 export SCCACHE_MULTILEVEL_CHAIN="disk,redis,s3"
-export SCCACHE_MULTILEVEL_WRITE_POLICY="ignore"
+export SCCACHE_MULTILEVEL_WRITE_ERROR_POLICY="ignore"
 ```
 Compilation always succeeds, even if all writes fail. Write failures are logged as warnings. **Best for unstable cache backends** where you don't want cache issues blocking builds.
 
 **Example 3: Strict Consistency (all policy)**
 ```bash
 export SCCACHE_MULTILEVEL_CHAIN="disk,redis,s3"
-export SCCACHE_MULTILEVEL_WRITE_POLICY="all"
+export SCCACHE_MULTILEVEL_WRITE_ERROR_POLICY="all"
 ```
 Compilation succeeds only if all read-write levels succeed. Any write failure fails the compilation. **Best for critical environments** where cache consistency is mandatory.
 
@@ -170,7 +170,7 @@ Any level configured as read-only (e.g., `SCCACHE_LOCAL_RW_MODE=READ_ONLY`) is a
 
 ```bash
 export SCCACHE_MULTILEVEL_CHAIN="disk,redis"
-export SCCACHE_MULTILEVEL_WRITE_POLICY="all"
+export SCCACHE_MULTILEVEL_WRITE_ERROR_POLICY="all"
 export SCCACHE_LOCAL_RW_MODE="READ_ONLY"  # Disk is read-only
 # Compilation succeeds if Redis write succeeds (disk is skipped)
 ```
@@ -180,7 +180,7 @@ export SCCACHE_LOCAL_RW_MODE="READ_ONLY"  # Disk is read-only
 ```bash
 # Multi-level configuration
 export SCCACHE_MULTILEVEL_CHAIN="disk,redis,s3"
-export SCCACHE_MULTILEVEL_WRITE_POLICY="l0"  # Default: fail only if disk fails
+export SCCACHE_MULTILEVEL_WRITE_ERROR_POLICY="l0"  # Default: fail only if disk fails
 
 # Level 0: Disk cache
 export SCCACHE_DIR="/var/cache/sccache"
@@ -202,7 +202,7 @@ export SCCACHE_S3_USE_SSL="true"
 # ~/.config/sccache/config
 [cache.multilevel]
 chain = ["disk", "redis", "s3"]
-write_policy = "l0"  # Optional: ignore, l0 (default), or all
+write_error_policy = "l0"  # Optional: ignore, l0 (default), or all
 
 [cache.disk]
 dir = "/var/cache/sccache"

src/cache/multilevel.rs

@@ -47,7 +47,7 @@ use crate::compiler::PreprocessorCacheEntry;
     feature = "cos"
 ))]
 use crate::config::CacheType;
-use crate::config::{Config, PreprocessorCacheModeConfig, WritePolicy};
+use crate::config::{Config, PreprocessorCacheModeConfig, WriteErrorPolicy};
 use crate::errors::*;
 
 /// Lock-free atomic counters for multi-level cache statistics.
@@ -307,7 +307,7 @@ impl MultiLevelStats {
 /// See docs/MultiLevel.md for details.
 pub struct MultiLevelStorage {
     levels: Vec<Arc<dyn Storage>>,
-    write_policy: WritePolicy,
+    write_error_policy: WriteErrorPolicy,
     /// Lock-free atomic statistics per level
     atomic_stats: Vec<Arc<AtomicLevelStats>>,
     /// Base directories for path normalization, propagated to compiler pipeline
@@ -333,17 +333,20 @@ impl MultiLevelStorage {
     /// Levels are checked in order (L0, L1, L2, ...) during reads.
     /// All levels receive writes in parallel.
     pub fn new(levels: Vec<Arc<dyn Storage>>) -> Self {
-        Self::with_write_policy(levels, WritePolicy::default())
+        Self::with_write_error_policy(levels, WriteErrorPolicy::default())
     }
 
     /// Create a new multi-level storage with explicit write policy.
-    pub fn with_write_policy(levels: Vec<Arc<dyn Storage>>, write_policy: WritePolicy) -> Self {
+    pub fn with_write_error_policy(
+        levels: Vec<Arc<dyn Storage>>,
+        write_error_policy: WriteErrorPolicy,
+    ) -> Self {
         let atomic_stats = AtomicLevelStats::from_levels(&levels);
         let basedirs = Self::collect_basedirs(&levels);
 
         MultiLevelStorage {
             levels,
-            write_policy,
+            write_error_policy,
             atomic_stats,
             basedirs,
         }
@@ -391,7 +394,7 @@ impl MultiLevelStorage {
         );
 
         let levels = &ml_config.chain;
-        let write_policy = ml_config.write_policy;
+        let write_error_policy = ml_config.write_error_policy;
 
         let mut storages: Vec<Arc<dyn Storage>> = Vec::new();
 
@@ -508,9 +511,9 @@ impl MultiLevelStorage {
             storages.len()
         );
 
-        Ok(Some(MultiLevelStorage::with_write_policy(
+        Ok(Some(MultiLevelStorage::with_write_error_policy(
             storages,
-            write_policy,
+            write_error_policy,
         )))
     }
 
@@ -696,14 +699,14 @@ impl Storage for MultiLevelStorage {
         let data: Bytes = entry.finish()?.into();
         let key_str = key.to_string();
 
-        match self.write_policy {
-            WritePolicy::Ignore => {
+        match self.write_error_policy {
+            WriteErrorPolicy::Ignore => {
                 // Never fail, log warnings only
                 self.write_remaining_levels_async(&key_str, &data, 0).await;
                 Ok(Duration::ZERO)
             }
 
-            WritePolicy::L0 => {
+            WriteErrorPolicy::L0 => {
                 // Fail only if L0 write fails (unless L0 is read-only)
                 if let Some(l0) = self.levels.first() {
                     // Check if L0 is read-only before attempting write
@@ -731,7 +734,7 @@ impl Storage for MultiLevelStorage {
                 Ok(Duration::ZERO)
             }
 
-            WritePolicy::All => {
+            WriteErrorPolicy::All => {
                 // Fail if any RW level fails
                 use tokio::sync::mpsc;
                 let (tx, mut rx) = mpsc::channel(self.levels.len());

src/cache/multilevel_test.rs

@@ -1143,9 +1143,9 @@ fn test_put_mode_ignore() {
     let cache_l0 = Arc::new(FailingStorage);
     let cache_l1 = Arc::new(FailingStorage);
 
-    let storage = MultiLevelStorage::with_write_policy(
+    let storage = MultiLevelStorage::with_write_error_policy(
         vec![cache_l0 as Arc<dyn Storage>, cache_l1 as Arc<dyn Storage>],
-        WritePolicy::Ignore,
+        WriteErrorPolicy::Ignore,
     );
 
     runtime.block_on(async {
@@ -1154,7 +1154,7 @@ fn test_put_mode_ignore() {
 
         assert!(
             result.is_ok(),
-            "WritePolicy::Ignore should never fail, even when all levels error"
+            "WriteErrorPolicy::Ignore should never fail, even when all levels error"
         );
     });
 }
@@ -1171,9 +1171,9 @@ fn test_put_mode_l0_fails_on_error() {
     let cache_l0 = Arc::new(FailingStorage);
     let cache_l1 = Arc::new(InMemoryStorage::new());
 
-    let storage = MultiLevelStorage::with_write_policy(
+    let storage = MultiLevelStorage::with_write_error_policy(
         vec![cache_l0 as Arc<dyn Storage>, cache_l1 as Arc<dyn Storage>],
-        WritePolicy::L0,
+        WriteErrorPolicy::L0,
     );
 
     runtime.block_on(async {
@@ -1182,7 +1182,7 @@ fn test_put_mode_l0_fails_on_error() {
 
         assert!(
             result.is_err(),
-            "WritePolicy::L0 should fail when L0 write fails"
+            "WriteErrorPolicy::L0 should fail when L0 write fails"
         );
         let err_msg = result.unwrap_err().to_string();
         assert!(
@@ -1205,9 +1205,9 @@ fn test_put_mode_l0_succeeds_if_l0_ok() {
     let cache_l0 = Arc::new(InMemoryStorage::new());
     let cache_l1 = Arc::new(FailingStorage);
 
-    let storage = MultiLevelStorage::with_write_policy(
+    let storage = MultiLevelStorage::with_write_error_policy(
         vec![cache_l0 as Arc<dyn Storage>, cache_l1 as Arc<dyn Storage>],
-        WritePolicy::L0,
+        WriteErrorPolicy::L0,
     );
 
     runtime.block_on(async {
@@ -1216,7 +1216,7 @@ fn test_put_mode_l0_succeeds_if_l0_ok() {
 
         assert!(
             result.is_ok(),
-            "WritePolicy::L0 should succeed when L0 succeeds, even if L1+ fails"
+            "WriteErrorPolicy::L0 should succeed when L0 succeeds, even if L1+ fails"
         );
     });
 }
@@ -1233,9 +1233,9 @@ fn test_put_mode_all_fails_on_any_error() {
     let cache_l0 = Arc::new(InMemoryStorage::new());
     let cache_l1 = Arc::new(FailingStorage);
 
-    let storage = MultiLevelStorage::with_write_policy(
+    let storage = MultiLevelStorage::with_write_error_policy(
         vec![cache_l0 as Arc<dyn Storage>, cache_l1 as Arc<dyn Storage>],
-        WritePolicy::All,
+        WriteErrorPolicy::All,
     );
 
     runtime.block_on(async {
@@ -1247,7 +1247,7 @@ fn test_put_mode_all_fails_on_any_error() {
 
         assert!(
             result.is_err(),
-            "WritePolicy::All should fail when any RW level fails"
+            "WriteErrorPolicy::All should fail when any RW level fails"
         );
     });
 }
@@ -1264,12 +1264,12 @@ fn test_put_mode_all_succeeds_when_all_ok() {
     let cache_l0 = Arc::new(InMemoryStorage::new());
     let cache_l1 = Arc::new(InMemoryStorage::new());
 
-    let storage = MultiLevelStorage::with_write_policy(
+    let storage = MultiLevelStorage::with_write_error_policy(
         vec![
             cache_l0.clone() as Arc<dyn Storage>,
             cache_l1.clone() as Arc<dyn Storage>,
         ],
-        WritePolicy::All,
+        WriteErrorPolicy::All,
     );
 
     runtime.block_on(async {
@@ -1281,7 +1281,7 @@ fn test_put_mode_all_succeeds_when_all_ok() {
 
         assert!(
             result.is_ok(),
-            "WritePolicy::All should succeed when all levels succeed"
+            "WriteErrorPolicy::All should succeed when all levels succeed"
         );
 
         // Verify both levels have the data
@@ -1309,13 +1309,13 @@ fn test_put_mode_all_skips_readonly() {
     let cache_l1 = Arc::new(ReadOnlyStorage(Arc::new(InMemoryStorage::new())));
     let cache_l2 = Arc::new(InMemoryStorage::new());
 
-    let storage = MultiLevelStorage::with_write_policy(
+    let storage = MultiLevelStorage::with_write_error_policy(
         vec![
             cache_l0.clone() as Arc<dyn Storage>,
             cache_l1 as Arc<dyn Storage>,
             cache_l2.clone() as Arc<dyn Storage>,
         ],
-        WritePolicy::All,
+        WriteErrorPolicy::All,
     );
 
     runtime.block_on(async {
@@ -1327,7 +1327,7 @@ fn test_put_mode_all_skips_readonly() {
 
         assert!(
             result.is_ok(),
-            "WritePolicy::All should succeed when read-only levels are skipped"
+            "WriteErrorPolicy::All should succeed when read-only levels are skipped"
         );
 
         // Verify writable levels have the data

src/config.rs

@@ -40,7 +40,7 @@ use crate::errors::*;
 /// Defines how the multi-level cache handles write failures.
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
-pub enum WritePolicy {
+pub enum WriteErrorPolicy {
     /// Never fail on write errors - log warnings only (most permissive)
     Ignore,
     /// Fail only if L0 write fails (default - balances reliability and performance)
@@ -50,14 +50,14 @@ pub enum WritePolicy {
     All,
 }
 
-impl FromStr for WritePolicy {
+impl FromStr for WriteErrorPolicy {
     type Err = anyhow::Error;
 
     fn from_str(s: &str) -> Result<Self> {
         match s.to_lowercase().as_str() {
-            "ignore" => Ok(WritePolicy::Ignore),
-            "l0" => Ok(WritePolicy::L0),
-            "all" => Ok(WritePolicy::All),
+            "ignore" => Ok(WriteErrorPolicy::Ignore),
+            "l0" => Ok(WriteErrorPolicy::L0),
+            "all" => Ok(WriteErrorPolicy::All),
             _ => Err(anyhow!(
                 "Invalid write policy '{}'. Valid values: ignore, l0, all",
                 s
@@ -66,12 +66,12 @@ impl FromStr for WritePolicy {
     }
 }
 
-impl fmt::Display for WritePolicy {
+impl fmt::Display for WriteErrorPolicy {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            WritePolicy::Ignore => write!(f, "ignore"),
-            WritePolicy::L0 => write!(f, "l0"),
-            WritePolicy::All => write!(f, "all"),
+            WriteErrorPolicy::Ignore => write!(f, "ignore"),
+            WriteErrorPolicy::L0 => write!(f, "l0"),
+            WriteErrorPolicy::All => write!(f, "all"),
         }
     }
 }
@@ -84,7 +84,7 @@ pub struct MultiLevelConfig {
     pub chain: Vec<String>,
     /// Write failure handling policy
     #[serde(default)]
-    pub write_policy: WritePolicy,
+    pub write_error_policy: WriteErrorPolicy,
 }
 
 static CACHED_CONFIG_PATH: LazyLock<PathBuf> = LazyLock::new(CachedConfig::file_config_path);
@@ -1138,14 +1138,14 @@ fn config_from_env() -> Result<EnvConfig> {
     let multilevel = if let Ok(chain_str) = env::var("SCCACHE_MULTILEVEL_CHAIN") {
         let chain: Vec<String> = chain_str.split(',').map(|s| s.trim().to_string()).collect();
 
-        let write_policy = env::var("SCCACHE_MULTILEVEL_WRITE_POLICY")
+        let write_error_policy = env::var("SCCACHE_MULTILEVEL_WRITE_ERROR_POLICY")
             .ok()
-            .and_then(|s| s.parse::<WritePolicy>().ok())
+            .and_then(|s| s.parse::<WriteErrorPolicy>().ok())
             .unwrap_or_default();
 
         Some(MultiLevelConfig {
             chain,
-            write_policy,
+            write_error_policy,
         })
     } else {
         None
@@ -2831,7 +2831,7 @@ fn test_get_cache_levels_invalid_level() {
     let configs = CacheConfigs {
         multilevel: Some(MultiLevelConfig {
             chain: vec!["unknown_cache".to_string()],
-            write_policy: WritePolicy::default(),
+            write_error_policy: WriteErrorPolicy::default(),
         }),
         ..Default::default()
     };
@@ -2851,7 +2851,7 @@ fn test_get_cache_levels_missing_config() {
     let configs = CacheConfigs {
         multilevel: Some(MultiLevelConfig {
             chain: vec!["s3".to_string()],
-            write_policy: WritePolicy::default(),
+            write_error_policy: WriteErrorPolicy::default(),
         }),
         ..Default::default()
     };