parsers.rs
444 lines
| 14.0 KiB
| application/rls-services+xml
|
RustLexer
|
r42617 | // 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. | ||||
|
r43227 | use crate::utils::hg_path::HgPath; | ||
|
r42828 | use crate::{ | ||
|
r42994 | dirstate::{CopyMap, EntryState, StateMap}, | ||
|
r42993 | DirstateEntry, DirstatePackError, DirstateParents, DirstateParseError, | ||
|
r42828 | }; | ||
|
r42617 | use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; | ||
|
r45028 | use micro_timer::timed; | ||
|
r42994 | use std::convert::{TryFrom, TryInto}; | ||
|
r42617 | use std::io::Cursor; | ||
|
r42993 | use std::time::Duration; | ||
|
r42617 | |||
/// Parents are stored in the dirstate as byte hashes. | ||||
|
r42993 | pub const PARENT_SIZE: usize = 20; | ||
|
r42617 | /// Dirstate entries have a static part of 8 + 32 + 32 + 32 + 32 bits. | ||
const MIN_ENTRY_SIZE: usize = 17; | ||||
|
r45916 | type ParseResult<'a> = ( | ||
DirstateParents, | ||||
Vec<(&'a HgPath, DirstateEntry)>, | ||||
Vec<(&'a HgPath, &'a HgPath)>, | ||||
); | ||||
|
r42993 | |||
|
r45028 | #[timed] | ||
|
r42617 | pub fn parse_dirstate( | ||
contents: &[u8], | ||||
|
r45916 | ) -> Result<ParseResult, DirstateParseError> { | ||
|
r42617 | if contents.len() < PARENT_SIZE * 2 { | ||
return Err(DirstateParseError::TooLittleData); | ||||
} | ||||
|
r45916 | let mut copies = vec![]; | ||
let mut entries = vec![]; | ||||
|
r42617 | |||
let mut curr_pos = PARENT_SIZE * 2; | ||||
let parents = DirstateParents { | ||||
|
r43067 | p1: contents[..PARENT_SIZE].try_into().unwrap(), | ||
p2: contents[PARENT_SIZE..curr_pos].try_into().unwrap(), | ||||
|
r42617 | }; | ||
while curr_pos < contents.len() { | ||||
if curr_pos + MIN_ENTRY_SIZE > contents.len() { | ||||
return Err(DirstateParseError::Overflow); | ||||
} | ||||
let entry_bytes = &contents[curr_pos..]; | ||||
let mut cursor = Cursor::new(entry_bytes); | ||||
|
r42994 | let state = EntryState::try_from(cursor.read_u8()?)?; | ||
|
r42617 | let mode = cursor.read_i32::<BigEndian>()?; | ||
let size = cursor.read_i32::<BigEndian>()?; | ||||
let mtime = cursor.read_i32::<BigEndian>()?; | ||||
let path_len = cursor.read_i32::<BigEndian>()? as usize; | ||||
if path_len > contents.len() - curr_pos { | ||||
return Err(DirstateParseError::Overflow); | ||||
} | ||||
// Slice instead of allocating a Vec needed for `read_exact` | ||||
let path = &entry_bytes[MIN_ENTRY_SIZE..MIN_ENTRY_SIZE + (path_len)]; | ||||
let (path, copy) = match memchr::memchr(0, path) { | ||||
None => (path, None), | ||||
Some(i) => (&path[..i], Some(&path[(i + 1)..])), | ||||
}; | ||||
if let Some(copy_path) = copy { | ||||
|
r45916 | copies.push((HgPath::new(path), HgPath::new(copy_path))); | ||
|
r42617 | }; | ||
|
r45916 | entries.push(( | ||
HgPath::new(path), | ||||
|
r42617 | DirstateEntry { | ||
state, | ||||
mode, | ||||
size, | ||||
mtime, | ||||
}, | ||||
|
r45916 | )); | ||
|
r42617 | curr_pos = curr_pos + MIN_ENTRY_SIZE + (path_len); | ||
} | ||||
|
r45916 | Ok((parents, entries, copies)) | ||
|
r42617 | } | ||
|
r42993 | /// `now` is the duration in seconds since the Unix epoch | ||
|
r42617 | pub fn pack_dirstate( | ||
|
r42993 | state_map: &mut StateMap, | ||
copy_map: &CopyMap, | ||||
|
r42617 | parents: DirstateParents, | ||
|
r42993 | now: Duration, | ||
) -> Result<Vec<u8>, DirstatePackError> { | ||||
// TODO move away from i32 before 2038. | ||||
let now: i32 = now.as_secs().try_into().expect("time overflow"); | ||||
|
r42617 | |||
|
r42993 | let expected_size: usize = state_map | ||
|
r42617 | .iter() | ||
|
r42993 | .map(|(filename, _)| { | ||
|
r42617 | let mut length = MIN_ENTRY_SIZE + filename.len(); | ||
|
r43062 | if let Some(copy) = copy_map.get(filename) { | ||
|
r42617 | length += copy.len() + 1; | ||
} | ||||
length | ||||
}) | ||||
.sum(); | ||||
let expected_size = expected_size + PARENT_SIZE * 2; | ||||
let mut packed = Vec::with_capacity(expected_size); | ||||
|
r42993 | let mut new_state_map = vec![]; | ||
|
r42617 | |||
|
r42993 | packed.extend(&parents.p1); | ||
packed.extend(&parents.p2); | ||||
|
r42617 | |||
|
r43062 | for (filename, entry) in state_map.iter() { | ||
|
r43227 | let new_filename = filename.to_owned(); | ||
|
r42617 | let mut new_mtime: i32 = entry.mtime; | ||
|
r42994 | if entry.state == EntryState::Normal && entry.mtime == now { | ||
|
r42617 | // 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; | ||||
|
r42993 | new_state_map.push(( | ||
|
r43062 | filename.to_owned(), | ||
|
r42617 | DirstateEntry { | ||
mtime: new_mtime, | ||||
..*entry | ||||
}, | ||||
)); | ||||
} | ||||
|
r43227 | let mut new_filename = new_filename.into_vec(); | ||
|
r43062 | if let Some(copy) = copy_map.get(filename) { | ||
|
r45500 | new_filename.push(b'\0'); | ||
|
r43227 | new_filename.extend(copy.bytes()); | ||
|
r42617 | } | ||
|
r42994 | packed.write_u8(entry.state.into())?; | ||
|
r42617 | packed.write_i32::<BigEndian>(entry.mode)?; | ||
packed.write_i32::<BigEndian>(entry.size)?; | ||||
packed.write_i32::<BigEndian>(new_mtime)?; | ||||
packed.write_i32::<BigEndian>(new_filename.len() as i32)?; | ||||
packed.extend(new_filename) | ||||
} | ||||
if packed.len() != expected_size { | ||||
return Err(DirstatePackError::BadSize(expected_size, packed.len())); | ||||
} | ||||
|
r42993 | state_map.extend(new_state_map); | ||
Ok(packed) | ||||
|
r42617 | } | ||
#[cfg(test)] | ||||
mod tests { | ||||
use super::*; | ||||
|
r44278 | use crate::{utils::hg_path::HgPathBuf, FastHashMap}; | ||
|
r42617 | |||
#[test] | ||||
fn test_pack_dirstate_empty() { | ||||
|
r44278 | let mut state_map: StateMap = FastHashMap::default(); | ||
let copymap = FastHashMap::default(); | ||||
|
r42617 | let parents = DirstateParents { | ||
|
r42993 | p1: *b"12345678910111213141", | ||
p2: *b"00000000000000000000", | ||||
|
r42617 | }; | ||
|
r42993 | let now = Duration::new(15000000, 0); | ||
let expected = b"1234567891011121314100000000000000000000".to_vec(); | ||||
|
r42617 | |||
assert_eq!( | ||||
expected, | ||||
|
r42993 | pack_dirstate(&mut state_map, ©map, parents, now).unwrap() | ||
|
r42617 | ); | ||
|
r42993 | |||
assert!(state_map.is_empty()) | ||||
|
r42617 | } | ||
#[test] | ||||
fn test_pack_dirstate_one_entry() { | ||||
|
r42993 | let expected_state_map: StateMap = [( | ||
|
r43227 | HgPathBuf::from_bytes(b"f1"), | ||
|
r42617 | DirstateEntry { | ||
|
r42994 | state: EntryState::Normal, | ||
|
r42617 | mode: 0o644, | ||
size: 0, | ||||
mtime: 791231220, | ||||
}, | ||||
|
r42993 | )] | ||
.iter() | ||||
.cloned() | ||||
.collect(); | ||||
let mut state_map = expected_state_map.clone(); | ||||
|
r44278 | let copymap = FastHashMap::default(); | ||
|
r42617 | let parents = DirstateParents { | ||
|
r42993 | p1: *b"12345678910111213141", | ||
p2: *b"00000000000000000000", | ||||
|
r42617 | }; | ||
|
r42993 | 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(); | ||||
|
r42617 | |||
assert_eq!( | ||||
expected, | ||||
|
r42993 | pack_dirstate(&mut state_map, ©map, parents, now).unwrap() | ||
|
r42617 | ); | ||
|
r42993 | assert_eq!(expected_state_map, state_map); | ||
} | ||||
|
r42617 | #[test] | ||
|
r42993 | fn test_pack_dirstate_one_entry_with_copy() { | ||
let expected_state_map: StateMap = [( | ||||
|
r43227 | HgPathBuf::from_bytes(b"f1"), | ||
|
r42617 | DirstateEntry { | ||
|
r42994 | state: EntryState::Normal, | ||
|
r42617 | mode: 0o644, | ||
size: 0, | ||||
mtime: 791231220, | ||||
}, | ||||
|
r42993 | )] | ||
.iter() | ||||
.cloned() | ||||
.collect(); | ||||
let mut state_map = expected_state_map.clone(); | ||||
|
r44278 | let mut copymap = FastHashMap::default(); | ||
|
r43227 | copymap.insert( | ||
HgPathBuf::from_bytes(b"f1"), | ||||
HgPathBuf::from_bytes(b"copyname"), | ||||
); | ||||
|
r42617 | let parents = DirstateParents { | ||
|
r42993 | p1: *b"12345678910111213141", | ||
p2: *b"00000000000000000000", | ||||
|
r42617 | }; | ||
|
r42993 | 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(); | ||||
|
r42617 | |||
assert_eq!( | ||||
|
r42993 | 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 = [( | ||||
|
r43227 | HgPathBuf::from_bytes(b"f1"), | ||
|
r42993 | DirstateEntry { | ||
|
r42994 | state: EntryState::Normal, | ||
|
r42993 | mode: 0o644, | ||
size: 0, | ||||
mtime: 791231220, | ||||
}, | ||||
)] | ||||
.iter() | ||||
.cloned() | ||||
.collect(); | ||||
|
r44278 | let mut copymap = FastHashMap::default(); | ||
|
r43227 | copymap.insert( | ||
HgPathBuf::from_bytes(b"f1"), | ||||
HgPathBuf::from_bytes(b"copyname"), | ||||
); | ||||
|
r42993 | let parents = DirstateParents { | ||
p1: *b"12345678910111213141", | ||||
p2: *b"00000000000000000000", | ||||
}; | ||||
let now = Duration::new(15000000, 0); | ||||
let result = | ||||
pack_dirstate(&mut state_map, ©map, parents.clone(), now) | ||||
.unwrap(); | ||||
|
r45916 | 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(); | ||||
|
r42993 | assert_eq!( | ||
(parents, state_map, copymap), | ||||
(new_parents, new_state_map, new_copy_map) | ||||
|
r42617 | ) | ||
} | ||||
#[test] | ||||
fn test_parse_pack_multiple_entries_with_copy() { | ||||
|
r42993 | let mut state_map: StateMap = [ | ||
|
r42617 | ( | ||
|
r43227 | HgPathBuf::from_bytes(b"f1"), | ||
|
r42617 | DirstateEntry { | ||
|
r42994 | state: EntryState::Normal, | ||
|
r42617 | mode: 0o644, | ||
size: 0, | ||||
mtime: 791231220, | ||||
}, | ||||
), | ||||
( | ||||
|
r43227 | HgPathBuf::from_bytes(b"f2"), | ||
|
r42617 | DirstateEntry { | ||
|
r42994 | state: EntryState::Merged, | ||
|
r42617 | mode: 0o777, | ||
size: 1000, | ||||
mtime: 791231220, | ||||
}, | ||||
), | ||||
( | ||||
|
r43227 | HgPathBuf::from_bytes(b"f3"), | ||
|
r42617 | DirstateEntry { | ||
|
r42994 | state: EntryState::Removed, | ||
|
r42617 | mode: 0o644, | ||
size: 234553, | ||||
mtime: 791231220, | ||||
}, | ||||
), | ||||
( | ||||
|
r43227 | HgPathBuf::from_bytes(b"f4\xF6"), | ||
|
r42617 | DirstateEntry { | ||
|
r42994 | state: EntryState::Added, | ||
|
r42617 | mode: 0o644, | ||
size: -1, | ||||
mtime: -1, | ||||
}, | ||||
), | ||||
|
r42993 | ] | ||
.iter() | ||||
.cloned() | ||||
.collect(); | ||||
|
r44278 | let mut copymap = FastHashMap::default(); | ||
|
r43227 | 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"), | ||||
); | ||||
|
r42617 | let parents = DirstateParents { | ||
|
r42993 | p1: *b"12345678910111213141", | ||
p2: *b"00000000000000000000", | ||||
|
r42617 | }; | ||
|
r42993 | let now = Duration::new(15000000, 0); | ||
|
r42617 | let result = | ||
|
r42993 | pack_dirstate(&mut state_map, ©map, parents.clone(), now) | ||
.unwrap(); | ||||
|
r42617 | |||
|
r45916 | 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(); | ||||
|
r42617 | assert_eq!( | ||
|
r42993 | (parents, state_map, copymap), | ||
(new_parents, new_state_map, new_copy_map) | ||||
|
r42617 | ) | ||
} | ||||
#[test] | ||||
/// https://www.mercurial-scm.org/repo/hg/rev/af3f26b6bba4 | ||||
fn test_parse_pack_one_entry_with_copy_and_time_conflict() { | ||||
|
r42993 | let mut state_map: StateMap = [( | ||
|
r43227 | HgPathBuf::from_bytes(b"f1"), | ||
|
r42617 | DirstateEntry { | ||
|
r42994 | state: EntryState::Normal, | ||
|
r42617 | mode: 0o644, | ||
size: 0, | ||||
mtime: 15000000, | ||||
}, | ||||
|
r42993 | )] | ||
.iter() | ||||
.cloned() | ||||
.collect(); | ||||
|
r44278 | let mut copymap = FastHashMap::default(); | ||
|
r43227 | copymap.insert( | ||
HgPathBuf::from_bytes(b"f1"), | ||||
HgPathBuf::from_bytes(b"copyname"), | ||||
); | ||||
|
r42617 | let parents = DirstateParents { | ||
|
r42993 | p1: *b"12345678910111213141", | ||
p2: *b"00000000000000000000", | ||||
|
r42617 | }; | ||
|
r42993 | let now = Duration::new(15000000, 0); | ||
|
r42617 | let result = | ||
|
r42993 | pack_dirstate(&mut state_map, ©map, parents.clone(), now) | ||
.unwrap(); | ||||
|
r45916 | 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(); | ||||
|
r42617 | |||
assert_eq!( | ||||
( | ||||
parents, | ||||
|
r42993 | [( | ||
|
r43227 | HgPathBuf::from_bytes(b"f1"), | ||
|
r42617 | DirstateEntry { | ||
|
r42994 | state: EntryState::Normal, | ||
|
r42617 | mode: 0o644, | ||
size: 0, | ||||
mtime: -1 | ||||
} | ||||
|
r42993 | )] | ||
.iter() | ||||
.cloned() | ||||
.collect::<StateMap>(), | ||||
copymap, | ||||
|
r42617 | ), | ||
|
r42993 | (new_parents, new_state_map, new_copy_map) | ||
|
r42617 | ) | ||
} | ||||
} | ||||