Mercurial > hg
view rust/hg-core/src/dirstate/parsers.rs @ 46890:441024b279a6
rust: Remove the compile-time 'dirstate-tree' feature flag
This code has compiler errors since it is not built on CI and nobody has been
working on it for some time.
We (Octobus) are still pursuing status optimizations based on a tree data
structure for the dirstate, but upcoming patches will use a run-time opt-in
instead of compile-time, so that at least corresponding Rust code keeps
compiling when other changes are made.
Differential Revision: https://phab.mercurial-scm.org/D10329
author | Simon Sapin <simon.sapin@octobus.net> |
---|---|
date | Thu, 08 Apr 2021 21:46:54 +0200 |
parents | 755c31a1caf9 |
children | e66ea29e2b1a |
line wrap: on
line source
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // // This software may be used and distributed according to the terms of the // GNU General Public License version 2 or any later version. use crate::errors::HgError; use crate::utils::hg_path::HgPath; use crate::{ dirstate::{CopyMap, EntryState, RawEntry, StateMap}, DirstateEntry, DirstateParents, }; use byteorder::{BigEndian, WriteBytesExt}; use bytes_cast::BytesCast; use micro_timer::timed; use std::convert::{TryFrom, TryInto}; use std::time::Duration; /// Parents are stored in the dirstate as byte hashes. pub const PARENT_SIZE: usize = 20; /// Dirstate entries have a static part of 8 + 32 + 32 + 32 + 32 bits. const MIN_ENTRY_SIZE: usize = 17; type ParseResult<'a> = ( &'a DirstateParents, Vec<(&'a HgPath, DirstateEntry)>, Vec<(&'a HgPath, &'a HgPath)>, ); pub fn parse_dirstate_parents( contents: &[u8], ) -> Result<&DirstateParents, HgError> { let (parents, _rest) = DirstateParents::from_bytes(contents) .map_err(|_| HgError::corrupted("Too little data for dirstate."))?; Ok(parents) } #[timed] pub fn parse_dirstate(mut contents: &[u8]) -> Result<ParseResult, HgError> { let mut copies = Vec::new(); let mut entries = Vec::new(); let (parents, rest) = DirstateParents::from_bytes(contents) .map_err(|_| HgError::corrupted("Too little data for dirstate."))?; contents = rest; while !contents.is_empty() { let (raw_entry, rest) = RawEntry::from_bytes(contents) .map_err(|_| HgError::corrupted("Overflow in dirstate."))?; let entry = DirstateEntry { state: EntryState::try_from(raw_entry.state)?, mode: raw_entry.mode.get(), mtime: raw_entry.mtime.get(), size: raw_entry.size.get(), }; let (paths, rest) = u8::slice_from_bytes(rest, raw_entry.length.get() as usize) .map_err(|_| HgError::corrupted("Overflow in dirstate."))?; // `paths` is either a single path, or two paths separated by a NULL // byte let mut iter = paths.splitn(2, |&byte| byte == b'\0'); let path = HgPath::new( iter.next().expect("splitn always yields at least one item"), ); if let Some(copy_source) = iter.next() { copies.push((path, HgPath::new(copy_source))); } entries.push((path, entry)); contents = rest; } Ok((parents, entries, copies)) } /// `now` is the duration in seconds since the Unix epoch pub fn pack_dirstate( state_map: &mut StateMap, copy_map: &CopyMap, parents: DirstateParents, now: Duration, ) -> Result<Vec<u8>, HgError> { // TODO move away from i32 before 2038. let now: i32 = now.as_secs().try_into().expect("time overflow"); let expected_size: usize = state_map .iter() .map(|(filename, _)| { let mut length = MIN_ENTRY_SIZE + filename.len(); if let Some(copy) = copy_map.get(filename) { length += copy.len() + 1; } length }) .sum(); let expected_size = expected_size + PARENT_SIZE * 2; let mut packed = Vec::with_capacity(expected_size); packed.extend(parents.p1.as_bytes()); packed.extend(parents.p2.as_bytes()); for (filename, entry) in state_map.iter_mut() { let new_filename = filename.to_owned(); let mut new_mtime: i32 = entry.mtime; if entry.state == EntryState::Normal && entry.mtime == now { // The file was last modified "simultaneously" with the current // write to dirstate (i.e. within the same second for file- // systems with a granularity of 1 sec). This commonly happens // for at least a couple of files on 'update'. // The user could change the file without changing its size // within the same second. Invalidate the file's mtime in // dirstate, forcing future 'status' calls to compare the // contents of the file if the size is the same. This prevents // mistakenly treating such files as clean. new_mtime = -1; *entry = DirstateEntry { mtime: new_mtime, ..*entry }; } let mut new_filename = new_filename.into_vec(); if let Some(copy) = copy_map.get(filename) { new_filename.push(b'\0'); new_filename.extend(copy.bytes()); } // Unwrapping because `impl std::io::Write for Vec<u8>` never errors packed.write_u8(entry.state.into()).unwrap(); packed.write_i32::<BigEndian>(entry.mode).unwrap(); packed.write_i32::<BigEndian>(entry.size).unwrap(); packed.write_i32::<BigEndian>(new_mtime).unwrap(); packed .write_i32::<BigEndian>(new_filename.len() as i32) .unwrap(); packed.extend(new_filename) } if packed.len() != expected_size { return Err(HgError::CorruptedRepository(format!( "bad dirstate size: {} != {}", expected_size, packed.len() ))); } Ok(packed) } #[cfg(test)] mod tests { use super::*; use crate::{utils::hg_path::HgPathBuf, FastHashMap}; use pretty_assertions::assert_eq; #[test] fn test_pack_dirstate_empty() { let mut state_map = StateMap::default(); let copymap = FastHashMap::default(); let parents = DirstateParents { p1: b"12345678910111213141".into(), p2: b"00000000000000000000".into(), }; let now = Duration::new(15000000, 0); let expected = b"1234567891011121314100000000000000000000".to_vec(); assert_eq!( expected, pack_dirstate(&mut state_map, ©map, parents, now).unwrap() ); assert!(state_map.is_empty()) } #[test] fn test_pack_dirstate_one_entry() { let expected_state_map: StateMap = [( HgPathBuf::from_bytes(b"f1"), DirstateEntry { state: EntryState::Normal, mode: 0o644, size: 0, mtime: 791231220, }, )] .iter() .cloned() .collect(); let mut state_map = expected_state_map.clone(); let copymap = FastHashMap::default(); let parents = DirstateParents { p1: b"12345678910111213141".into(), p2: b"00000000000000000000".into(), }; let now = Duration::new(15000000, 0); let expected = [ 49, 50, 51, 52, 53, 54, 55, 56, 57, 49, 48, 49, 49, 49, 50, 49, 51, 49, 52, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 110, 0, 0, 1, 164, 0, 0, 0, 0, 47, 41, 58, 244, 0, 0, 0, 2, 102, 49, ] .to_vec(); assert_eq!( expected, pack_dirstate(&mut state_map, ©map, parents, now).unwrap() ); assert_eq!(expected_state_map, state_map); } #[test] fn test_pack_dirstate_one_entry_with_copy() { let expected_state_map: StateMap = [( HgPathBuf::from_bytes(b"f1"), DirstateEntry { state: EntryState::Normal, mode: 0o644, size: 0, mtime: 791231220, }, )] .iter() .cloned() .collect(); let mut state_map = expected_state_map.clone(); let mut copymap = FastHashMap::default(); copymap.insert( HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"copyname"), ); let parents = DirstateParents { p1: b"12345678910111213141".into(), p2: b"00000000000000000000".into(), }; let now = Duration::new(15000000, 0); let expected = [ 49, 50, 51, 52, 53, 54, 55, 56, 57, 49, 48, 49, 49, 49, 50, 49, 51, 49, 52, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 110, 0, 0, 1, 164, 0, 0, 0, 0, 47, 41, 58, 244, 0, 0, 0, 11, 102, 49, 0, 99, 111, 112, 121, 110, 97, 109, 101, ] .to_vec(); assert_eq!( expected, pack_dirstate(&mut state_map, ©map, parents, now).unwrap() ); assert_eq!(expected_state_map, state_map); } #[test] fn test_parse_pack_one_entry_with_copy() { let mut state_map: StateMap = [( HgPathBuf::from_bytes(b"f1"), DirstateEntry { state: EntryState::Normal, mode: 0o644, size: 0, mtime: 791231220, }, )] .iter() .cloned() .collect(); let mut copymap = FastHashMap::default(); copymap.insert( HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"copyname"), ); let parents = DirstateParents { p1: b"12345678910111213141".into(), p2: b"00000000000000000000".into(), }; let now = Duration::new(15000000, 0); let result = pack_dirstate(&mut state_map, ©map, parents.clone(), now) .unwrap(); let (new_parents, entries, copies) = parse_dirstate(result.as_slice()).unwrap(); let new_state_map: StateMap = entries .into_iter() .map(|(path, entry)| (path.to_owned(), entry)) .collect(); let new_copy_map: CopyMap = copies .into_iter() .map(|(path, copy)| (path.to_owned(), copy.to_owned())) .collect(); assert_eq!( (&parents, state_map, copymap), (new_parents, new_state_map, new_copy_map) ) } #[test] fn test_parse_pack_multiple_entries_with_copy() { let mut state_map: StateMap = [ ( HgPathBuf::from_bytes(b"f1"), DirstateEntry { state: EntryState::Normal, mode: 0o644, size: 0, mtime: 791231220, }, ), ( HgPathBuf::from_bytes(b"f2"), DirstateEntry { state: EntryState::Merged, mode: 0o777, size: 1000, mtime: 791231220, }, ), ( HgPathBuf::from_bytes(b"f3"), DirstateEntry { state: EntryState::Removed, mode: 0o644, size: 234553, mtime: 791231220, }, ), ( HgPathBuf::from_bytes(b"f4\xF6"), DirstateEntry { state: EntryState::Added, mode: 0o644, size: -1, mtime: -1, }, ), ] .iter() .cloned() .collect(); let mut copymap = FastHashMap::default(); copymap.insert( HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"copyname"), ); copymap.insert( HgPathBuf::from_bytes(b"f4\xF6"), HgPathBuf::from_bytes(b"copyname2"), ); let parents = DirstateParents { p1: b"12345678910111213141".into(), p2: b"00000000000000000000".into(), }; let now = Duration::new(15000000, 0); let result = pack_dirstate(&mut state_map, ©map, parents.clone(), now) .unwrap(); let (new_parents, entries, copies) = parse_dirstate(result.as_slice()).unwrap(); let new_state_map: StateMap = entries .into_iter() .map(|(path, entry)| (path.to_owned(), entry)) .collect(); let new_copy_map: CopyMap = copies .into_iter() .map(|(path, copy)| (path.to_owned(), copy.to_owned())) .collect(); assert_eq!( (&parents, state_map, copymap), (new_parents, new_state_map, new_copy_map) ) } #[test] /// https://www.mercurial-scm.org/repo/hg/rev/af3f26b6bba4 fn test_parse_pack_one_entry_with_copy_and_time_conflict() { let mut state_map: StateMap = [( HgPathBuf::from_bytes(b"f1"), DirstateEntry { state: EntryState::Normal, mode: 0o644, size: 0, mtime: 15000000, }, )] .iter() .cloned() .collect(); let mut copymap = FastHashMap::default(); copymap.insert( HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"copyname"), ); let parents = DirstateParents { p1: b"12345678910111213141".into(), p2: b"00000000000000000000".into(), }; let now = Duration::new(15000000, 0); let result = pack_dirstate(&mut state_map, ©map, parents.clone(), now) .unwrap(); let (new_parents, entries, copies) = parse_dirstate(result.as_slice()).unwrap(); let new_state_map: StateMap = entries .into_iter() .map(|(path, entry)| (path.to_owned(), entry)) .collect(); let new_copy_map: CopyMap = copies .into_iter() .map(|(path, copy)| (path.to_owned(), copy.to_owned())) .collect(); assert_eq!( ( &parents, [( HgPathBuf::from_bytes(b"f1"), DirstateEntry { state: EntryState::Normal, mode: 0o644, size: 0, mtime: -1 } )] .iter() .cloned() .collect::<StateMap>(), copymap, ), (new_parents, new_state_map, new_copy_map) ) } }