amiss-git 0.1.0

Read-only Git object store behind a no-follow handle boundary, for Amiss
Documentation 
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use std::collections::BTreeSet;

use amiss_wire::controls::ResourceName;

use crate::Error;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct GitLimits {
    pub inflated_object_bytes: u64,
    pub compressed_stream_bytes: u64,
    pub aggregate_compressed_bytes: u64,
    pub pack_directory_entries: u64,
    pub pack_files: u64,
    pub pack_index_bytes: u64,
    pub aggregate_pack_index_bytes: u64,
    pub delta_depth: u64,
    pub index_bytes: u64,
    pub tree_entries_per_snapshot: u64,
    pub raw_path_bytes: u64,
}

/// A smaller contextual inflated cap (a document, target, or control blob)
/// that applies before the general Git object cap when the object header
/// declares a larger value.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ValueCap {
    pub resource: ResourceName,
    pub limit: u64,
}

impl GitLimits {
    pub const CONTRACT: Self = Self {
        inflated_object_bytes: 134_217_728,
        compressed_stream_bytes: 268_435_456,
        aggregate_compressed_bytes: 2_147_483_648,
        pack_directory_entries: 8_192,
        pack_files: 4_096,
        pack_index_bytes: 536_870_912,
        aggregate_pack_index_bytes: 1_073_741_824,
        delta_depth: 128,
        index_bytes: 268_435_456,
        tree_entries_per_snapshot: 1_000_000,
        raw_path_bytes: 4_096,
    };
}

impl Default for GitLimits {
    fn default() -> Self {
        Self::CONTRACT
    }
}

pub(crate) fn crossing(resource: ResourceName, configured_limit: u64, observed: u64) -> Error {
    Error::ResourceLimit {
        resource,
        configured_limit,
        observed_lower_bound: observed,
    }
}

/// Byte charging for one evaluation side: each member is charged once per
/// selected member key, so cache hits never recharge.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct GitResources {
    limits: GitLimits,
    aggregate_compressed: u64,
    aggregate_index: u64,
    charged: BTreeSet<String>,
}

impl GitResources {
    #[must_use]
    pub fn new(limits: GitLimits) -> Self {
        Self {
            limits,
            aggregate_compressed: 0,
            aggregate_index: 0,
            charged: BTreeSet::new(),
        }
    }

    #[must_use]
    pub const fn limits(&self) -> GitLimits {
        self.limits
    }

    /// # Errors
    ///
    /// Fails when the stream crosses the per-stream cap or the running total
    /// crosses the aggregate cap.
    pub fn charge_compressed(&mut self, member: &str, bytes: u64) -> Result<(), Error> {
        if bytes > self.limits.compressed_stream_bytes {
            return Err(crossing(
                ResourceName::GitCompressedObjectBytes,
                self.limits.compressed_stream_bytes,
                bytes,
            ));
        }
        if self.charged.contains(member) {
            return Ok(());
        }
        let total = self.aggregate_compressed.saturating_add(bytes);
        if total > self.limits.aggregate_compressed_bytes {
            return Err(crossing(
                ResourceName::AggregateGitCompressedObjectBytesPerEvaluation,
                self.limits.aggregate_compressed_bytes,
                total,
            ));
        }
        self.aggregate_compressed = total;
        self.charged.insert(member.to_owned());
        Ok(())
    }

    /// # Errors
    ///
    /// Fails when one index crosses the per-index cap or the running total
    /// crosses the aggregate cap.
    pub fn charge_index(&mut self, member: &str, bytes: u64) -> Result<(), Error> {
        if bytes > self.limits.pack_index_bytes {
            return Err(crossing(
                ResourceName::GitPackIndexBytes,
                self.limits.pack_index_bytes,
                bytes,
            ));
        }
        let key = format!("idx:{member}");
        if self.charged.contains(&key) {
            return Ok(());
        }
        let total = self.aggregate_index.saturating_add(bytes);
        if total > self.limits.aggregate_pack_index_bytes {
            return Err(crossing(
                ResourceName::AggregateGitPackIndexBytes,
                self.limits.aggregate_pack_index_bytes,
                total,
            ));
        }
        self.aggregate_index = total;
        self.charged.insert(key);
        Ok(())
    }
}