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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
use crate::{
extension::{Link, Signature},
util::split_at_pos,
};
/// The signature of the link extension.
pub const SIGNATURE: Signature = *b"link";
/// Bitmaps to know which entries to delete or replace, even though details are still unknown.
#[derive(Clone)]
pub struct Bitmaps {
/// A bitmap to signal which entries to delete, maybe.
pub delete: gix_bitmap::ewah::Vec,
/// A bitmap to signal which entries to replace, maybe.
pub replace: gix_bitmap::ewah::Vec,
}
///
pub mod decode {
/// The error returned when decoding link extensions.
#[derive(Debug, thiserror::Error)]
#[allow(missing_docs)]
pub enum Error {
#[error("{0}")]
Corrupt(&'static str),
#[error("{kind} bitmap corrupt")]
BitmapDecode {
err: gix_bitmap::ewah::decode::Error,
kind: &'static str,
},
}
impl From<std::num::TryFromIntError> for Error {
fn from(_: std::num::TryFromIntError) -> Self {
Self::Corrupt("error in bitmap iteration trying to convert from u64 to usize")
}
}
}
pub(crate) fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Result<Link, decode::Error> {
let (id, data) = split_at_pos(data, object_hash.len_in_bytes())
.ok_or(decode::Error::Corrupt(
"link extension too short to read share index checksum",
))
.map(|(id, d)| (gix_hash::ObjectId::from(id), d))?;
if data.is_empty() {
return Ok(Link {
shared_index_checksum: id,
bitmaps: None,
});
}
let (delete, data) =
gix_bitmap::ewah::decode(data).map_err(|err| decode::Error::BitmapDecode { kind: "delete", err })?;
let (replace, data) =
gix_bitmap::ewah::decode(data).map_err(|err| decode::Error::BitmapDecode { kind: "replace", err })?;
if !data.is_empty() {
return Err(decode::Error::Corrupt("garbage trailing link extension"));
}
Ok(Link {
shared_index_checksum: id,
bitmaps: Some(Bitmaps { delete, replace }),
})
}
impl Link {
pub(crate) fn dissolve_into(
self,
split_index: &mut crate::File,
object_hash: gix_hash::Kind,
options: crate::decode::Options,
) -> Result<(), crate::file::init::Error> {
let shared_index_path = split_index
.path
.parent()
.expect("split index file in .git folder")
.join(format!("sharedindex.{}", self.shared_index_checksum));
let mut shared_index = crate::File::at(
&shared_index_path,
object_hash,
crate::decode::Options {
expected_checksum: self.shared_index_checksum.into(),
..options
},
)?;
if let Some(bitmaps) = self.bitmaps {
let mut split_entry_index = 0;
let mut err = None;
bitmaps.replace.for_each_set_bit(|replace_index| {
let shared_entry = match shared_index.entries.get_mut(replace_index) {
Some(e) => e,
None => {
err = decode::Error::Corrupt("replace bitmap length exceeds shared index length - more entries in bitmap than found in shared index").into();
return None
}
};
if shared_entry.flags.contains(crate::entry::Flags::REMOVE) {
err = decode::Error::Corrupt("entry is marked as both replace and delete").into();
return None
}
let split_entry = match split_index.entries.get(split_entry_index) {
Some(e) => e,
None => {
err = decode::Error::Corrupt("replace bitmap length exceeds split index length - more entries in bitmap than found in split index").into();
return None
}
};
if !split_entry.path.is_empty() {
err = decode::Error::Corrupt("paths in split index entries that are for replacement should be empty").into();
return None
}
if shared_entry.path.is_empty() {
err = decode::Error::Corrupt("paths in shared index entries that are replaced should not be empty").into();
return None
}
shared_entry.stat = split_entry.stat;
shared_entry.id = split_entry.id;
shared_entry.flags = split_entry.flags;
shared_entry.mode = split_entry.mode;
split_entry_index += 1;
Some(())
});
if let Some(err) = err {
return Err(err.into());
}
let split_index_path_backing = std::mem::take(&mut split_index.path_backing);
for mut split_entry in split_index.entries.drain(split_entry_index..) {
let start = shared_index.path_backing.len();
let split_index_path = split_entry.path.clone();
split_entry.path = start..start + split_entry.path.len();
shared_index.entries.push(split_entry);
shared_index
.path_backing
.extend_from_slice(&split_index_path_backing[split_index_path]);
}
bitmaps.delete.for_each_set_bit(|delete_index| {
let shared_entry = match shared_index.entries.get_mut(delete_index) {
Some(e) => e,
None => {
err = decode::Error::Corrupt("delete bitmap length exceeds shared index length - more entries in bitmap than found in shared index").into();
return None
}
};
shared_entry.flags.insert(crate::entry::Flags::REMOVE);
Some(())
});
if let Some(err) = err {
return Err(err.into());
}
shared_index
.entries
.retain(|e| !e.flags.contains(crate::entry::Flags::REMOVE));
let mut shared_entries = std::mem::take(&mut shared_index.entries);
shared_entries.sort_by(|a, b| a.cmp(b, &shared_index.state));
split_index.entries = shared_entries;
split_index.path_backing = std::mem::take(&mut shared_index.path_backing);
}
Ok(())
}
}
|
