( )⚙ D11621 dirstate: Move more methods to the _dirstatemapcommon base class

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11621

dirstate: Move more methods to the _dirstatemapcommon base class
ClosedPublic

Authored by SimonSapin on Oct 8 2021, 8:06 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGe7b5e8ba7cab: dirstate: Move more methods to the _dirstatemapcommon base class
Summary

This reduces duplication slightly and will help with supporting dirstate-v2
when Rust is not enabled.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

PathPackages
Mmercurial/dirstatemap.py (217 lines)

Diff 30758

mercurial/dirstatemap.py

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 # Also update Rust code when changing this! self._nodelen = 20 # Also update Rust code when changing this!
self._parents = None self._parents = None
self._dirtyparents = False self._dirtyparents = False
self._docket = None
# for consistent view between _pl() and _read() invocations # for consistent view between _pl() and _read() invocations
self._pendingmode = None self._pendingmode = None
def preload(self): def preload(self):
"""Loads the underlying data, if it's not already loaded""" """Loads the underlying data, if it's not already loaded"""
self._map self._map
wc_tracked=wc_tracked, wc_tracked=wc_tracked,
p1_tracked=p1_tracked, p1_tracked=p1_tracked,
p2_info=p2_info, p2_info=p2_info,
has_meaningful_mtime=has_meaningful_mtime, has_meaningful_mtime=has_meaningful_mtime,
parentfiledata=parentfiledata, parentfiledata=parentfiledata,
) )
self._insert_entry(filename, entry) self._insert_entry(filename, entry)
### disk interaction
def _opendirstatefile(self):
fp, mode = txnutil.trypending(self._root, self._opener, self._filename)
if self._pendingmode is not None and self._pendingmode != mode:
fp.close()
raise error.Abort(
_(b'working directory state may be changed parallelly')
)
self._pendingmode = mode
return fp
def _readdirstatefile(self, size=-1):
try:
with self._opendirstatefile() as fp:
return fp.read(size)
except IOError as err:
if err.errno != errno.ENOENT:
raise
# File doesn't exist, so the current state is empty
return b''
@property
def docket(self):
if not self._docket:
if not self._use_dirstate_v2:
raise error.ProgrammingError(
b'dirstate only has a docket in v2 format'
)
self._docket = docketmod.DirstateDocket.parse(
self._readdirstatefile(), self._nodeconstants
)
return self._docket
def write_v2_no_append(self, tr, st, meta, packed):
old_docket = self.docket
new_docket = docketmod.DirstateDocket.with_new_uuid(
self.parents(), len(packed), meta
)
data_filename = new_docket.data_filename()
if tr:
tr.add(data_filename, 0)
self._opener.write(data_filename, packed)
# Write the new docket after the new data file has been
# written. Because `st` was opened with `atomictemp=True`,
# the actual `.hg/dirstate` file is only affected on close.
st.write(new_docket.serialize())
st.close()
# Remove the old data file after the new docket pointing to
# the new data file was written.
if old_docket.uuid:
data_filename = old_docket.data_filename()
unlink = lambda _tr=None: self._opener.unlink(data_filename)
if tr:
category = b"dirstate-v2-clean-" + old_docket.uuid
tr.addpostclose(category, unlink)
else:
unlink()
self._docket = new_docket
### reading/setting parents
def parents(self):
if not self._parents:
if self._use_dirstate_v2:
self._parents = self.docket.parents
else:
read_len = self._nodelen * 2
st = self._readdirstatefile(read_len)
l = len(st)
if l == read_len:
self._parents = (
st[: self._nodelen],
st[self._nodelen : 2 * self._nodelen],
)
elif l == 0:
self._parents = (
self._nodeconstants.nullid,
self._nodeconstants.nullid,
)
else:
raise error.Abort(
_(b'working directory state appears damaged!')
)
return self._parents
class dirstatemap(_dirstatemapcommon): class dirstatemap(_dirstatemapcommon):
"""Map encapsulating the dirstate's contents. """Map encapsulating the dirstate's contents.
The dirstate contains the following state: The dirstate contains the following state:
- `identity` is the identity of the dirstate file, which can be used to - `identity` is the identity of the dirstate file, which can be used to
detect when changes have occurred to the dirstate file. detect when changes have occurred to the dirstate file.
for (filename, item) in self.items(): for (filename, item) in self.items():
yield (filename, item.state, item.mode, item.size, item.mtime) yield (filename, item.state, item.mode, item.size, item.mtime)
def keys(self): def keys(self):
return self._map.keys() return self._map.keys()
### reading/setting parents ### reading/setting parents
def parents(self):
if not self._parents:
try:
fp = self._opendirstatefile()
st = fp.read(2 * self._nodelen)
fp.close()
except IOError as err:
if err.errno != errno.ENOENT:
raise
# File doesn't exist, so the current state is empty
st = b''
l = len(st)
if l == self._nodelen * 2:
self._parents = (
st[: self._nodelen],
st[self._nodelen : 2 * self._nodelen],
)
elif l == 0:
self._parents = (
self._nodeconstants.nullid,
self._nodeconstants.nullid,
)
else:
raise error.Abort(
_(b'working directory state appears damaged!')
)
return self._parents
def setparents(self, p1, p2, fold_p2=False): def setparents(self, p1, p2, fold_p2=False):
self._parents = (p1, p2) self._parents = (p1, p2)
self._dirtyparents = True self._dirtyparents = True
copies = {} copies = {}
if fold_p2: if fold_p2:
for f, s in pycompat.iteritems(self._map): for f, s in pycompat.iteritems(self._map):
# Discard "merged" markers when moving away from a merge state # Discard "merged" markers when moving away from a merge state
if s.p2_info: if s.p2_info:
self.get = self._map.get self.get = self._map.get
def write(self, _tr, st, now): def write(self, _tr, st, now):
d = parsers.pack_dirstate(self._map, self.copymap, self.parents(), now) d = parsers.pack_dirstate(self._map, self.copymap, self.parents(), now)
st.write(d) st.write(d)
st.close() st.close()
self._dirtyparents = False self._dirtyparents = False
def _opendirstatefile(self):
fp, mode = txnutil.trypending(self._root, self._opener, self._filename)
if self._pendingmode is not None and self._pendingmode != mode:
fp.close()
raise error.Abort(
_(b'working directory state may be changed parallelly')
)
self._pendingmode = mode
return fp
@propertycache @propertycache
def identity(self): def identity(self):
self._map self._map
return self.identity return self.identity
### code related to maintaining and accessing "extra" property ### code related to maintaining and accessing "extra" property
# (e.g. "has_dir") # (e.g. "has_dir")
def _drop_entry(self, f): def _drop_entry(self, f):
self._map.pop(f, None) self._map.pop(f, None)
self.copymap.pop(f, None) self.copymap.pop(f, None)
if rustmod is not None: if rustmod is not None:
class dirstatemap(_dirstatemapcommon): class dirstatemap(_dirstatemapcommon):
def __init__(self, ui, opener, root, nodeconstants, use_dirstate_v2):
super(dirstatemap, self).__init__(
ui, opener, root, nodeconstants, use_dirstate_v2
)
self._docket = None
### Core data storage and access ### Core data storage and access
@property
def docket(self):
if not self._docket:
if not self._use_dirstate_v2:
raise error.ProgrammingError(
b'dirstate only has a docket in v2 format'
)
self._docket = docketmod.DirstateDocket.parse(
self._readdirstatefile(), self._nodeconstants
)
return self._docket
@propertycache @propertycache
def _map(self): def _map(self):
""" """
Fills the Dirstatemap when called. Fills the Dirstatemap when called.
""" """
# ignore HG_PENDING because identity is used only for writing # ignore HG_PENDING because identity is used only for writing
self.identity = util.filestat.frompath( self.identity = util.filestat.frompath(
self._opener.join(self._filename) self._opener.join(self._filename)
e = rust_map.get(f) e = rust_map.get(f)
source = self.copymap.pop(f, None) source = self.copymap.pop(f, None)
if source: if source:
copies[f] = source copies[f] = source
e.drop_merge_data() e.drop_merge_data()
rust_map.set_dirstate_item(f, e) rust_map.set_dirstate_item(f, e)
return copies return copies
def parents(self):
if not self._parents:
if self._use_dirstate_v2:
self._parents = self.docket.parents
else:
read_len = self._nodelen * 2
st = self._readdirstatefile(read_len)
l = len(st)
if l == read_len:
self._parents = (
st[: self._nodelen],
st[self._nodelen : 2 * self._nodelen],
)
elif l == 0:
self._parents = (
self._nodeconstants.nullid,
self._nodeconstants.nullid,
)
else:
raise error.Abort(
_(b'working directory state appears damaged!')
)
return self._parents
### disk interaction ### disk interaction
@propertycache @propertycache
def identity(self): def identity(self):
self._map self._map
return self.identity return self.identity
def write(self, tr, st, now): def write(self, tr, st, now):
if written is not None: # py2 may return None if written is not None: # py2 may return None
assert written == len(packed), (written, len(packed)) assert written == len(packed), (written, len(packed))
docket.data_size += len(packed) docket.data_size += len(packed)
docket.parents = self.parents() docket.parents = self.parents()
docket.tree_metadata = meta docket.tree_metadata = meta
st.write(docket.serialize()) st.write(docket.serialize())
st.close() st.close()
else: else:
old_docket = self.docket self.write_v2_no_append(tr, st, meta, packed)
new_docket = docketmod.DirstateDocket.with_new_uuid(
self.parents(), len(packed), meta
)
data_filename = new_docket.data_filename()
if tr:
tr.add(data_filename, 0)
self._opener.write(data_filename, packed)
# Write the new docket after the new data file has been
# written. Because `st` was opened with `atomictemp=True`,
# the actual `.hg/dirstate` file is only affected on close.
st.write(new_docket.serialize())
st.close()
# Remove the old data file after the new docket pointing to
# the new data file was written.
if old_docket.uuid:
data_filename = old_docket.data_filename()
unlink = lambda _tr=None: self._opener.unlink(data_filename)
if tr:
category = b"dirstate-v2-clean-" + old_docket.uuid
tr.addpostclose(category, unlink)
else:
unlink()
self._docket = new_docket
# Reload from the newly-written file # Reload from the newly-written file
util.clearcachedproperty(self, b"_map") util.clearcachedproperty(self, b"_map")
self._dirtyparents = False self._dirtyparents = False
def _opendirstatefile(self):
fp, mode = txnutil.trypending(
self._root, self._opener, self._filename
)
if self._pendingmode is not None and self._pendingmode != mode:
fp.close()
raise error.Abort(
_(b'working directory state may be changed parallelly')
)
self._pendingmode = mode
return fp
def _readdirstatefile(self, size=-1):
try:
with self._opendirstatefile() as fp:
return fp.read(size)
except IOError as err:
if err.errno != errno.ENOENT:
raise
# File doesn't exist, so the current state is empty
return b''
### code related to maintaining and accessing "extra" property ### code related to maintaining and accessing "extra" property
# (e.g. "has_dir") # (e.g. "has_dir")
@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.
""" """