kache 0.6.0

Zero-copy, content-addressed Rust build cache. No copies, no wasted disk — just hardlinks locally and S3 for sharing.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use crate::config::{Config, RemoteConfig};
use crate::remote_layout::RemoteLayout;

/// The kind of remote workload being planned.
///
/// `v3` should eventually tune remote behavior differently for cold restores,
/// background prefetch, and uploads. Today all workloads use the same pack-first
/// layout, but callers no longer decide that directly.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RemoteWorkload {
    RestoreCheck,
    Prefetch,
    SyncPull,
    SyncPush,
    BackgroundUpload,
    KeyDiscovery,
}

/// Remote object layout selected for an operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RemoteLayoutKind {
    V3,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RemotePlan {
    pub workload: RemoteWorkload,
    pub layout: RemoteLayoutKind,
}

impl RemotePlan {
    pub fn layout<'a>(
        &self,
        client: &'a aws_sdk_s3::Client,
        remote: &'a RemoteConfig,
    ) -> RemoteLayout<'a> {
        match self.layout {
            RemoteLayoutKind::V3 => RemoteLayout::new(client, remote),
        }
    }

    pub fn transfer_format(&self) -> &'static str {
        match self.layout {
            RemoteLayoutKind::V3 => "v3",
        }
    }
}

/// Chooses the remote plan for each workload.
///
/// For now this routes every workload through the same `v3` pack-first layout.
/// The goal is to keep one place where local-optimized and remote-optimized
/// behavior can diverge later without rewriting call sites again.
pub struct RemotePlanner<'a> {
    _config: &'a Config,
}

impl<'a> RemotePlanner<'a> {
    pub fn new(config: &'a Config) -> Self {
        Self { _config: config }
    }

    pub fn plan(&self, workload: RemoteWorkload) -> RemotePlan {
        RemotePlan {
            workload,
            layout: RemoteLayoutKind::V3,
        }
    }
}

#[cfg(test)]
mod tests {
    use std::path::PathBuf;

    use super::{RemoteLayoutKind, RemotePlanner, RemoteWorkload};
    use crate::config::{Config, DEFAULT_DAEMON_IDLE_TIMEOUT_SECS, DEFAULT_S3_POOL_IDLE_SECS};

    fn test_config() -> Config {
        Config {
            fallback: None,
            key_salt: None,
            cc_extra_allowlist_flags: Vec::new(),
            local_only: false,
            modified_input_guard: false,
            path_only_env_vars: Vec::new(),
            cache_dir: PathBuf::from("/tmp/kache-test"),
            max_size: 1024,
            remote: None,
            disabled: false,
            cache_executables: false,
            clean_incremental: true,
            event_log_max_size: 1024,
            event_log_keep_lines: 100,
            compression_level: 3,
            s3_concurrency: 16,
            daemon_idle_timeout_secs: DEFAULT_DAEMON_IDLE_TIMEOUT_SECS,
            s3_pool_idle_secs: DEFAULT_S3_POOL_IDLE_SECS,
        }
    }

    #[test]
    fn default_plans_use_v3_layout() {
        let config = test_config();
        let planner = RemotePlanner::new(&config);

        for workload in [
            RemoteWorkload::RestoreCheck,
            RemoteWorkload::Prefetch,
            RemoteWorkload::SyncPull,
            RemoteWorkload::SyncPush,
            RemoteWorkload::BackgroundUpload,
            RemoteWorkload::KeyDiscovery,
        ] {
            assert_eq!(planner.plan(workload).layout, RemoteLayoutKind::V3);
        }
    }
}