( )⚙ 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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 28100

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