girt 0.18.0

An incremental, idiomatic Rust implementation of Git
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

//! Admission of an already-resolved configuration before maintenance remote resolution.

use std::collections::BTreeMap;
use std::sync::atomic::{AtomicBool, Ordering};

use crate::Config;

/// Independent caps for config inspection and retained remote names, without reading sources.
#[derive(Clone, Copy, Debug)]
pub(crate) struct InventoryLimits {
    pub max_entries: usize,
    pub max_bytes: usize,
    pub max_remotes: usize,
}

impl Default for InventoryLimits {
    fn default() -> Self {
        Self {
            max_entries: 1_000_000,
            max_bytes: 256 * 1024 * 1024,
            max_remotes: 4096,
        }
    }
}

/// One exact remote name, borrowed from its first config entry.
#[derive(Debug)]
pub(crate) struct RemoteEntry<'a> {
    pub name: &'a [u8],
    pub skip: bool,
}

#[derive(Debug, thiserror::Error)]
pub(crate) enum InventoryError {
    #[error("prefetch inventory limit: {0}")]
    Limit(&'static str),
    #[error("prefetch inventory cancelled")]
    Cancelled,
    #[error("invalid remote {key} boolean at config entry {entry}")]
    Boolean { key: &'static str, entry: usize },
}

/// Borrows names in first-entry order, validating every skip-flag occurrence.
///
/// Both skip spellings update the same flag in config order. Empty remote headers do not count,
/// matching the existing remote inventory. Every entry is charged, including unrelated sections;
/// logical bytes count its names, value and 128 bytes of bookkeeping. Limits precede parsing and
/// retained allocations for that entry. Cancellation is checked on entry and every 64 entries.
///
/// This admits neither URL resolution nor refspec parsing. Those later phases need their own
/// budgets, including repeated config scans and URL rewrite work. There is no I/O or mutation.
pub(crate) fn inventory<'a>(
    config: &'a Config,
    limits: InventoryLimits,
    cancel: &AtomicBool,
) -> Result<Vec<RemoteEntry<'a>>, InventoryError> {
    let mut remotes: Vec<RemoteEntry<'_>> = Vec::new();
    let mut positions = BTreeMap::new();
    let mut bytes = 0usize;
    if cancel.load(Ordering::Relaxed) {
        return Err(InventoryError::Cancelled);
    }
    for (index, entry) in config.entries().iter().enumerate() {
        if index % 64 == 0 && cancel.load(Ordering::Relaxed) {
            return Err(InventoryError::Cancelled);
        }
        if index >= limits.max_entries {
            return Err(InventoryError::Limit("config entries"));
        }
        for amount in [
            128,
            entry.section.len(),
            entry.subsection.as_ref().map_or(0, Vec::len),
            entry.name.len(),
            entry.value.as_ref().map_or(0, Vec::len),
        ] {
            bytes = bytes
                .checked_add(amount)
                .filter(|&total| total <= limits.max_bytes)
                .ok_or(InventoryError::Limit("config bytes"))?;
        }
        if !entry.section.eq_ignore_ascii_case(b"remote") {
            continue;
        }
        let Some(name) = entry.subsection.as_deref() else {
            continue;
        };
        let position = match positions.get(name) {
            Some(&position) => position,
            None => {
                if remotes.len() >= limits.max_remotes {
                    return Err(InventoryError::Limit("remotes"));
                }
                let position = remotes.len();
                positions.insert(name, position);
                remotes.push(RemoteEntry { name, skip: false });
                position
            }
        };
        let key = if entry.name.eq_ignore_ascii_case(b"skipfetchall") {
            "skipFetchAll"
        } else if entry.name.eq_ignore_ascii_case(b"skipdefaultupdate") {
            "skipDefaultUpdate"
        } else {
            continue;
        };
        remotes[position].skip = crate::config::values::boolean(entry.value.as_deref()).ok_or(
            InventoryError::Boolean {
                key,
                entry: index + 1,
            },
        )?;
    }
    if cancel.load(Ordering::Relaxed) {
        return Err(InventoryError::Cancelled);
    }
    Ok(remotes)
}