| indygreg | |
| Alphare |
| hg-reviewers |
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.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | contrib/perf.py (18 lines) | |||
| M | mercurial/bundlerepo.py (10 lines) | |||
| M | mercurial/changegroup.py (4 lines) | |||
| M | mercurial/changelog.py (20 lines) | |||
| M | mercurial/filelog.py (2 lines) | |||
| M | mercurial/repoview.py (2 lines) | |||
| M | mercurial/revlog.py (88 lines) | |||
| M | mercurial/revlogutils/nodemap.py (2 lines) | |||
| M | mercurial/unionrepo.py (6 lines) | |||
| M | mercurial/upgrade_utils/engine.py (6 lines) | |||
| M | tests/test-contrib-perf.t (2 lines) | |||
| M | tests/test-revlog-raw.py (2 lines) |
| 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) | ||||
| 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 | ||||
| # 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 | ||||
| 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: | ||||
| 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) | ||||
| 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) | ||||
| 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) | ||||
| """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") | ||||
| 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: | ||||
| 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: | ||||
| > "$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] | ||||
| 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() | ||||