Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit de4fe06

Browse files
ByronByron
committed
Merge branch 'main' into gix-clone
2 parents e462bd5 + 375051f commit de4fe06

31 files changed

Lines changed: 428 additions & 211 deletions

File tree

‎Cargo.lock‎

Lines changed: 1 addition & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎git-index/Cargo.toml‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,7 @@ git-hash = { version = "^0.9.11", path = "../git-hash" }
3535
git-bitmap = { version = "^0.1.2", path = "../git-bitmap" }
3636
git-object = { version = "^0.22.0", path = "../git-object" }
3737
git-traverse = { version = "^0.18.0", path = "../git-traverse" }
38+
git-lock = { version = "2.1.1", path = "../git-lock" }
3839

3940
thiserror = "1.0.32"
4041
memmap2 = "0.5.0"

‎git-index/src/access.rs‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,11 @@ impl State {
99
self.version
1010
}
1111

12+
/// Return the kind of hashes used in this instance.
13+
pub fn object_hash(&self) -> git_hash::Kind {
14+
self.object_hash
15+
}
16+
1217
/// Return our entries
1318
pub fn entries(&self) -> &[Entry] {
1419
&self.entries

‎git-index/src/decode/mod.rs‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -30,10 +30,8 @@ use git_features::parallel::InOrderIter;
3030
use crate::util::read_u32;
3131

3232
/// Options to define how to decode an index state [from bytes][State::from_bytes()].
33-
#[derive(Default)]
33+
#[derive(Default, Clone, Copy)]
3434
pub struct Options {
35-
/// The kind of object hash to assume when decoding object ids.
36-
pub object_hash: git_hash::Kind,
3735
/// If Some(_), we are allowed to use more than one thread. If Some(N), use no more than N threads. If Some(0)|None, use as many threads
3836
/// as there are logical cores.
3937
///
@@ -46,12 +44,13 @@ pub struct Options {
4644
}
4745

4846
impl State {
49-
/// Decode an index state from `data` and store `timestamp` in the resulting instance for pass-through.
47+
/// Decode an index state from `data` and store `timestamp` in the resulting instance for pass-through, assuming `object_hash`
48+
/// to be used through the file.
5049
pub fn from_bytes(
5150
data: &[u8],
5251
timestamp: FileTime,
52+
object_hash: git_hash::Kind,
5353
Options {
54-
object_hash,
5554
thread_limit,
5655
min_extension_block_in_bytes_for_threading,
5756
}: Options,
@@ -210,6 +209,7 @@ impl State {
210209

211210
Ok((
212211
State {
212+
object_hash,
213213
timestamp,
214214
version,
215215
entries,

‎git-index/src/file/init.rs‎

Lines changed: 19 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -23,8 +23,8 @@ pub use error::Error;
2323

2424
/// Initialization
2525
impl File {
26-
/// Open an index file at `path` with `options`.
27-
pub fn at(path: impl Into<PathBuf>, options: decode::Options) -> Result<Self, Error> {
26+
/// Open an index file at `path` with `options`, assuming `object_hash` is used throughout the file.
27+
pub fn at(path: impl Into<PathBuf>, object_hash: git_hash::Kind, options: decode::Options) -> Result<Self, Error> {
2828
let path = path.into();
2929
let (data, mtime) = {
3030
// SAFETY: we have to take the risk of somebody changing the file underneath. Git never writes into the same file.
@@ -34,7 +34,22 @@ impl File {
3434
(data, filetime::FileTime::from_last_modification_time(&file.metadata()?))
3535
};
3636

37-
let (state, checksum) = State::from_bytes(&data, mtime, options)?;
38-
Ok(File { state, path, checksum })
37+
let (state, checksum) = State::from_bytes(&data, mtime, object_hash, options)?;
38+
Ok(File {
39+
state,
40+
path,
41+
checksum: Some(checksum),
42+
})
43+
}
44+
45+
/// Consume `state` and pretend it was read from `path`, setting our checksum to `null`.
46+
///
47+
/// `File` instances created like that should be written to disk to set the correct checksum via `[File::write()]`.
48+
pub fn from_state(state: crate::State, path: impl Into<PathBuf>) -> Self {
49+
File {
50+
state,
51+
path: path.into(),
52+
checksum: None,
53+
}
3954
}
4055
}

‎git-index/src/file/mod.rs‎

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,39 @@ mod impl_ {
3030
}
3131
}
3232
}
33+
34+
mod access {
35+
use crate::File;
36+
37+
/// Consumption
38+
impl File {
39+
/// Take the state and discard the rest.
40+
pub fn into_state(self) -> crate::State {
41+
self.state
42+
}
43+
44+
/// Take all non-copy parts of the index.
45+
pub fn into_parts(self) -> (crate::State, std::path::PathBuf) {
46+
(self.state, self.path)
47+
}
48+
}
49+
50+
/// Access
51+
impl File {
52+
/// The path from which the index was read or to which it is supposed to be written when used with [`File::from_state()`].
53+
pub fn path(&self) -> &std::path::Path {
54+
&self.path
55+
}
56+
57+
/// The checksum over the file that was read or written to disk, or `None` if the state in memory was never serialized.
58+
///
59+
/// Note that even if `Some`, it will only represent the state in memory right after reading or [writing][File::write()].
60+
pub fn checksum(&self) -> Option<git_hash::ObjectId> {
61+
self.checksum
62+
}
63+
}
64+
}
65+
3366
///
3467
pub mod init;
3568
///

‎git-index/src/file/verify.rs‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -14,25 +14,28 @@ mod error {
1414
actual: git_hash::ObjectId,
1515
expected: git_hash::ObjectId,
1616
},
17+
#[error("Checksum of in-memory index wasn't computed yet")]
18+
NoChecksum,
1719
}
1820
}
1921
pub use error::Error;
2022

2123
impl File {
2224
/// Verify the integrity of the index to assure its consistency.
2325
pub fn verify_integrity(&self) -> Result<(), Error> {
24-
let num_bytes_to_hash = self.path.metadata()?.len() - self.checksum.as_bytes().len() as u64;
26+
let checksum = self.checksum.ok_or(Error::NoChecksum)?;
27+
let num_bytes_to_hash = self.path.metadata()?.len() - checksum.as_bytes().len() as u64;
2528
let should_interrupt = AtomicBool::new(false);
2629
let actual = git_features::hash::bytes_of_file(
2730
&self.path,
2831
num_bytes_to_hash as usize,
29-
self.checksum.kind(),
32+
checksum.kind(),
3033
&mut git_features::progress::Discard,
3134
&should_interrupt,
3235
)?;
33-
(actual == self.checksum).then(|| ()).ok_or(Error::ChecksumMismatch {
36+
(actual == checksum).then(|| ()).ok_or(Error::ChecksumMismatch {
3437
actual,
35-
expected: self.checksum,
38+
expected: checksum,
3639
})
3740
}
3841
}

‎git-index/src/file/write.rs‎

Lines changed: 38 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2,15 +2,50 @@ use git_features::hash;
22

33
use crate::{write, File, Version};
44

5+
/// The error produced by [`File::write()`].
6+
#[derive(Debug, thiserror::Error)]
7+
#[allow(missing_docs)]
8+
pub enum Error {
9+
#[error(transparent)]
10+
Io(#[from] std::io::Error),
11+
#[error("Could not acquire lock for index file")]
12+
AcquireLock(#[from] git_lock::acquire::Error),
13+
#[error("Could not commit lock for index file")]
14+
CommitLock(#[from] git_lock::commit::Error<git_lock::File>),
15+
}
16+
517
impl File {
618
/// Write the index to `out` with `options`, to be readable by [`File::at()`], returning the version that was actually written
719
/// to retain all information of this index.
8-
pub fn write_to(&self, mut out: impl std::io::Write, options: write::Options) -> std::io::Result<Version> {
9-
let mut hasher = hash::Write::new(&mut out, options.hash_kind);
20+
pub fn write_to(
21+
&self,
22+
mut out: impl std::io::Write,
23+
options: write::Options,
24+
) -> std::io::Result<(Version, git_hash::ObjectId)> {
25+
let mut hasher = hash::Write::new(&mut out, self.state.object_hash);
1026
let version = self.state.write_to(&mut hasher, options)?;
1127

1228
let hash = hasher.hash.digest();
1329
out.write_all(&hash)?;
14-
Ok(version)
30+
Ok((version, git_hash::ObjectId::from(hash)))
31+
}
32+
33+
/// Write ourselves to the path we were read from after acquiring a lock, using `options`.
34+
///
35+
/// Note that the hash produced will be stored which is why we need to be mutable.
36+
pub fn write(&mut self, options: write::Options) -> Result<(), Error> {
37+
let mut lock = std::io::BufWriter::new(git_lock::File::acquire_to_update_resource(
38+
&self.path,
39+
git_lock::acquire::Fail::Immediately,
40+
None,
41+
)?);
42+
let (version, digest) = self.write_to(&mut lock, options)?;
43+
match lock.into_inner() {
44+
Ok(lock) => lock.commit()?,
45+
Err(err) => return Err(err.into_error().into()),
46+
};
47+
self.state.version = version;
48+
self.checksum = Some(digest);
49+
Ok(())
1550
}
1651
}

0 commit comments

Comments
 (0)