( )⚙ D10574 revlog: rename `indexfile` to `_indexfile`

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10574

revlog: rename `indexfile` to `_indexfile`
ClosedPublic

Authored by marmoute on May 3 2021, 7:48 AM.

Details

Reviewers
indygreg
Alphare
Group Reviewers
hg-reviewers
Commits
rHGa07d5cb03a85: revlog: rename `indexfile` to `_indexfile`
Summary

We want to make the actual location of the indexfile and location more of an
implementation details than what is is currently. In that process, we make the
attribute private.

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

marmoute created this revision.May 3 2021, 7:48 AM
baymax updated this revision to Diff 27489.May 3 2021, 9:43 PM

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

Alphare accepted this revision.May 11 2021, 9:44 AM
This revision is now accepted and ready to land.May 11 2021, 9:44 AM
marmoute added a commit: rHGa07d5cb03a85: revlog: rename `indexfile` to `_indexfile`.May 11 2021, 12:48 PM
Closed by commit rHGa07d5cb03a85: revlog: rename `indexfile` to `_indexfile` (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 27820

contrib/perf.py

index data. index data.
""" """
opts = _byteskwargs(opts) opts = _byteskwargs(opts)
rl = cmdutil.openrevlog(repo, b'perfrevlogindex', file_, opts) rl = cmdutil.openrevlog(repo, b'perfrevlogindex', file_, opts)
opener = getattr(rl, 'opener') # trick linter opener = getattr(rl, 'opener') # trick linter
indexfile = rl.indexfile # compat with hg <= 5.8
indexfile = getattr(rl, '_indexfile', None)
if indexfile is None:
# compatibility with <= hg-5.8
indexfile = getattr(rl, 'indexfile')
data = opener.read(indexfile) data = opener.read(indexfile)
header = struct.unpack(b'>I', data[0:4])[0] header = struct.unpack(b'>I', data[0:4])[0]
version = header & 0xFFFF version = header & 0xFFFF
if version == 1: if version == 1:
inline = header & (1 << 16) inline = header & (1 << 16)
else: else:
raise error.Abort(b'unsupported revlog version: %d' % version) raise error.Abort(b'unsupported revlog version: %d' % version)
if orig._inline: if orig._inline:
raise error.Abort('not supporting inline revlog (yet)') raise error.Abort('not supporting inline revlog (yet)')
revlogkwargs = {} revlogkwargs = {}
k = 'upperboundcomp' k = 'upperboundcomp'
if util.safehasattr(orig, k): if util.safehasattr(orig, k):
revlogkwargs[k] = getattr(orig, k) revlogkwargs[k] = getattr(orig, k)
origindexpath = orig.opener.join(orig.indexfile) indexfile = getattr(orig, '_indexfile', None)
if indexfile is None:
# compatibility with <= hg-5.8
indexfile = getattr(orig, 'indexfile')
origindexpath = orig.opener.join(indexfile)
origdatapath = orig.opener.join(orig.datafile) origdatapath = orig.opener.join(orig.datafile)
indexname = 'revlog.i' indexname = 'revlog.i'
dataname = 'revlog.d' dataname = 'revlog.d'
tmpdir = tempfile.mkdtemp(prefix='tmp-hgperf-') tmpdir = tempfile.mkdtemp(prefix='tmp-hgperf-')
try: try:
# copy the data file in a temporary directory # copy the data file in a temporary directory
ui.debug('copying data in %s\n' % tmpdir) ui.debug('copying data in %s\n' % tmpdir)
engines.append(e) engines.append(e)
except NotImplementedError: except NotImplementedError:
pass pass
revs = list(rl.revs(startrev, len(rl) - 1)) revs = list(rl.revs(startrev, len(rl) - 1))
def rlfh(rl): def rlfh(rl):
if rl._inline: if rl._inline:
return getsvfs(repo)(rl.indexfile) indexfile = getattr(rl, '_indexfile', None)
if indexfile is None:
# compatibility with <= hg-5.8
indexfile = getattr(rl, 'indexfile')
return getsvfs(repo)(indexfile)
else: else:
return getsvfs(repo)(rl.datafile) return getsvfs(repo)(rl.datafile)
def doread(): def doread():
rl.clearcaches() rl.clearcaches()
for rev in revs: for rev in revs:
segmentforrevs(rev, rev) segmentforrevs(rev, rev)

mercurial/bundlerepo.py

if cs == node: if cs == node:
linkrev = nullrev linkrev = nullrev
else: else:
linkrev = linkmapper(cs) linkrev = linkmapper(cs)
for p in (p1, p2): for p in (p1, p2):
if not self.index.has_node(p): if not self.index.has_node(p):
raise error.LookupError( raise error.LookupError(
p, self.indexfile, _(b"unknown parent") p, self._indexfile, _(b"unknown parent")
) )
if not self.index.has_node(deltabase): if not self.index.has_node(deltabase):
raise LookupError( raise LookupError(
deltabase, self.indexfile, _(b'unknown delta base') deltabase, self._indexfile, _(b'unknown delta base')
) )
baserev = self.rev(deltabase) baserev = self.rev(deltabase)
# start, size, full unc. size, base (unused), link, p1, p2, node, sidedata_offset (unused), sidedata_size (unused) # start, size, full unc. size, base (unused), link, p1, p2, node, sidedata_offset (unused), sidedata_size (unused)
e = ( e = (
revlog.offset_type(start, flags), revlog.offset_type(start, flags),
size, size,
-1, -1,
class bundlechangelog(bundlerevlog, changelog.changelog): class bundlechangelog(bundlerevlog, changelog.changelog):
def __init__(self, opener, cgunpacker): def __init__(self, opener, cgunpacker):
changelog.changelog.__init__(self, opener) changelog.changelog.__init__(self, opener)
linkmapper = lambda x: x linkmapper = lambda x: x
bundlerevlog.__init__( bundlerevlog.__init__(
self, self,
opener, opener,
(revlog_constants.KIND_CHANGELOG, None), (revlog_constants.KIND_CHANGELOG, None),
self.indexfile, self._indexfile,
cgunpacker, cgunpacker,
linkmapper, linkmapper,
) )
class bundlemanifest(bundlerevlog, manifest.manifestrevlog): class bundlemanifest(bundlerevlog, manifest.manifestrevlog):
def __init__( def __init__(
self, self,
nodeconstants, nodeconstants,
opener, opener,
cgunpacker, cgunpacker,
linkmapper, linkmapper,
dirlogstarts=None, dirlogstarts=None,
dir=b'', dir=b'',
): ):
manifest.manifestrevlog.__init__(self, nodeconstants, opener, tree=dir) manifest.manifestrevlog.__init__(self, nodeconstants, opener, tree=dir)
bundlerevlog.__init__( bundlerevlog.__init__(
self, self,
opener, opener,
(revlog_constants.KIND_MANIFESTLOG, dir), (revlog_constants.KIND_MANIFESTLOG, dir),
self._revlog.indexfile, self._revlog._indexfile,
cgunpacker, cgunpacker,
linkmapper, linkmapper,
) )
if dirlogstarts is None: if dirlogstarts is None:
dirlogstarts = {} dirlogstarts = {}
if self.bundle.version == b"03": if self.bundle.version == b"03":
dirlogstarts = _getfilestarts(self.bundle) dirlogstarts = _getfilestarts(self.bundle)
self._dirlogstarts = dirlogstarts self._dirlogstarts = dirlogstarts
class bundlefilelog(filelog.filelog): class bundlefilelog(filelog.filelog):
def __init__(self, opener, path, cgunpacker, linkmapper): def __init__(self, opener, path, cgunpacker, linkmapper):
filelog.filelog.__init__(self, opener, path) filelog.filelog.__init__(self, opener, path)
self._revlog = bundlerevlog( self._revlog = bundlerevlog(
opener, opener,
# XXX should use the unencoded path # XXX should use the unencoded path
target=(revlog_constants.KIND_FILELOG, path), target=(revlog_constants.KIND_FILELOG, path),
indexfile=self._revlog.indexfile, indexfile=self._revlog._indexfile,
cgunpacker=cgunpacker, cgunpacker=cgunpacker,
linkmapper=linkmapper, linkmapper=linkmapper,
) )
class bundlepeer(localrepo.localpeer): class bundlepeer(localrepo.localpeer):
def canpush(self): def canpush(self):
return False return False

mercurial/changegroup.py

# where this breaks down a bit. That said, I don't # where this breaks down a bit. That said, I don't
# know if it would hurt anything. # know if it would hurt anything.
for i in pycompat.xrange(rev, 0, -1): for i in pycompat.xrange(rev, 0, -1):
if store.linkrev(i) == clrev: if store.linkrev(i) == clrev:
return i return i
# We failed to resolve a parent for this node, so # We failed to resolve a parent for this node, so
# we crash the changegroup construction. # we crash the changegroup construction.
if util.safehasattr(store, 'target'): if util.safehasattr(store, 'target'):
target = store.indexfile target = store._indexfile
else: else:
# some revlog not actually a revlog # some revlog not actually a revlog
target = store._revlog.indexfile target = store._revlog._indexfile
raise error.Abort( raise error.Abort(
b"unable to resolve parent while packing '%s' %r" b"unable to resolve parent while packing '%s' %r"
b' for changeset %r' % (target, rev, clrev) b' for changeset %r' % (target, rev, clrev)
) )
return nullrev return nullrev

mercurial/changelog.py

self._filteredrevs_hashcache = {} self._filteredrevs_hashcache = {}
def delayupdate(self, tr): def delayupdate(self, tr):
"""delay visibility of index updates to other readers""" """delay visibility of index updates to other readers"""
if not self._delayed: if not self._delayed:
if len(self) == 0: if len(self) == 0:
self._divert = True self._divert = True
if self._realopener.exists(self.indexfile + b'.a'): if self._realopener.exists(self._indexfile + b'.a'):
self._realopener.unlink(self.indexfile + b'.a') self._realopener.unlink(self._indexfile + b'.a')
self.opener = _divertopener(self._realopener, self.indexfile) self.opener = _divertopener(self._realopener, self._indexfile)
else: else:
self._delaybuf = [] self._delaybuf = []
self.opener = _delayopener( self.opener = _delayopener(
self._realopener, self.indexfile, self._delaybuf self._realopener, self._indexfile, self._delaybuf
) )
self._delayed = True self._delayed = True
tr.addpending(b'cl-%i' % id(self), self._writepending) tr.addpending(b'cl-%i' % id(self), self._writepending)
tr.addfinalize(b'cl-%i' % id(self), self._finalize) tr.addfinalize(b'cl-%i' % id(self), self._finalize)
def _finalize(self, tr): def _finalize(self, tr):
"""finalize index updates""" """finalize index updates"""
self._delayed = False self._delayed = False
self.opener = self._realopener self.opener = self._realopener
# move redirected index data back into place # move redirected index data back into place
if self._divert: if self._divert:
assert not self._delaybuf assert not self._delaybuf
tmpname = self.indexfile + b".a" tmpname = self._indexfile + b".a"
nfile = self.opener.open(tmpname) nfile = self.opener.open(tmpname)
nfile.close() nfile.close()
self.opener.rename(tmpname, self.indexfile, checkambig=True) self.opener.rename(tmpname, self._indexfile, checkambig=True)
elif self._delaybuf: elif self._delaybuf:
fp = self.opener(self.indexfile, b'a', checkambig=True) fp = self.opener(self._indexfile, b'a', checkambig=True)
fp.write(b"".join(self._delaybuf)) fp.write(b"".join(self._delaybuf))
fp.close() fp.close()
self._delaybuf = None self._delaybuf = None
self._divert = False self._divert = False
# split when we're done # split when we're done
self._enforceinlinesize(tr) self._enforceinlinesize(tr)
def _writepending(self, tr): def _writepending(self, tr):
"""create a file containing the unfinalized state for """create a file containing the unfinalized state for
pretxnchangegroup""" pretxnchangegroup"""
if self._delaybuf: if self._delaybuf:
# make a temporary copy of the index # make a temporary copy of the index
fp1 = self._realopener(self.indexfile) fp1 = self._realopener(self._indexfile)
pendingfilename = self.indexfile + b".a" pendingfilename = self._indexfile + b".a"
# register as a temp file to ensure cleanup on failure # register as a temp file to ensure cleanup on failure
tr.registertmp(pendingfilename) tr.registertmp(pendingfilename)
# write existing data # write existing data
fp2 = self._realopener(pendingfilename, b"w") fp2 = self._realopener(pendingfilename, b"w")
fp2.write(fp1.read()) fp2.write(fp1.read())
# add pending data # add pending data
fp2.write(b"".join(self._delaybuf)) fp2.write(b"".join(self._delaybuf))
fp2.close() fp2.close()
# switch modes so finalize can simply rename # switch modes so finalize can simply rename
self._delaybuf = None self._delaybuf = None
self._divert = True self._divert = True
self.opener = _divertopener(self._realopener, self.indexfile) self.opener = _divertopener(self._realopener, self._indexfile)
if self._divert: if self._divert:
return True return True
return False return False
def _enforceinlinesize(self, tr, fp=None): def _enforceinlinesize(self, tr, fp=None):
if not self._delayed: if not self._delayed:

mercurial/filelog.py

def rev(self, node): def rev(self, node):
return self._revlog.rev(node) return self._revlog.rev(node)
def node(self, rev): def node(self, rev):
return self._revlog.node(rev) return self._revlog.node(rev)
def lookup(self, node): def lookup(self, node):
return storageutil.fileidlookup( return storageutil.fileidlookup(
self._revlog, node, self._revlog.indexfile self._revlog, node, self._revlog._indexfile
) )
def linkrev(self, rev): def linkrev(self, rev):
return self._revlog.linkrev(rev) return self._revlog.linkrev(rev)
def commonancestorsheads(self, node1, node2): def commonancestorsheads(self, node1, node2):
return self._revlog.commonancestorsheads(node1, node2) return self._revlog.commonancestorsheads(node1, node2)

mercurial/repoview.py

assert not self.filteredrevs assert not self.filteredrevs
super(filteredchangelogmixin, self).strip(*args, **kwargs) super(filteredchangelogmixin, self).strip(*args, **kwargs)
def rev(self, node): def rev(self, node):
"""filtered version of revlog.rev""" """filtered version of revlog.rev"""
r = super(filteredchangelogmixin, self).rev(node) r = super(filteredchangelogmixin, self).rev(node)
if r in self.filteredrevs: if r in self.filteredrevs:
raise error.FilteredLookupError( raise error.FilteredLookupError(
hex(node), self.indexfile, _(b'filtered node') hex(node), self._indexfile, _(b'filtered node')
) )
return r return r
def node(self, rev): def node(self, rev):
"""filtered version of revlog.node""" """filtered version of revlog.node"""
if rev in self.filteredrevs: if rev in self.filteredrevs:
raise error.FilteredIndexError(rev) raise error.FilteredIndexError(rev)
return super(filteredchangelogmixin, self).node(rev) return super(filteredchangelogmixin, self).node(rev)

mercurial/revlog.py

b"revlog's indexfile should end with `.i`" b"revlog's indexfile should end with `.i`"
) )
if datafile is None: if datafile is None:
datafile = indexfile[:-2] + b".d" datafile = indexfile[:-2] + b".d"
if postfix is not None: if postfix is not None:
datafile = b'%s.%s' % (datafile, postfix) datafile = b'%s.%s' % (datafile, postfix)
if postfix is not None: if postfix is not None:
indexfile = b'%s.%s' % (indexfile, postfix) indexfile = b'%s.%s' % (indexfile, postfix)
self.indexfile = indexfile self._indexfile = indexfile
self.datafile = datafile self.datafile = datafile
self.nodemap_file = None self.nodemap_file = None
self.postfix = postfix self.postfix = postfix
if persistentnodemap: if persistentnodemap:
self.nodemap_file = nodemaputil.get_nodemap_file( self.nodemap_file = nodemaputil.get_nodemap_file(
opener, self.indexfile opener, self._indexfile
) )
self.opener = opener self.opener = opener
assert target[0] in ALL_KINDS assert target[0] in ALL_KINDS
assert len(target) == 2 assert len(target) == 2
self.target = target self.target = target
# When True, indexfile is opened with checkambig=True at writing, to # When True, indexfile is opened with checkambig=True at writing, to
# avoid file stat ambiguity. # avoid file stat ambiguity.
flags = self._format_flags = versionflags & ~0xFFFF flags = self._format_flags = versionflags & ~0xFFFF
fmt = self._format_version = versionflags & 0xFFFF fmt = self._format_version = versionflags & 0xFFFF
if fmt == REVLOGV0: if fmt == REVLOGV0:
if flags: if flags:
raise error.RevlogError( raise error.RevlogError(
_(b'unknown flags (%#04x) in version %d revlog %s') _(b'unknown flags (%#04x) in version %d revlog %s')
% (flags >> 16, fmt, self.indexfile) % (flags >> 16, fmt, self._indexfile)
) )
self._inline = False self._inline = False
self._generaldelta = False self._generaldelta = False
elif fmt == REVLOGV1: elif fmt == REVLOGV1:
if flags & ~REVLOGV1_FLAGS: if flags & ~REVLOGV1_FLAGS:
raise error.RevlogError( raise error.RevlogError(
_(b'unknown flags (%#04x) in version %d revlog %s') _(b'unknown flags (%#04x) in version %d revlog %s')
% (flags >> 16, fmt, self.indexfile) % (flags >> 16, fmt, self._indexfile)
) )
self._inline = versionflags & FLAG_INLINE_DATA self._inline = versionflags & FLAG_INLINE_DATA
self._generaldelta = versionflags & FLAG_GENERALDELTA self._generaldelta = versionflags & FLAG_GENERALDELTA
elif fmt == REVLOGV2: elif fmt == REVLOGV2:
if flags & ~REVLOGV2_FLAGS: if flags & ~REVLOGV2_FLAGS:
raise error.RevlogError( raise error.RevlogError(
_(b'unknown flags (%#04x) in version %d revlog %s') _(b'unknown flags (%#04x) in version %d revlog %s')
% (flags >> 16, fmt, self.indexfile) % (flags >> 16, fmt, self._indexfile)
) )
# There is a bug in the transaction handling when going from an # There is a bug in the transaction handling when going from an
# inline revlog to a separate index and data file. Turn it off until # inline revlog to a separate index and data file. Turn it off until
# it's fixed, since v2 revlogs sometimes get rewritten on exchange. # it's fixed, since v2 revlogs sometimes get rewritten on exchange.
# See issue6485 # See issue6485
self._inline = False self._inline = False
# generaldelta implied by version 2 revlogs. # generaldelta implied by version 2 revlogs.
self._generaldelta = True self._generaldelta = True
else: else:
raise error.RevlogError( raise error.RevlogError(
_(b'unknown version (%d) in revlog %s') % (fmt, self.indexfile) _(b'unknown version (%d) in revlog %s') % (fmt, self._indexfile)
) )
self.nodeconstants = sha1nodeconstants self.nodeconstants = sha1nodeconstants
self.nullid = self.nodeconstants.nullid self.nullid = self.nodeconstants.nullid
# sparse-revlog can't be on without general-delta (issue6056) # sparse-revlog can't be on without general-delta (issue6056)
if not self._generaldelta: if not self._generaldelta:
self._sparserevlog = False self._sparserevlog = False
len(d[0]) > docket.tip_rev len(d[0]) > docket.tip_rev
and d[0][docket.tip_rev][7] == docket.tip_node and d[0][docket.tip_rev][7] == docket.tip_node
): ):
# no changelog tampering # no changelog tampering
self._nodemap_docket = docket self._nodemap_docket = docket
index.update_nodemap_data(*nodemap_data) index.update_nodemap_data(*nodemap_data)
except (ValueError, IndexError): except (ValueError, IndexError):
raise error.RevlogError( raise error.RevlogError(
_(b"index %s is corrupted") % self.indexfile _(b"index %s is corrupted") % self._indexfile
) )
self.index, self._chunkcache = d self.index, self._chunkcache = d
if not self._chunkcache: if not self._chunkcache:
self._chunkclear() self._chunkclear()
# revnum -> (chain-length, sum-delta-length) # revnum -> (chain-length, sum-delta-length)
self._chaininfocache = util.lrucachedict(500) self._chaininfocache = util.lrucachedict(500)
# revlog header -> revlog compressor # revlog header -> revlog compressor
self._decompressors = {} self._decompressors = {}
def _indexfp(self, mode=b'r'): def _indexfp(self, mode=b'r'):
"""file object for the revlog's index file""" """file object for the revlog's index file"""
args = {'mode': mode} args = {'mode': mode}
if mode != b'r': if mode != b'r':
args['checkambig'] = self._checkambig args['checkambig'] = self._checkambig
if mode == b'w': if mode == b'w':
args['atomictemp'] = True args['atomictemp'] = True
return self.opener(self.indexfile, **args) return self.opener(self._indexfile, **args)
def _datafp(self, mode=b'r'): def _datafp(self, mode=b'r'):
"""file object for the revlog's data file""" """file object for the revlog's data file"""
return self.opener(self.datafile, mode=mode) return self.opener(self.datafile, mode=mode)
@contextlib.contextmanager @contextlib.contextmanager
def _datareadfp(self, existingfp=None): def _datareadfp(self, existingfp=None):
"""file object suitable to read data""" """file object suitable to read data"""
raise raise
except error.RevlogError: except error.RevlogError:
# parsers.c radix tree lookup failed # parsers.c radix tree lookup failed
if ( if (
node == self.nodeconstants.wdirid node == self.nodeconstants.wdirid
or node in self.nodeconstants.wdirfilenodeids or node in self.nodeconstants.wdirfilenodeids
): ):
raise error.WdirUnsupported raise error.WdirUnsupported
raise error.LookupError(node, self.indexfile, _(b'no node')) raise error.LookupError(node, self._indexfile, _(b'no node'))
# Accessors for index entries. # Accessors for index entries.
# First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes # First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes
# are flags. # are flags.
def start(self, rev): def start(self, rev):
return int(self.index[rev][0] >> 16) return int(self.index[rev][0] >> 16)
# no 'ff...' match in radix tree, wdir identified # no 'ff...' match in radix tree, wdir identified
raise error.WdirUnsupported raise error.WdirUnsupported
return None return None
except error.RevlogError: except error.RevlogError:
# parsers.c radix tree lookup gave multiple matches # parsers.c radix tree lookup gave multiple matches
# fast path: for unfiltered changelog, radix tree is accurate # fast path: for unfiltered changelog, radix tree is accurate
if not getattr(self, 'filteredrevs', None): if not getattr(self, 'filteredrevs', None):
raise error.AmbiguousPrefixLookupError( raise error.AmbiguousPrefixLookupError(
id, self.indexfile, _(b'ambiguous identifier') id, self._indexfile, _(b'ambiguous identifier')
) )
# fall through to slow path that filters hidden revisions # fall through to slow path that filters hidden revisions
except (AttributeError, ValueError): except (AttributeError, ValueError):
# we are pure python, or key was too short to search radix tree # we are pure python, or key was too short to search radix tree
pass pass
if id in self._pcache: if id in self._pcache:
return self._pcache[id] return self._pcache[id]
] ]
if self.nodeconstants.nullhex.startswith(id): if self.nodeconstants.nullhex.startswith(id):
nl.append(self.nullid) nl.append(self.nullid)
if len(nl) > 0: if len(nl) > 0:
if len(nl) == 1 and not maybewdir: if len(nl) == 1 and not maybewdir:
self._pcache[id] = nl[0] self._pcache[id] = nl[0]
return nl[0] return nl[0]
raise error.AmbiguousPrefixLookupError( raise error.AmbiguousPrefixLookupError(
id, self.indexfile, _(b'ambiguous identifier') id, self._indexfile, _(b'ambiguous identifier')
) )
if maybewdir: if maybewdir:
raise error.WdirUnsupported raise error.WdirUnsupported
return None return None
except TypeError: except TypeError:
pass pass
def lookup(self, id): def lookup(self, id):
"""locate a node based on: """locate a node based on:
- revision number or str(revision number) - revision number or str(revision number)
- nodeid or subset of hex nodeid - nodeid or subset of hex nodeid
""" """
n = self._match(id) n = self._match(id)
if n is not None: if n is not None:
return n return n
n = self._partialmatch(id) n = self._partialmatch(id)
if n: if n:
return n return n
raise error.LookupError(id, self.indexfile, _(b'no match found')) raise error.LookupError(id, self._indexfile, _(b'no match found'))
def shortest(self, node, minlength=1): def shortest(self, node, minlength=1):
"""Find the shortest unambiguous prefix that matches node.""" """Find the shortest unambiguous prefix that matches node."""
def isvalid(prefix): def isvalid(prefix):
try: try:
matchednode = self._partialmatch(prefix) matchednode = self._partialmatch(prefix)
except error.AmbiguousPrefixLookupError: except error.AmbiguousPrefixLookupError:
return False return False
except error.WdirUnsupported: except error.WdirUnsupported:
# single 'ff...' match # single 'ff...' match
return True return True
if matchednode is None: if matchednode is None:
raise error.LookupError(node, self.indexfile, _(b'no node')) raise error.LookupError(node, self._indexfile, _(b'no node'))
return True return True
def maybewdir(prefix): def maybewdir(prefix):
return all(c == b'f' for c in pycompat.iterbytestr(prefix)) return all(c == b'f' for c in pycompat.iterbytestr(prefix))
hexnode = hex(node) hexnode = hex(node)
def disambiguate(hexnode, minlength): def disambiguate(hexnode, minlength):
"""Disambiguate against wdirid.""" """Disambiguate against wdirid."""
for length in range(minlength, len(hexnode) + 1): for length in range(minlength, len(hexnode) + 1):
prefix = hexnode[:length] prefix = hexnode[:length]
if not maybewdir(prefix): if not maybewdir(prefix):
return prefix return prefix
if not getattr(self, 'filteredrevs', None): if not getattr(self, 'filteredrevs', None):
try: try:
length = max(self.index.shortest(node), minlength) length = max(self.index.shortest(node), minlength)
return disambiguate(hexnode, length) return disambiguate(hexnode, length)
except error.RevlogError: except error.RevlogError:
if node != self.nodeconstants.wdirid: if node != self.nodeconstants.wdirid:
raise error.LookupError(node, self.indexfile, _(b'no node')) raise error.LookupError(
node, self._indexfile, _(b'no node')
)
except AttributeError: except AttributeError:
# Fall through to pure code # Fall through to pure code
pass pass
if node == self.nodeconstants.wdirid: if node == self.nodeconstants.wdirid:
for length in range(minlength, len(hexnode) + 1): for length in range(minlength, len(hexnode) + 1):
prefix = hexnode[:length] prefix = hexnode[:length]
if isvalid(prefix): if isvalid(prefix):
startoffset = offset - realoffset startoffset = offset - realoffset
if len(d) - startoffset < length: if len(d) - startoffset < length:
raise error.RevlogError( raise error.RevlogError(
_( _(
b'partial read of revlog %s; expected %d bytes from ' b'partial read of revlog %s; expected %d bytes from '
b'offset %d, got %d' b'offset %d, got %d'
) )
% ( % (
self.indexfile if self._inline else self.datafile, self._indexfile if self._inline else self.datafile,
length, length,
realoffset, realoffset,
len(d) - startoffset, len(d) - startoffset,
) )
) )
return util.buffer(d, startoffset, length) return util.buffer(d, startoffset, length)
if len(d) < length: if len(d) < length:
raise error.RevlogError( raise error.RevlogError(
_( _(
b'partial read of revlog %s; expected %d bytes from offset ' b'partial read of revlog %s; expected %d bytes from offset '
b'%d, got %d' b'%d, got %d'
) )
% ( % (
self.indexfile if self._inline else self.datafile, self._indexfile if self._inline else self.datafile,
length, length,
offset, offset,
len(d), len(d),
) )
) )
return d return d
if self._revisioncache and self._revisioncache[0] == node: if self._revisioncache and self._revisioncache[0] == node:
self._revisioncache = None self._revisioncache = None
revornode = rev revornode = rev
if revornode is None: if revornode is None:
revornode = templatefilters.short(hex(node)) revornode = templatefilters.short(hex(node))
raise error.RevlogError( raise error.RevlogError(
_(b"integrity check failed on %s:%s") _(b"integrity check failed on %s:%s")
% (self.indexfile, pycompat.bytestr(revornode)) % (self._indexfile, pycompat.bytestr(revornode))
) )
except error.RevlogError: except error.RevlogError:
if self._censorable and storageutil.iscensoredtext(text): if self._censorable and storageutil.iscensoredtext(text):
raise error.CensoredNodeError(self.indexfile, node, text) raise error.CensoredNodeError(self._indexfile, node, text)
raise raise
def _enforceinlinesize(self, tr, fp=None): def _enforceinlinesize(self, tr, fp=None):
"""Check if the revlog is too big for inline and convert if so. """Check if the revlog is too big for inline and convert if so.
This should be called after revisions are added to the revlog. If the This should be called after revisions are added to the revlog. If the
revlog has grown too large to be an inline revlog, it will convert it revlog has grown too large to be an inline revlog, it will convert it
to use multiple index and data files. to use multiple index and data files.
""" """
tiprev = len(self) - 1 tiprev = len(self) - 1
if ( if (
not self._inline not self._inline
or (self.start(tiprev) + self.length(tiprev)) < _maxinline or (self.start(tiprev) + self.length(tiprev)) < _maxinline
): ):
return return
troffset = tr.findoffset(self.indexfile) troffset = tr.findoffset(self._indexfile)
if troffset is None: if troffset is None:
raise error.RevlogError( raise error.RevlogError(
_(b"%s not found in the transaction") % self.indexfile _(b"%s not found in the transaction") % self._indexfile
) )
trindex = 0 trindex = 0
tr.add(self.datafile, 0) tr.add(self.datafile, 0)
if fp: if fp:
fp.flush() fp.flush()
fp.close() fp.close()
# We can't use the cached file handle after close(). So prevent # We can't use the cached file handle after close(). So prevent
header = self._format_flags | self._format_version header = self._format_flags | self._format_version
header = self.index.pack_header(header) header = self.index.pack_header(header)
e = header + e e = header + e
fp.write(e) fp.write(e)
# the temp file replace the real index when we exit the context # the temp file replace the real index when we exit the context
# manager # manager
tr.replace(self.indexfile, trindex * self.index.entry_size) tr.replace(self._indexfile, trindex * self.index.entry_size)
nodemaputil.setup_persistent_nodemap(tr, self) nodemaputil.setup_persistent_nodemap(tr, self)
self._chunkclear() self._chunkclear()
def _nodeduplicatecallback(self, transaction, node): def _nodeduplicatecallback(self, transaction, node):
"""called when trying to add a node already stored.""" """called when trying to add a node already stored."""
def addrevision( def addrevision(
self, self,
computed by default as hash(text, p1, p2), however subclasses might computed by default as hash(text, p1, p2), however subclasses might
use different hashing method (and override checkhash() in such case) use different hashing method (and override checkhash() in such case)
flags - the known flags to set on the revision flags - the known flags to set on the revision
deltacomputer - an optional deltacomputer instance shared between deltacomputer - an optional deltacomputer instance shared between
multiple calls multiple calls
""" """
if link == nullrev: if link == nullrev:
raise error.RevlogError( raise error.RevlogError(
_(b"attempted to add linkrev -1 to %s") % self.indexfile _(b"attempted to add linkrev -1 to %s") % self._indexfile
) )
if sidedata is None: if sidedata is None:
sidedata = {} sidedata = {}
elif sidedata and not self.hassidedata: elif sidedata and not self.hassidedata:
raise error.ProgrammingError( raise error.ProgrammingError(
_(b"trying to add sidedata to a revlog who don't support them") _(b"trying to add sidedata to a revlog who don't support them")
) )
if flags: if flags:
node = node or self.hash(text, p1, p2) node = node or self.hash(text, p1, p2)
rawtext, validatehash = flagutil.processflagswrite(self, text, flags) rawtext, validatehash = flagutil.processflagswrite(self, text, flags)
# If the flag processor modifies the revision data, ignore any provided # If the flag processor modifies the revision data, ignore any provided
# cachedelta. # cachedelta.
if rawtext != text: if rawtext != text:
cachedelta = None cachedelta = None
if len(rawtext) > _maxentrysize: if len(rawtext) > _maxentrysize:
raise error.RevlogError( raise error.RevlogError(
_( _(
b"%s: size of %d bytes exceeds maximum revlog storage of 2GiB" b"%s: size of %d bytes exceeds maximum revlog storage of 2GiB"
) )
% (self.indexfile, len(rawtext)) % (self._indexfile, len(rawtext))
) )
node = node or self.hash(rawtext, p1, p2) node = node or self.hash(rawtext, p1, p2)
rev = self.index.get_rev(node) rev = self.index.get_rev(node)
if rev is not None: if rev is not None:
return rev return rev
if validatehash: if validatehash:
be used. be used.
invariants: invariants:
- rawtext is optional (can be None); if not set, cachedelta must be set. - rawtext is optional (can be None); if not set, cachedelta must be set.
if both are set, they must correspond to each other. if both are set, they must correspond to each other.
""" """
if node == self.nullid: if node == self.nullid:
raise error.RevlogError( raise error.RevlogError(
_(b"%s: attempt to add null revision") % self.indexfile _(b"%s: attempt to add null revision") % self._indexfile
) )
if ( if (
node == self.nodeconstants.wdirid node == self.nodeconstants.wdirid
or node in self.nodeconstants.wdirfilenodeids or node in self.nodeconstants.wdirfilenodeids
): ):
raise error.RevlogError( raise error.RevlogError(
_(b"%s: attempt to add wdir revision") % self.indexfile _(b"%s: attempt to add wdir revision") % self._indexfile
) )
if self._inline: if self._inline:
fh = ifh fh = ifh
else: else:
fh = dfh fh = dfh
btext = [rawtext] btext = [rawtext]
curr = len(self) curr = len(self)
prev = curr - 1 prev = curr - 1
offset = self._get_data_offset(prev) offset = self._get_data_offset(prev)
if self._concurrencychecker: if self._concurrencychecker:
if self._inline: if self._inline:
# offset is "as if" it were in the .d file, so we need to add on # offset is "as if" it were in the .d file, so we need to add on
# the size of the entry metadata. # the size of the entry metadata.
self._concurrencychecker( self._concurrencychecker(
ifh, self.indexfile, offset + curr * self.index.entry_size ifh, self._indexfile, offset + curr * self.index.entry_size
) )
else: else:
# Entries in the .i are a consistent size. # Entries in the .i are a consistent size.
self._concurrencychecker( self._concurrencychecker(
ifh, self.indexfile, curr * self.index.entry_size ifh, self._indexfile, curr * self.index.entry_size
) )
self._concurrencychecker(dfh, self.datafile, offset) self._concurrencychecker(dfh, self.datafile, offset)
p1r, p2r = self.rev(p1), self.rev(p2) p1r, p2r = self.rev(p1), self.rev(p2)
# full versions are inserted when the needed deltas # full versions are inserted when the needed deltas
# become comparable to the uncompressed text # become comparable to the uncompressed text
if rawtext is None: if rawtext is None:
# to be careful before changing this. # to be careful before changing this.
ifh.seek(0, os.SEEK_END) ifh.seek(0, os.SEEK_END)
if dfh: if dfh:
dfh.seek(0, os.SEEK_END) dfh.seek(0, os.SEEK_END)
curr = len(self) - 1 curr = len(self) - 1
if not self._inline: if not self._inline:
transaction.add(self.datafile, offset) transaction.add(self.datafile, offset)
transaction.add(self.indexfile, curr * len(entry)) transaction.add(self._indexfile, curr * len(entry))
if data[0]: if data[0]:
dfh.write(data[0]) dfh.write(data[0])
dfh.write(data[1]) dfh.write(data[1])
if sidedata: if sidedata:
dfh.write(sidedata) dfh.write(sidedata)
ifh.write(entry) ifh.write(entry)
else: else:
offset += curr * self.index.entry_size offset += curr * self.index.entry_size
transaction.add(self.indexfile, offset) transaction.add(self._indexfile, offset)
ifh.write(entry) ifh.write(entry)
ifh.write(data[0]) ifh.write(data[0])
ifh.write(data[1]) ifh.write(data[1])
if sidedata: if sidedata:
ifh.write(sidedata) ifh.write(sidedata)
self._enforceinlinesize(transaction, ifh) self._enforceinlinesize(transaction, ifh)
nodemaputil.setup_persistent_nodemap(transaction, self) nodemaputil.setup_persistent_nodemap(transaction, self)
r = len(self) r = len(self)
end = 0 end = 0
if r: if r:
end = self.end(r - 1) end = self.end(r - 1)
ifh = self._indexfp(b"a+") ifh = self._indexfp(b"a+")
isize = r * self.index.entry_size isize = r * self.index.entry_size
if self._inline: if self._inline:
transaction.add(self.indexfile, end + isize) transaction.add(self._indexfile, end + isize)
dfh = None dfh = None
else: else:
transaction.add(self.indexfile, isize) transaction.add(self._indexfile, isize)
transaction.add(self.datafile, end) transaction.add(self.datafile, end)
dfh = self._datafp(b"a+") dfh = self._datafp(b"a+")
def flush(): def flush():
if dfh: if dfh:
dfh.flush() dfh.flush()
ifh.flush() ifh.flush()
if duplicaterevisioncb: if duplicaterevisioncb:
duplicaterevisioncb(self, rev) duplicaterevisioncb(self, rev)
empty = False empty = False
continue continue
for p in (p1, p2): for p in (p1, p2):
if not self.index.has_node(p): if not self.index.has_node(p):
raise error.LookupError( raise error.LookupError(
p, self.indexfile, _(b'unknown parent') p, self._indexfile, _(b'unknown parent')
) )
if not self.index.has_node(deltabase): if not self.index.has_node(deltabase):
raise error.LookupError( raise error.LookupError(
deltabase, self.indexfile, _(b'unknown delta base') deltabase, self._indexfile, _(b'unknown delta base')
) )
baserev = self.rev(deltabase) baserev = self.rev(deltabase)
if baserev != nullrev and self.iscensored(baserev): if baserev != nullrev and self.iscensored(baserev):
# if base is censored, delta must be full replacement in a # if base is censored, delta must be full replacement in a
# single patch operation # single patch operation
hlen = struct.calcsize(b">lll") hlen = struct.calcsize(b">lll")
oldlen = self.rawsize(baserev) oldlen = self.rawsize(baserev)
newlen = len(delta) - hlen newlen = len(delta) - hlen
if delta[:hlen] != mdiff.replacediffheader(oldlen, newlen): if delta[:hlen] != mdiff.replacediffheader(oldlen, newlen):
raise error.CensoredBaseError( raise error.CensoredBaseError(
self.indexfile, self.node(baserev) self._indexfile, self.node(baserev)
) )
if not flags and self._peek_iscensored(baserev, delta, flush): if not flags and self._peek_iscensored(baserev, delta, flush):
flags |= REVIDX_ISCENSORED flags |= REVIDX_ISCENSORED
# We assume consumers of addrevisioncb will want to retrieve # We assume consumers of addrevisioncb will want to retrieve
# the added revision, which will require a call to # the added revision, which will require a call to
# revision(). revision() will fast path if there is a cache # revision(). revision() will fast path if there is a cache
# first truncate the files on disk # first truncate the files on disk
end = self.start(rev) end = self.start(rev)
if not self._inline: if not self._inline:
transaction.add(self.datafile, end) transaction.add(self.datafile, end)
end = rev * self.index.entry_size end = rev * self.index.entry_size
else: else:
end += rev * self.index.entry_size end += rev * self.index.entry_size
transaction.add(self.indexfile, end) transaction.add(self._indexfile, end)
# then reset internal state in memory to forget those revisions # then reset internal state in memory to forget those revisions
self._revisioncache = None self._revisioncache = None
self._chaininfocache = util.lrucachedict(500) self._chaininfocache = util.lrucachedict(500)
self._chunkclear() self._chunkclear()
del self.index[rev:-1] del self.index[rev:-1]
actual = f.tell() actual = f.tell()
dd = actual - expected dd = actual - expected
except IOError as inst: except IOError as inst:
if inst.errno != errno.ENOENT: if inst.errno != errno.ENOENT:
raise raise
dd = 0 dd = 0
try: try:
f = self.opener(self.indexfile) f = self.opener(self._indexfile)
f.seek(0, io.SEEK_END) f.seek(0, io.SEEK_END)
actual = f.tell() actual = f.tell()
f.close() f.close()
s = self.index.entry_size s = self.index.entry_size
i = max(0, actual // s) i = max(0, actual // s)
di = actual - (i * s) di = actual - (i * s)
if self._inline: if self._inline:
databytes = 0 databytes = 0
for r in self: for r in self:
databytes += max(0, self.length(r)) databytes += max(0, self.length(r))
dd = 0 dd = 0
di = actual - len(self) * s - databytes di = actual - len(self) * s - databytes
except IOError as inst: except IOError as inst:
if inst.errno != errno.ENOENT: if inst.errno != errno.ENOENT:
raise raise
di = 0 di = 0
return (dd, di) return (dd, di)
def files(self): def files(self):
res = [self.indexfile] res = [self._indexfile]
if not self._inline: if not self._inline:
res.append(self.datafile) res.append(self.datafile)
return res return res
def emitrevisions( def emitrevisions(
self, self,
nodes, nodes,
nodesorder=None, nodesorder=None,
if sidedata_helpers is not None: if sidedata_helpers is not None:
(sidedata, new_flags) = sidedatautil.run_sidedata_helpers( (sidedata, new_flags) = sidedatautil.run_sidedata_helpers(
self, sidedata_helpers, sidedata, rev self, sidedata_helpers, sidedata, rev
) )
flags = flags | new_flags[0] & ~new_flags[1] flags = flags | new_flags[0] & ~new_flags[1]
ifh = destrevlog.opener( ifh = destrevlog.opener(
destrevlog.indexfile, b'a+', checkambig=False destrevlog._indexfile, b'a+', checkambig=False
) )
dfh = None dfh = None
if not destrevlog._inline: if not destrevlog._inline:
dfh = destrevlog.opener(destrevlog.datafile, b'a+') dfh = destrevlog.opener(destrevlog.datafile, b'a+')
try: try:
destrevlog._addrevision( destrevlog._addrevision(
node, node,
rawtext, rawtext,
# to create a new revlog, copy all revisions to it, then replace the # to create a new revlog, copy all revisions to it, then replace the
# revlogs on transaction close. # revlogs on transaction close.
# #
# This is a bit dangerous. We could easily have a mismatch of state. # This is a bit dangerous. We could easily have a mismatch of state.
newrl = revlog( newrl = revlog(
self.opener, self.opener,
target=self.target, target=self.target,
postfix=b'tmpcensored', postfix=b'tmpcensored',
indexfile=self.indexfile, indexfile=self._indexfile,
censorable=True, censorable=True,
) )
newrl._format_version = self._format_version newrl._format_version = self._format_version
newrl._format_flags = self._format_flags newrl._format_flags = self._format_flags
newrl._generaldelta = self._generaldelta newrl._generaldelta = self._generaldelta
newrl._parse_index = self._parse_index newrl._parse_index = self._parse_index
for rev in self.revs(): for rev in self.revs():
rawtext = self._chunk(rev) rawtext = self._chunk(rev)
else: else:
rawtext = self.rawdata(rev) rawtext = self.rawdata(rev)
newrl.addrawrevision( newrl.addrawrevision(
rawtext, tr, self.linkrev(rev), p1, p2, node, self.flags(rev) rawtext, tr, self.linkrev(rev), p1, p2, node, self.flags(rev)
) )
tr.addbackup(self.indexfile, location=b'store') tr.addbackup(self._indexfile, location=b'store')
if not self._inline: if not self._inline:
tr.addbackup(self.datafile, location=b'store') tr.addbackup(self.datafile, location=b'store')
self.opener.rename(newrl.indexfile, self.indexfile) self.opener.rename(newrl._indexfile, self._indexfile)
if not self._inline: if not self._inline:
self.opener.rename(newrl.datafile, self.datafile) self.opener.rename(newrl.datafile, self.datafile)
self.clearcaches() self.clearcaches()
self._loadindex() self._loadindex()
def verifyintegrity(self, state): def verifyintegrity(self, state):
"""Verifies the integrity of the revlog. """Verifies the integrity of the revlog.
Yields ``revlogproblem`` instances describing problems that are Yields ``revlogproblem`` instances describing problems that are
found. found.
""" """
dd, di = self.checksize() dd, di = self.checksize()
if dd: if dd:
yield revlogproblem(error=_(b'data length off by %d bytes') % dd) yield revlogproblem(error=_(b'data length off by %d bytes') % dd)
if di: if di:
yield revlogproblem(error=_(b'index contains %d extra bytes') % di) yield revlogproblem(error=_(b'index contains %d extra bytes') % di)
version = self._format_version version = self._format_version
# The verifier tells us what version revlog we should be. # The verifier tells us what version revlog we should be.
if version != state[b'expectedversion']: if version != state[b'expectedversion']:
yield revlogproblem( yield revlogproblem(
warning=_(b"warning: '%s' uses revlog format %d; expected %d") warning=_(b"warning: '%s' uses revlog format %d; expected %d")
% (self.indexfile, version, state[b'expectedversion']) % (self._indexfile, version, state[b'expectedversion'])
) )
state[b'skipread'] = set() state[b'skipread'] = set()
state[b'safe_renamed'] = set() state[b'safe_renamed'] = set()
for rev in self: for rev in self:
node = self.node(rev) node = self.node(rev)
sharedfiles=False, sharedfiles=False,
revisionscount=False, revisionscount=False,
trackedsize=False, trackedsize=False,
storedsize=False, storedsize=False,
): ):
d = {} d = {}
if exclusivefiles: if exclusivefiles:
d[b'exclusivefiles'] = [(self.opener, self.indexfile)] d[b'exclusivefiles'] = [(self.opener, self._indexfile)]
if not self._inline: if not self._inline:
d[b'exclusivefiles'].append((self.opener, self.datafile)) d[b'exclusivefiles'].append((self.opener, self.datafile))
if sharedfiles: if sharedfiles:
d[b'sharedfiles'] = [] d[b'sharedfiles'] = []
if revisionscount: if revisionscount:
d[b'revisionscount'] = len(self) d[b'revisionscount'] = len(self)

mercurial/revlogutils/nodemap.py

"""Write nodemap data on disk for a given revlog""" """Write nodemap data on disk for a given revlog"""
if getattr(revlog, 'filteredrevs', ()): if getattr(revlog, 'filteredrevs', ()):
raise error.ProgrammingError( raise error.ProgrammingError(
"cannot persist nodemap of a filtered changelog" "cannot persist nodemap of a filtered changelog"
) )
if revlog.nodemap_file is None: if revlog.nodemap_file is None:
if force: if force:
revlog.nodemap_file = get_nodemap_file( revlog.nodemap_file = get_nodemap_file(
revlog.opener, revlog.indexfile revlog.opener, revlog._indexfile
) )
else: else:
msg = "calling persist nodemap on a revlog without the feature enabled" msg = "calling persist nodemap on a revlog without the feature enabled"
raise error.ProgrammingError(msg) raise error.ProgrammingError(msg)
can_incremental = util.safehasattr(revlog.index, "nodemap_data_incremental") can_incremental = util.safehasattr(revlog.index, "nodemap_data_incremental")
ondisk_docket = revlog._nodemap_docket ondisk_docket = revlog._nodemap_docket
feed_data = util.safehasattr(revlog.index, "update_nodemap_data") feed_data = util.safehasattr(revlog.index, "update_nodemap_data")

mercurial/unionrepo.py

class unionchangelog(unionrevlog, changelog.changelog): class unionchangelog(unionrevlog, changelog.changelog):
def __init__(self, opener, opener2): def __init__(self, opener, opener2):
changelog.changelog.__init__(self, opener) changelog.changelog.__init__(self, opener)
linkmapper = None linkmapper = None
changelog2 = changelog.changelog(opener2) changelog2 = changelog.changelog(opener2)
unionrevlog.__init__( unionrevlog.__init__(
self, opener, self.indexfile, changelog2, linkmapper self, opener, self._indexfile, changelog2, linkmapper
) )
class unionmanifest(unionrevlog, manifest.manifestrevlog): class unionmanifest(unionrevlog, manifest.manifestrevlog):
def __init__(self, nodeconstants, opener, opener2, linkmapper): def __init__(self, nodeconstants, opener, opener2, linkmapper):
manifest.manifestrevlog.__init__(self, nodeconstants, opener) manifest.manifestrevlog.__init__(self, nodeconstants, opener)
manifest2 = manifest.manifestrevlog(nodeconstants, opener2) manifest2 = manifest.manifestrevlog(nodeconstants, opener2)
unionrevlog.__init__( unionrevlog.__init__(
self, opener, self._revlog.indexfile, manifest2, linkmapper self, opener, self._revlog._indexfile, manifest2, linkmapper
) )
class unionfilelog(filelog.filelog): class unionfilelog(filelog.filelog):
def __init__(self, opener, path, opener2, linkmapper, repo): def __init__(self, opener, path, opener2, linkmapper, repo):
filelog.filelog.__init__(self, opener, path) filelog.filelog.__init__(self, opener, path)
filelog2 = filelog.filelog(opener2, path) filelog2 = filelog.filelog(opener2, path)
self._revlog = unionrevlog( self._revlog = unionrevlog(
opener, self._revlog.indexfile, filelog2._revlog, linkmapper opener, self._revlog._indexfile, filelog2._revlog, linkmapper
) )
self._repo = repo self._repo = repo
self.repotiprev = self._revlog.repotiprev self.repotiprev = self._revlog.repotiprev
self.revlog2 = self._revlog.revlog2 self.revlog2 = self._revlog.revlog2
def iscensored(self, rev): def iscensored(self, rev):
"""Check if a revision is censored.""" """Check if a revision is censored."""
if rev <= self.repotiprev: if rev <= self.repotiprev:

mercurial/upgrade_utils/engine.py

content is compatible with format of the destination repository. content is compatible with format of the destination repository.
""" """
oldrl = getattr(oldrl, '_revlog', oldrl) oldrl = getattr(oldrl, '_revlog', oldrl)
newrl = _revlogfrompath(destrepo, rl_type, unencodedname) newrl = _revlogfrompath(destrepo, rl_type, unencodedname)
newrl = getattr(newrl, '_revlog', newrl) newrl = getattr(newrl, '_revlog', newrl)
oldvfs = oldrl.opener oldvfs = oldrl.opener
newvfs = newrl.opener newvfs = newrl.opener
oldindex = oldvfs.join(oldrl.indexfile) oldindex = oldvfs.join(oldrl._indexfile)
newindex = newvfs.join(newrl.indexfile) newindex = newvfs.join(newrl._indexfile)
olddata = oldvfs.join(oldrl.datafile) olddata = oldvfs.join(oldrl.datafile)
newdata = newvfs.join(newrl.datafile) newdata = newvfs.join(newrl.datafile)
with newvfs(newrl.indexfile, b'w'): with newvfs(newrl._indexfile, b'w'):
pass # create all the directories pass # create all the directories
util.copyfile(oldindex, newindex) util.copyfile(oldindex, newindex)
copydata = oldrl.opener.exists(oldrl.datafile) copydata = oldrl.opener.exists(oldrl.datafile)
if copydata: if copydata:
util.copyfile(olddata, newdata) util.copyfile(olddata, newdata)
if rl_type & store.FILEFLAGS_FILELOG: if rl_type & store.FILEFLAGS_FILELOG:

tests/test-contrib-perf.t

> "$TESTDIR"/check-perf-code.py contrib/perf.py > "$TESTDIR"/check-perf-code.py contrib/perf.py
contrib/perf.py:\d+: (re) contrib/perf.py:\d+: (re)
> from mercurial import ( > from mercurial import (
import newer module separately in try clause for early Mercurial import newer module separately in try clause for early Mercurial
contrib/perf.py:\d+: (re) contrib/perf.py:\d+: (re)
> from mercurial import ( > from mercurial import (
import newer module separately in try clause for early Mercurial import newer module separately in try clause for early Mercurial
contrib/perf.py:\d+: (re) contrib/perf.py:\d+: (re)
> origindexpath = orig.opener.join(orig.indexfile) > origindexpath = orig.opener.join(indexfile)
use getvfs()/getsvfs() for early Mercurial use getvfs()/getsvfs() for early Mercurial
contrib/perf.py:\d+: (re) contrib/perf.py:\d+: (re)
> origdatapath = orig.opener.join(orig.datafile) > origdatapath = orig.opener.join(orig.datafile)
use getvfs()/getsvfs() for early Mercurial use getvfs()/getsvfs() for early Mercurial
contrib/perf.py:\d+: (re) contrib/perf.py:\d+: (re)
> vfs = vfsmod.vfs(tmpdir) > vfs = vfsmod.vfs(tmpdir)
use getvfs()/getsvfs() for early Mercurial use getvfs()/getsvfs() for early Mercurial
contrib/perf.py:\d+: (re) contrib/perf.py:\d+: (re)
> vfs.options = getattr(orig.opener, 'options', None) > vfs.options = getattr(orig.opener, 'options', None)
use getvfs()/getsvfs() for early Mercurial use getvfs()/getsvfs() for early Mercurial
[1] [1]

tests/test-revlog-raw.py

if rlog.flags(p) & revlog.REVIDX_EXTSTORED == 0 if rlog.flags(p) & revlog.REVIDX_EXTSTORED == 0
] ]
) )
text = None text = None
cachedelta = (deltaparent, rlog.revdiff(deltaparent, r)) cachedelta = (deltaparent, rlog.revdiff(deltaparent, r))
flags = rlog.flags(r) flags = rlog.flags(r)
ifh = dfh = None ifh = dfh = None
try: try:
ifh = dlog.opener(dlog.indexfile, b'a+') ifh = dlog.opener(dlog._indexfile, b'a+')
if not dlog._inline: if not dlog._inline:
dfh = dlog.opener(dlog.datafile, b'a+') dfh = dlog.opener(dlog.datafile, b'a+')
dlog._addrevision( dlog._addrevision(
rlog.node(r), text, tr, r, p1, p2, flags, cachedelta, ifh, dfh rlog.node(r), text, tr, r, p1, p2, flags, cachedelta, ifh, dfh
) )
finally: finally:
if dfh is not None: if dfh is not None:
dfh.close() dfh.close()