For now, the format is the same except with an additional marker at the start.
This marker is redundant: for existing repositories it is .hg/requires that
determines which format to use. For new repositories, it is the new
format.exp-dirstate-v2 config. There is no upgrade or downgrade so far.
Most of the changes are about plumbing a boolean through layers of APIs to
indicate which format should be used.
| No Linters Available |
| No Unit Test Coverage |
| Path | Packages | |||
|---|---|---|---|---|
| M | hgext/largefiles/lfutil.py (3 lines) | |||
| M | mercurial/dirstate.py (43 lines) | |||
| M | mercurial/interfaces/dirstate.py (10 lines) | |||
| M | mercurial/localrepo.py (3 lines) | |||
| M | rust/hg-core/src/dirstate_tree.rs (1 line) | |||
| M | rust/hg-core/src/dirstate_tree/dirstate_map.rs (59 lines) | |||
| M | rust/hg-core/src/dirstate_tree/dispatch.rs (20 lines) | |||
| A | M | rust/hg-core/src/dirstate_tree/on_disk.rs (4 lines) | ||
| M | rust/hg-cpython/src/dirstate.rs (2 lines) | |||
| M | rust/hg-cpython/src/dirstate/dirstate_map.rs (23 lines) | |||
| M | rust/hg-cpython/src/dirstate/dispatch.rs (12 lines) | |||
| M | rust/hg-cpython/src/dirstate/owning.rs (7 lines) |
| Commit | Parents | Author | Summary | Date |
|---|---|---|---|---|
| 300d20b0d103 | 2008b3fa3fcd | Simon Sapin | May 3 2021, 2:07 PM |
| Status | Author | Revision | |
|---|---|---|---|
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin |
| from mercurial import ( | from mercurial import ( | ||||
| dirstate, | dirstate, | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| httpconnection, | httpconnection, | ||||
| match as matchmod, | match as matchmod, | ||||
| pycompat, | pycompat, | ||||
| requirements, | |||||
| scmutil, | scmutil, | ||||
| sparse, | sparse, | ||||
| util, | util, | ||||
| vfs as vfsmod, | vfs as vfsmod, | ||||
| ) | ) | ||||
| from mercurial.utils import hashutil | from mercurial.utils import hashutil | ||||
| shortname = b'.hglf' | shortname = b'.hglf' | ||||
| def openlfdirstate(ui, repo, create=True): | def openlfdirstate(ui, repo, create=True): | ||||
| """ | """ | ||||
| Return a dirstate object that tracks largefiles: i.e. its root is | Return a dirstate object that tracks largefiles: i.e. its root is | ||||
| the repo root, but it is saved in .hg/largefiles/dirstate. | the repo root, but it is saved in .hg/largefiles/dirstate. | ||||
| """ | """ | ||||
| vfs = repo.vfs | vfs = repo.vfs | ||||
| lfstoredir = longname | lfstoredir = longname | ||||
| opener = vfsmod.vfs(vfs.join(lfstoredir)) | opener = vfsmod.vfs(vfs.join(lfstoredir)) | ||||
| use_dirstate_v2 = requirements.DIRSTATE_V2_REQUIREMENT in repo.requirements | |||||
| lfdirstate = largefilesdirstate( | lfdirstate = largefilesdirstate( | ||||
| opener, | opener, | ||||
| ui, | ui, | ||||
| repo.root, | repo.root, | ||||
| repo.dirstate._validate, | repo.dirstate._validate, | ||||
| lambda: sparse.matcher(repo), | lambda: sparse.matcher(repo), | ||||
| repo.nodeconstants, | repo.nodeconstants, | ||||
| use_dirstate_v2, | |||||
| ) | ) | ||||
| # If the largefiles dirstate does not exist, populate and create | # If the largefiles dirstate does not exist, populate and create | ||||
| # it. This ensures that we create it on the first meaningful | # it. This ensures that we create it on the first meaningful | ||||
| # largefiles operation in a new clone. | # largefiles operation in a new clone. | ||||
| if create and not vfs.exists(vfs.join(lfstoredir, b'dirstate')): | if create and not vfs.exists(vfs.join(lfstoredir, b'dirstate')): | ||||
| matcher = getstandinmatcher(repo) | matcher = getstandinmatcher(repo) | ||||
| standins = repo.dirstate.walk( | standins = repo.dirstate.walk( | ||||
| finally: | finally: | ||||
| os.close(tmpfd) | os.close(tmpfd) | ||||
| vfs.unlink(tmpname) | vfs.unlink(tmpname) | ||||
| @interfaceutil.implementer(intdirstate.idirstate) | @interfaceutil.implementer(intdirstate.idirstate) | ||||
| class dirstate(object): | class dirstate(object): | ||||
| def __init__( | def __init__( | ||||
| self, opener, ui, root, validate, sparsematchfn, nodeconstants | self, | ||||
| opener, | |||||
| ui, | |||||
| root, | |||||
| validate, | |||||
| sparsematchfn, | |||||
| nodeconstants, | |||||
| use_dirstate_v2, | |||||
| ): | ): | ||||
| """Create a new dirstate object. | """Create a new dirstate object. | ||||
| opener is an open()-like callable that can be used to open the | opener is an open()-like callable that can be used to open the | ||||
| dirstate file; root is the root of the directory tracked by | dirstate file; root is the root of the directory tracked by | ||||
| the dirstate. | the dirstate. | ||||
| """ | """ | ||||
| self._use_dirstate_v2 = use_dirstate_v2 | |||||
| self._nodeconstants = nodeconstants | self._nodeconstants = nodeconstants | ||||
| self._opener = opener | self._opener = opener | ||||
| self._validate = validate | self._validate = validate | ||||
| self._root = root | self._root = root | ||||
| self._sparsematchfn = sparsematchfn | self._sparsematchfn = sparsematchfn | ||||
| # ntpath.join(root, '') of Python 2.7.9 does not add sep if root is | # ntpath.join(root, '') of Python 2.7.9 does not add sep if root is | ||||
| # UNC path pointing to root share (issue4557) | # UNC path pointing to root share (issue4557) | ||||
| self._rootdir = pathutil.normasprefix(root) | self._rootdir = pathutil.normasprefix(root) | ||||
| that modify the dirstate parent. | that modify the dirstate parent. | ||||
| """ | """ | ||||
| return self._parentwriters > 0 | return self._parentwriters > 0 | ||||
| @propertycache | @propertycache | ||||
| def _map(self): | def _map(self): | ||||
| """Return the dirstate contents (see documentation for dirstatemap).""" | """Return the dirstate contents (see documentation for dirstatemap).""" | ||||
| self._map = self._mapcls( | self._map = self._mapcls( | ||||
| self._ui, self._opener, self._root, self._nodeconstants | self._ui, | ||||
| self._opener, | |||||
| self._root, | |||||
| self._nodeconstants, | |||||
| self._use_dirstate_v2, | |||||
| ) | ) | ||||
| return self._map | return self._map | ||||
| @property | @property | ||||
| def _sparsematcher(self): | def _sparsematcher(self): | ||||
| """The matcher for the sparse checkout. | """The matcher for the sparse checkout. | ||||
| The working directory may not include every file from a manifest. The | The working directory may not include every file from a manifest. The | ||||
| - `filefoldmap` is a dict mapping normalized filenames to the denormalized | - `filefoldmap` is a dict mapping normalized filenames to the denormalized | ||||
| form that they appear as in the dirstate. | form that they appear as in the dirstate. | ||||
| - `dirfoldmap` is a dict mapping normalized directory names to the | - `dirfoldmap` is a dict mapping normalized directory names to the | ||||
| denormalized form that they appear as in the dirstate. | denormalized form that they appear as in the dirstate. | ||||
| """ | """ | ||||
| def __init__(self, ui, opener, root, nodeconstants): | def __init__(self, ui, opener, root, nodeconstants, use_dirstate_v2): | ||||
| self._ui = ui | self._ui = ui | ||||
| self._opener = opener | self._opener = opener | ||||
| self._root = root | self._root = root | ||||
| self._filename = b'dirstate' | self._filename = b'dirstate' | ||||
| self._nodelen = 20 | self._nodelen = 20 | ||||
| self._nodeconstants = nodeconstants | self._nodeconstants = nodeconstants | ||||
| assert ( | |||||
| not use_dirstate_v2 | |||||
| ), "should have detected unsupported requirement" | |||||
| self._parents = None | self._parents = None | ||||
| self._dirtyparents = False | self._dirtyparents = False | ||||
| # for consistent view between _pl() and _read() invocations | # for consistent view between _pl() and _read() invocations | ||||
| self._pendingmode = None | self._pendingmode = None | ||||
| @propertycache | @propertycache | ||||
| for name in self._dirs: | for name in self._dirs: | ||||
| f[normcase(name)] = name | f[normcase(name)] = name | ||||
| return f | return f | ||||
| if rustmod is not None: | if rustmod is not None: | ||||
| class dirstatemap(object): | class dirstatemap(object): | ||||
| def __init__(self, ui, opener, root, nodeconstants): | def __init__(self, ui, opener, root, nodeconstants, use_dirstate_v2): | ||||
| self._use_dirstate_v2 = use_dirstate_v2 | |||||
| self._nodeconstants = nodeconstants | self._nodeconstants = nodeconstants | ||||
| self._ui = ui | self._ui = ui | ||||
| self._opener = opener | self._opener = opener | ||||
| self._root = root | self._root = root | ||||
| self._filename = b'dirstate' | self._filename = b'dirstate' | ||||
| self._nodelen = 20 | self._nodelen = 20 # Also update Rust code when changing this! | ||||
| self._parents = None | self._parents = None | ||||
| self._dirtyparents = False | self._dirtyparents = False | ||||
| # for consistent view between _pl() and _read() invocations | # for consistent view between _pl() and _read() invocations | ||||
| self._pendingmode = None | self._pendingmode = None | ||||
| def addfile(self, *args, **kwargs): | def addfile(self, *args, **kwargs): | ||||
| return self._rustmap.addfile(*args, **kwargs) | return self._rustmap.addfile(*args, **kwargs) | ||||
| return fp | return fp | ||||
| def setparents(self, p1, p2): | def setparents(self, p1, p2): | ||||
| self._parents = (p1, p2) | self._parents = (p1, p2) | ||||
| self._dirtyparents = True | self._dirtyparents = True | ||||
| def parents(self): | def parents(self): | ||||
| if not self._parents: | if not self._parents: | ||||
| if self._use_dirstate_v2: | |||||
| offset = len(rustmod.V2_FORMAT_MARKER) | |||||
| else: | |||||
| offset = 0 | |||||
| read_len = offset + self._nodelen * 2 | |||||
| try: | try: | ||||
| fp = self._opendirstatefile() | fp = self._opendirstatefile() | ||||
| st = fp.read(40) | st = fp.read(read_len) | ||||
| fp.close() | fp.close() | ||||
| except IOError as err: | except IOError as err: | ||||
| if err.errno != errno.ENOENT: | if err.errno != errno.ENOENT: | ||||
| raise | raise | ||||
| # File doesn't exist, so the current state is empty | # File doesn't exist, so the current state is empty | ||||
| st = b'' | st = b'' | ||||
| l = len(st) | l = len(st) | ||||
| if l == self._nodelen * 2: | if l == read_len: | ||||
| st = st[offset:] | |||||
| self._parents = ( | self._parents = ( | ||||
| st[: self._nodelen], | st[: self._nodelen], | ||||
| st[self._nodelen : 2 * self._nodelen], | st[self._nodelen : 2 * self._nodelen], | ||||
| ) | ) | ||||
| elif l == 0: | elif l == 0: | ||||
| self._parents = ( | self._parents = ( | ||||
| self._nodeconstants.nullid, | self._nodeconstants.nullid, | ||||
| self._nodeconstants.nullid, | self._nodeconstants.nullid, | ||||
| st = b'' | st = b'' | ||||
| use_dirstate_tree = self._ui.configbool( | use_dirstate_tree = self._ui.configbool( | ||||
| b"experimental", | b"experimental", | ||||
| b"dirstate-tree.in-memory", | b"dirstate-tree.in-memory", | ||||
| False, | False, | ||||
| ) | ) | ||||
| self._rustmap, parents = rustmod.DirstateMap.new( | self._rustmap, parents = rustmod.DirstateMap.new( | ||||
| use_dirstate_tree, st | use_dirstate_tree, self._use_dirstate_v2, st | ||||
| ) | ) | ||||
| if parents and not self._dirtyparents: | if parents and not self._dirtyparents: | ||||
| self.setparents(*parents) | self.setparents(*parents) | ||||
| self.__contains__ = self._rustmap.__contains__ | self.__contains__ = self._rustmap.__contains__ | ||||
| self.__getitem__ = self._rustmap.__getitem__ | self.__getitem__ = self._rustmap.__getitem__ | ||||
| self.get = self._rustmap.get | self.get = self._rustmap.get | ||||
| return self._rustmap | return self._rustmap | ||||
| def write(self, st, now): | def write(self, st, now): | ||||
| parents = self.parents() | parents = self.parents() | ||||
| st.write(self._rustmap.write(parents[0], parents[1], now)) | packed = self._rustmap.write( | ||||
| self._use_dirstate_v2, parents[0], parents[1], now | |||||
| ) | |||||
| st.write(packed) | |||||
| st.close() | st.close() | ||||
| self._dirtyparents = False | self._dirtyparents = False | ||||
| @propertycache | @propertycache | ||||
| def filefoldmap(self): | def filefoldmap(self): | ||||
| """Returns a dictionary mapping normalized case paths to their | """Returns a dictionary mapping normalized case paths to their | ||||
| non-normalized versions. | non-normalized versions. | ||||
| """ | """ | ||||
| from __future__ import absolute_import, print_function | from __future__ import absolute_import, print_function | ||||
| import contextlib | import contextlib | ||||
| from . import util as interfaceutil | from . import util as interfaceutil | ||||
| class idirstate(interfaceutil.Interface): | class idirstate(interfaceutil.Interface): | ||||
| def __init__(opener, ui, root, validate, sparsematchfn, nodeconstants): | def __init__( | ||||
| opener, | |||||
| ui, | |||||
| root, | |||||
| validate, | |||||
| sparsematchfn, | |||||
| nodeconstants, | |||||
| use_dirstate_v2, | |||||
| ): | |||||
| """Create a new dirstate object. | """Create a new dirstate object. | ||||
| opener is an open()-like callable that can be used to open the | opener is an open()-like callable that can be used to open the | ||||
| dirstate file; root is the root of the directory tracked by | dirstate file; root is the root of the directory tracked by | ||||
| the dirstate. | the dirstate. | ||||
| """ | """ | ||||
| # TODO: all these private methods and attributes should be made | # TODO: all these private methods and attributes should be made | ||||
| @repofilecache(b'dirstate') | @repofilecache(b'dirstate') | ||||
| def dirstate(self): | def dirstate(self): | ||||
| return self._makedirstate() | return self._makedirstate() | ||||
| def _makedirstate(self): | def _makedirstate(self): | ||||
| """Extension point for wrapping the dirstate per-repo.""" | """Extension point for wrapping the dirstate per-repo.""" | ||||
| sparsematchfn = lambda: sparse.matcher(self) | sparsematchfn = lambda: sparse.matcher(self) | ||||
| v2_req = requirementsmod.DIRSTATE_V2_REQUIREMENT | |||||
| use_dirstate_v2 = v2_req in self.requirements | |||||
| return dirstate.dirstate( | return dirstate.dirstate( | ||||
| self.vfs, | self.vfs, | ||||
| self.ui, | self.ui, | ||||
| self.root, | self.root, | ||||
| self._dirstatevalidate, | self._dirstatevalidate, | ||||
| sparsematchfn, | sparsematchfn, | ||||
| self.nodeconstants, | self.nodeconstants, | ||||
| use_dirstate_v2, | |||||
| ) | ) | ||||
| def _dirstatevalidate(self, node): | def _dirstatevalidate(self, node): | ||||
| try: | try: | ||||
| self.changelog.rev(node) | self.changelog.rev(node) | ||||
| return node | return node | ||||
| except error.LookupError: | except error.LookupError: | ||||
| if not self._dirstatevalidatewarned: | if not self._dirstatevalidatewarned: | ||||
| pub mod dirstate_map; | pub mod dirstate_map; | ||||
| pub mod dispatch; | pub mod dispatch; | ||||
| pub mod on_disk; | |||||
| pub mod path_with_basename; | pub mod path_with_basename; | ||||
| mod status; | mod status; | ||||
| use bytes_cast::BytesCast; | use bytes_cast::BytesCast; | ||||
| use micro_timer::timed; | use micro_timer::timed; | ||||
| use std::borrow::Cow; | use std::borrow::Cow; | ||||
| use std::convert::TryInto; | use std::convert::TryInto; | ||||
| use std::path::PathBuf; | use std::path::PathBuf; | ||||
| use super::on_disk::V2_FORMAT_MARKER; | |||||
| use super::path_with_basename::WithBasename; | use super::path_with_basename::WithBasename; | ||||
| use crate::dirstate::parsers::clear_ambiguous_mtime; | use crate::dirstate::parsers::clear_ambiguous_mtime; | ||||
| use crate::dirstate::parsers::pack_entry; | use crate::dirstate::parsers::pack_entry; | ||||
| use crate::dirstate::parsers::packed_entry_size; | use crate::dirstate::parsers::packed_entry_size; | ||||
| use crate::dirstate::parsers::parse_dirstate_entries; | use crate::dirstate::parsers::parse_dirstate_entries; | ||||
| use crate::dirstate::parsers::Timestamp; | use crate::dirstate::parsers::Timestamp; | ||||
| use crate::errors::HgError; | |||||
| use crate::matchers::Matcher; | use crate::matchers::Matcher; | ||||
| use crate::utils::hg_path::{HgPath, HgPathBuf}; | use crate::utils::hg_path::{HgPath, HgPathBuf}; | ||||
| use crate::utils::SliceExt; | |||||
| use crate::CopyMapIter; | use crate::CopyMapIter; | ||||
| use crate::DirstateEntry; | use crate::DirstateEntry; | ||||
| use crate::DirstateError; | use crate::DirstateError; | ||||
| use crate::DirstateMapError; | use crate::DirstateMapError; | ||||
| use crate::DirstateParents; | use crate::DirstateParents; | ||||
| use crate::DirstateStatus; | use crate::DirstateStatus; | ||||
| use crate::EntryState; | use crate::EntryState; | ||||
| use crate::FastHashMap; | use crate::FastHashMap; | ||||
| /// `(full_path, entry, copy_source)` | /// `(full_path, entry, copy_source)` | ||||
| type NodeDataMut<'tree, 'on_disk> = ( | type NodeDataMut<'tree, 'on_disk> = ( | ||||
| &'tree HgPath, | &'tree HgPath, | ||||
| &'tree mut Option<DirstateEntry>, | &'tree mut Option<DirstateEntry>, | ||||
| &'tree mut Option<Cow<'on_disk, HgPath>>, | &'tree mut Option<Cow<'on_disk, HgPath>>, | ||||
| ); | ); | ||||
| impl<'on_disk> DirstateMap<'on_disk> { | impl<'on_disk> DirstateMap<'on_disk> { | ||||
| pub fn new( | #[timed] | ||||
| pub fn new_v2( | |||||
| on_disk: &'on_disk [u8], | |||||
| ) -> Result<(Self, Option<DirstateParents>), DirstateError> { | |||||
| if let Some(rest) = on_disk.drop_prefix(V2_FORMAT_MARKER) { | |||||
| Self::new_v1(rest) | |||||
| } else if on_disk.is_empty() { | |||||
| Self::new_v1(on_disk) | |||||
| } else { | |||||
| return Err(HgError::corrupted( | |||||
| "missing dirstate-v2 magic number", | |||||
| ) | |||||
| .into()); | |||||
| } | |||||
| } | |||||
| #[timed] | |||||
| pub fn new_v1( | |||||
| on_disk: &'on_disk [u8], | on_disk: &'on_disk [u8], | ||||
| ) -> Result<(Self, Option<DirstateParents>), DirstateError> { | ) -> Result<(Self, Option<DirstateParents>), DirstateError> { | ||||
| let mut map = Self { | let mut map = Self { | ||||
| on_disk, | on_disk, | ||||
| root: ChildNodes::default(), | root: ChildNodes::default(), | ||||
| nodes_with_entry_count: 0, | nodes_with_entry_count: 0, | ||||
| nodes_with_copy_source_count: 0, | nodes_with_copy_source_count: 0, | ||||
| }; | }; | ||||
| let parents = map.read()?; | if map.on_disk.is_empty() { | ||||
| Ok((map, parents)) | return Ok((map, None)); | ||||
| } | |||||
| /// Should only be called in `new` | |||||
| #[timed] | |||||
| fn read(&mut self) -> Result<Option<DirstateParents>, DirstateError> { | |||||
| if self.on_disk.is_empty() { | |||||
| return Ok(None); | |||||
| } | } | ||||
| let parents = parse_dirstate_entries( | let parents = parse_dirstate_entries( | ||||
| self.on_disk, | map.on_disk, | ||||
| |path, entry, copy_source| { | |path, entry, copy_source| { | ||||
| let tracked = entry.state.is_tracked(); | let tracked = entry.state.is_tracked(); | ||||
| let node = Self::get_or_insert_node( | let node = Self::get_or_insert_node( | ||||
| &mut self.root, | &mut map.root, | ||||
| path, | path, | ||||
| WithBasename::to_cow_borrowed, | WithBasename::to_cow_borrowed, | ||||
| |ancestor| { | |ancestor| { | ||||
| if tracked { | if tracked { | ||||
| ancestor.tracked_descendants_count += 1 | ancestor.tracked_descendants_count += 1 | ||||
| } | } | ||||
| }, | }, | ||||
| ); | ); | ||||
| assert!( | assert!( | ||||
| node.entry.is_none(), | node.entry.is_none(), | ||||
| "duplicate dirstate entry in read" | "duplicate dirstate entry in read" | ||||
| ); | ); | ||||
| assert!( | assert!( | ||||
| node.copy_source.is_none(), | node.copy_source.is_none(), | ||||
| "duplicate dirstate entry in read" | "duplicate dirstate entry in read" | ||||
| ); | ); | ||||
| node.entry = Some(*entry); | node.entry = Some(*entry); | ||||
| node.copy_source = copy_source.map(Cow::Borrowed); | node.copy_source = copy_source.map(Cow::Borrowed); | ||||
| self.nodes_with_entry_count += 1; | map.nodes_with_entry_count += 1; | ||||
| if copy_source.is_some() { | if copy_source.is_some() { | ||||
| self.nodes_with_copy_source_count += 1 | map.nodes_with_copy_source_count += 1 | ||||
| } | } | ||||
| }, | }, | ||||
| )?; | )?; | ||||
| let parents = Some(parents.clone()); | |||||
| Ok(Some(parents.clone())) | Ok((map, parents)) | ||||
| } | } | ||||
| fn get_node(&self, path: &HgPath) -> Option<&Node> { | fn get_node(&self, path: &HgPath) -> Option<&Node> { | ||||
| let mut children = &self.root; | let mut children = &self.root; | ||||
| let mut components = path.components(); | let mut components = path.components(); | ||||
| let mut component = | let mut component = | ||||
| components.next().expect("expected at least one components"); | components.next().expect("expected at least one components"); | ||||
| loop { | loop { | ||||
| // A node without a `DirstateEntry` was created to hold child | // A node without a `DirstateEntry` was created to hold child | ||||
| // nodes, and is therefore a directory. | // nodes, and is therefore a directory. | ||||
| Ok(node.entry.is_none()) | Ok(node.entry.is_none()) | ||||
| } else { | } else { | ||||
| Ok(false) | Ok(false) | ||||
| } | } | ||||
| } | } | ||||
| fn pack( | #[timed] | ||||
| fn pack_v1( | |||||
| &mut self, | &mut self, | ||||
| parents: DirstateParents, | parents: DirstateParents, | ||||
| now: Timestamp, | now: Timestamp, | ||||
| ) -> Result<Vec<u8>, DirstateError> { | ) -> Result<Vec<u8>, DirstateError> { | ||||
| // Optizimation (to be measured?): pre-compute size to avoid `Vec` | // Optizimation (to be measured?): pre-compute size to avoid `Vec` | ||||
| // reallocations | // reallocations | ||||
| let mut size = parents.as_bytes().len(); | let mut size = parents.as_bytes().len(); | ||||
| for (path, node) in self.iter_nodes() { | for (path, node) in self.iter_nodes() { | ||||
| copy_source.as_ref().map(|p| &**p), | copy_source.as_ref().map(|p| &**p), | ||||
| &mut packed, | &mut packed, | ||||
| ); | ); | ||||
| } | } | ||||
| } | } | ||||
| Ok(packed) | Ok(packed) | ||||
| } | } | ||||
| #[timed] | |||||
| fn pack_v2( | |||||
| &mut self, | |||||
| parents: DirstateParents, | |||||
| now: Timestamp, | |||||
| ) -> Result<Vec<u8>, DirstateError> { | |||||
| // Inefficient but temporary | |||||
| let mut v2 = V2_FORMAT_MARKER.to_vec(); | |||||
| v2.append(&mut self.pack_v1(parents, now)?); | |||||
| Ok(v2) | |||||
| } | |||||
| fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> { | fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> { | ||||
| // Do nothing, this `DirstateMap` does not a separate `all_dirs` that | // Do nothing, this `DirstateMap` does not a separate `all_dirs` that | ||||
| // needs to be recomputed | // needs to be recomputed | ||||
| Ok(()) | Ok(()) | ||||
| } | } | ||||
| fn set_dirs(&mut self) -> Result<(), DirstateMapError> { | fn set_dirs(&mut self) -> Result<(), DirstateMapError> { | ||||
| // Do nothing, this `DirstateMap` does not a separate `dirs` that needs | // Do nothing, this `DirstateMap` does not a separate `dirs` that needs | ||||
| directory: &HgPath, | directory: &HgPath, | ||||
| ) -> Result<bool, DirstateMapError>; | ) -> Result<bool, DirstateMapError>; | ||||
| fn has_dir( | fn has_dir( | ||||
| &mut self, | &mut self, | ||||
| directory: &HgPath, | directory: &HgPath, | ||||
| ) -> Result<bool, DirstateMapError>; | ) -> Result<bool, DirstateMapError>; | ||||
| fn pack( | fn pack_v1( | ||||
| &mut self, | |||||
| parents: DirstateParents, | |||||
| now: Timestamp, | |||||
| ) -> Result<Vec<u8>, DirstateError>; | |||||
| fn pack_v2( | |||||
| &mut self, | &mut self, | ||||
| parents: DirstateParents, | parents: DirstateParents, | ||||
| now: Timestamp, | now: Timestamp, | ||||
| ) -> Result<Vec<u8>, DirstateError>; | ) -> Result<Vec<u8>, DirstateError>; | ||||
| fn set_all_dirs(&mut self) -> Result<(), DirstateMapError>; | fn set_all_dirs(&mut self) -> Result<(), DirstateMapError>; | ||||
| fn set_dirs(&mut self) -> Result<(), DirstateMapError>; | fn set_dirs(&mut self) -> Result<(), DirstateMapError>; | ||||
| fn has_dir( | fn has_dir( | ||||
| &mut self, | &mut self, | ||||
| directory: &HgPath, | directory: &HgPath, | ||||
| ) -> Result<bool, DirstateMapError> { | ) -> Result<bool, DirstateMapError> { | ||||
| self.has_dir(directory) | self.has_dir(directory) | ||||
| } | } | ||||
| fn pack( | fn pack_v1( | ||||
| &mut self, | &mut self, | ||||
| parents: DirstateParents, | parents: DirstateParents, | ||||
| now: Timestamp, | now: Timestamp, | ||||
| ) -> Result<Vec<u8>, DirstateError> { | ) -> Result<Vec<u8>, DirstateError> { | ||||
| self.pack(parents, now) | self.pack(parents, now) | ||||
| } | } | ||||
| fn pack_v2( | |||||
| &mut self, | |||||
| _parents: DirstateParents, | |||||
| _now: Timestamp, | |||||
| ) -> Result<Vec<u8>, DirstateError> { | |||||
| panic!( | |||||
| "should have used dirstate_tree::DirstateMap to use the v2 format" | |||||
| ) | |||||
| } | |||||
| fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> { | fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> { | ||||
| self.set_all_dirs() | self.set_all_dirs() | ||||
| } | } | ||||
| fn set_dirs(&mut self) -> Result<(), DirstateMapError> { | fn set_dirs(&mut self) -> Result<(), DirstateMapError> { | ||||
| self.set_dirs() | self.set_dirs() | ||||
| } | } | ||||
| /// Added at the start of `.hg/dirstate` when the "v2" format is used. | |||||
| /// Acts like a "magic number". This is a sanity check, not strictly necessary | |||||
| /// since `.hg/requires` already governs which format should be used. | |||||
| pub const V2_FORMAT_MARKER: &[u8; 12] = b"dirstate-v2\n"; | |||||
| dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper, | dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper, | ||||
| }, | }, | ||||
| exceptions, | exceptions, | ||||
| }; | }; | ||||
| use cpython::{ | use cpython::{ | ||||
| exc, PyBytes, PyDict, PyErr, PyList, PyModule, PyObject, PyResult, | exc, PyBytes, PyDict, PyErr, PyList, PyModule, PyObject, PyResult, | ||||
| PySequence, Python, | PySequence, Python, | ||||
| }; | }; | ||||
| use hg::dirstate_tree::on_disk::V2_FORMAT_MARKER; | |||||
| use hg::{utils::hg_path::HgPathBuf, DirstateEntry, EntryState, StateMap}; | use hg::{utils::hg_path::HgPathBuf, DirstateEntry, EntryState, StateMap}; | ||||
| use libc::{c_char, c_int}; | use libc::{c_char, c_int}; | ||||
| use std::convert::TryFrom; | use std::convert::TryFrom; | ||||
| // C code uses a custom `dirstate_tuple` type, checks in multiple instances | // C code uses a custom `dirstate_tuple` type, checks in multiple instances | ||||
| // for this type, and raises a Python `Exception` if the check does not pass. | // for this type, and raises a Python `Exception` if the check does not pass. | ||||
| // Because this type differs only in name from the regular Python tuple, it | // Because this type differs only in name from the regular Python tuple, it | ||||
| // would be a good idea in the near future to remove it entirely to allow | // would be a good idea in the near future to remove it entirely to allow | ||||
| m.add( | m.add( | ||||
| py, | py, | ||||
| "FallbackError", | "FallbackError", | ||||
| py.get_type::<exceptions::FallbackError>(), | py.get_type::<exceptions::FallbackError>(), | ||||
| )?; | )?; | ||||
| m.add_class::<Dirs>(py)?; | m.add_class::<Dirs>(py)?; | ||||
| m.add_class::<DirstateMap>(py)?; | m.add_class::<DirstateMap>(py)?; | ||||
| m.add(py, "V2_FORMAT_MARKER", PyBytes::new(py, V2_FORMAT_MARKER))?; | |||||
| m.add( | m.add( | ||||
| py, | py, | ||||
| "status", | "status", | ||||
| py_fn!( | py_fn!( | ||||
| py, | py, | ||||
| status_wrapper( | status_wrapper( | ||||
| dmap: DirstateMap, | dmap: DirstateMap, | ||||
| root_dir: PyObject, | root_dir: PyObject, | ||||
| // `RustDirstateMap`, rightfully so. | // `RustDirstateMap`, rightfully so. | ||||
| // All attributes also have to have a separate refcount data attribute for | // All attributes also have to have a separate refcount data attribute for | ||||
| // leaks, with all methods that go along for reference sharing. | // leaks, with all methods that go along for reference sharing. | ||||
| py_class!(pub class DirstateMap |py| { | py_class!(pub class DirstateMap |py| { | ||||
| @shared data inner: Box<dyn DirstateMapMethods + Send>; | @shared data inner: Box<dyn DirstateMapMethods + Send>; | ||||
| /// Returns a `(dirstate_map, parents)` tuple | /// Returns a `(dirstate_map, parents)` tuple | ||||
| @staticmethod | @staticmethod | ||||
| def new(use_dirstate_tree: bool, on_disk: PyBytes) -> PyResult<PyObject> { | def new( | ||||
| let dirstate_error = |_: DirstateError| { | use_dirstate_tree: bool, | ||||
| PyErr::new::<exc::OSError, _>(py, "Dirstate error".to_string()) | use_dirstate_v2: bool, | ||||
| on_disk: PyBytes, | |||||
| ) -> PyResult<PyObject> { | |||||
| let dirstate_error = |e: DirstateError| { | |||||
| PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e)) | |||||
| }; | }; | ||||
| let (inner, parents) = if use_dirstate_tree { | let (inner, parents) = if use_dirstate_tree || use_dirstate_v2 { | ||||
| let (map, parents) = | let (map, parents) = | ||||
| OwningDirstateMap::new(py, on_disk) | OwningDirstateMap::new(py, on_disk, use_dirstate_v2) | ||||
| .map_err(dirstate_error)?; | .map_err(dirstate_error)?; | ||||
| (Box::new(map) as _, parents) | (Box::new(map) as _, parents) | ||||
| } else { | } else { | ||||
| let bytes = on_disk.data(py); | let bytes = on_disk.data(py); | ||||
| let mut map = RustDirstateMap::default(); | let mut map = RustDirstateMap::default(); | ||||
| let parents = map.read(bytes).map_err(dirstate_error)?; | let parents = map.read(bytes).map_err(dirstate_error)?; | ||||
| (Box::new(map) as _, parents) | (Box::new(map) as _, parents) | ||||
| }; | }; | ||||
| .map_err(|e| { | .map_err(|e| { | ||||
| PyErr::new::<exc::ValueError, _>(py, e.to_string()) | PyErr::new::<exc::ValueError, _>(py, e.to_string()) | ||||
| })? | })? | ||||
| .to_py_object(py)) | .to_py_object(py)) | ||||
| } | } | ||||
| def write( | def write( | ||||
| &self, | &self, | ||||
| use_dirstate_v2: bool, | |||||
| p1: PyObject, | p1: PyObject, | ||||
| p2: PyObject, | p2: PyObject, | ||||
| now: PyObject | now: PyObject | ||||
| ) -> PyResult<PyBytes> { | ) -> PyResult<PyBytes> { | ||||
| let now = Timestamp(now.extract(py)?); | let now = Timestamp(now.extract(py)?); | ||||
| let parents = DirstateParents { | let parents = DirstateParents { | ||||
| p1: extract_node_id(py, &p1)?, | p1: extract_node_id(py, &p1)?, | ||||
| p2: extract_node_id(py, &p2)?, | p2: extract_node_id(py, &p2)?, | ||||
| }; | }; | ||||
| match self.inner(py).borrow_mut().pack(parents, now) { | let mut inner = self.inner(py).borrow_mut(); | ||||
| let result = if use_dirstate_v2 { | |||||
| inner.pack_v2(parents, now) | |||||
| } else { | |||||
| inner.pack_v1(parents, now) | |||||
| }; | |||||
| match result { | |||||
| Ok(packed) => Ok(PyBytes::new(py, &packed)), | Ok(packed) => Ok(PyBytes::new(py, &packed)), | ||||
| Err(_) => Err(PyErr::new::<exc::OSError, _>( | Err(_) => Err(PyErr::new::<exc::OSError, _>( | ||||
| py, | py, | ||||
| "Dirstate error".to_string(), | "Dirstate error".to_string(), | ||||
| )), | )), | ||||
| } | } | ||||
| } | } | ||||
| fn has_dir( | fn has_dir( | ||||
| &mut self, | &mut self, | ||||
| directory: &HgPath, | directory: &HgPath, | ||||
| ) -> Result<bool, DirstateMapError> { | ) -> Result<bool, DirstateMapError> { | ||||
| self.get_mut().has_dir(directory) | self.get_mut().has_dir(directory) | ||||
| } | } | ||||
| fn pack( | fn pack_v1( | ||||
| &mut self, | &mut self, | ||||
| parents: DirstateParents, | parents: DirstateParents, | ||||
| now: Timestamp, | now: Timestamp, | ||||
| ) -> Result<Vec<u8>, DirstateError> { | ) -> Result<Vec<u8>, DirstateError> { | ||||
| self.get_mut().pack(parents, now) | self.get_mut().pack_v1(parents, now) | ||||
| } | |||||
| fn pack_v2( | |||||
| &mut self, | |||||
| parents: DirstateParents, | |||||
| now: Timestamp, | |||||
| ) -> Result<Vec<u8>, DirstateError> { | |||||
| self.get_mut().pack_v2(parents, now) | |||||
| } | } | ||||
| fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> { | fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> { | ||||
| self.get_mut().set_all_dirs() | self.get_mut().set_all_dirs() | ||||
| } | } | ||||
| fn set_dirs(&mut self) -> Result<(), DirstateMapError> { | fn set_dirs(&mut self) -> Result<(), DirstateMapError> { | ||||
| self.get_mut().set_dirs() | self.get_mut().set_dirs() | ||||
| /// by `PyBytes`) but touches similar borrow-checker limitations. | /// by `PyBytes`) but touches similar borrow-checker limitations. | ||||
| ptr: *mut (), | ptr: *mut (), | ||||
| } | } | ||||
| impl OwningDirstateMap { | impl OwningDirstateMap { | ||||
| pub fn new( | pub fn new( | ||||
| py: Python, | py: Python, | ||||
| on_disk: PyBytes, | on_disk: PyBytes, | ||||
| use_dirstate_v2: bool, | |||||
| ) -> Result<(Self, Option<DirstateParents>), DirstateError> { | ) -> Result<(Self, Option<DirstateParents>), DirstateError> { | ||||
| let bytes: &'_ [u8] = on_disk.data(py); | let bytes: &'_ [u8] = on_disk.data(py); | ||||
| let (map, parents) = DirstateMap::new(bytes)?; | let (map, parents) = if use_dirstate_v2 { | ||||
| DirstateMap::new_v2(bytes)? | |||||
| } else { | |||||
| DirstateMap::new_v1(bytes)? | |||||
| }; | |||||
| // Like in `bytes` above, this `'_` lifetime parameter borrows from | // Like in `bytes` above, this `'_` lifetime parameter borrows from | ||||
| // the bytes buffer owned by `on_disk`. | // the bytes buffer owned by `on_disk`. | ||||
| let ptr: *mut DirstateMap<'_> = Box::into_raw(Box::new(map)); | let ptr: *mut DirstateMap<'_> = Box::into_raw(Box::new(map)); | ||||
| // Erase the pointed type entirely in order to erase the lifetime. | // Erase the pointed type entirely in order to erase the lifetime. | ||||
| let ptr: *mut () = ptr.cast(); | let ptr: *mut () = ptr.cast(); | ||||