( )⚙ D10719 dirstate-v2: Change the on-disk format when the requirement is enabled

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10719

dirstate-v2: Change the on-disk format when the requirement is enabled
ClosedPublic

Authored by SimonSapin on May 17 2021, 6:05 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG1766130fe9ba: dirstate-v2: Change the on-disk format when the requirement is enabled
rHG300d20b0d103: dirstate-v2: Change the on-disk format when the requirement is enabled
Summary

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.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

SimonSapin created this revision.May 17 2021, 6:05 AM
baymax updated this revision to Diff 27999.May 17 2021, 8:39 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Alphare accepted this revision.May 19 2021, 5:52 AM
This revision is now accepted and ready to land.May 19 2021, 5:52 AM
baymax updated this revision to Diff 28100.May 19 2021, 7:41 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Revision Contents
Changeset List

Diff 28093

hgext/largefiles/lfutil.py

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(

mercurial/dirstate.py

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.
""" """

mercurial/interfaces/dirstate.py

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

mercurial/localrepo.py

@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:

rust/hg-core/src/dirstate_tree.rs

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;

rust/hg-core/src/dirstate_tree/dirstate_map.rs

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

rust/hg-core/src/dirstate_tree/dispatch.rs

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()
} }

rust/hg-core/src/dirstate_tree/on_disk.rs

  • This file was added.
/// 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";

rust/hg-cpython/src/dirstate.rs

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,

rust/hg-cpython/src/dirstate/dirstate_map.rs

// `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(),
)), )),
} }
} }

rust/hg-cpython/src/dirstate/dispatch.rs

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()

rust/hg-cpython/src/dirstate/owning.rs

/// 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();