( )⚙ D10571 revlog: deal with special "postfix" explicitely

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10571

revlog: deal with special "postfix" explicitely
ClosedPublic

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

Details

Reviewers
indygreg
Alphare
Group Reviewers
hg-reviewers
Commits
rHGc6b8d5d91e73: revlog: deal with special "postfix" explicitely
Summary

revlog usually use a straight forward '.i' and '.d' naming except for two cases
"in-transaction" changelog, and censoring. Our goal is to let the revlog code
deal with the internal of the file naming itself. To do so, we need to start
dealing with these postfix explicitly.

Diff Detail

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

Event Timeline

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

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

Alphare accepted this revision.May 11 2021, 9:40 AM
This revision is now accepted and ready to land.May 11 2021, 9:40 AM
marmoute added a commit: rHGc6b8d5d91e73: revlog: deal with special "postfix" explicitely.May 11 2021, 12:45 PM
Closed by commit rHGc6b8d5d91e73: revlog: deal with special "postfix" explicitely (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/changelog.py (7 lines)
Mmercurial/revlog.py (23 lines)

Diff 27348

mercurial/changelog.py

The ``00changelog.i.a`` file contains index (and possibly inline The ``00changelog.i.a`` file contains index (and possibly inline
revision) data for a transaction that hasn't been finalized yet. revision) data for a transaction that hasn't been finalized yet.
It exists in a separate file to facilitate readers (such as It exists in a separate file to facilitate readers (such as
hooks processes) accessing data before a transaction is finalized. hooks processes) accessing data before a transaction is finalized.
``concurrencychecker`` will be passed to the revlog init function, see ``concurrencychecker`` will be passed to the revlog init function, see
the documentation there. the documentation there.
""" """
indexfile = b'00changelog.i'
if trypending and opener.exists(b'00changelog.i.a'): if trypending and opener.exists(b'00changelog.i.a'):
indexfile = b'00changelog.i.a' postfix = b'a'
else: else:
indexfile = b'00changelog.i' postfix = None
datafile = b'00changelog.d' datafile = b'00changelog.d'
revlog.revlog.__init__( revlog.revlog.__init__(
self, self,
opener, opener,
target=(revlog_constants.KIND_CHANGELOG, None), target=(revlog_constants.KIND_CHANGELOG, None),
postfix=postfix,
indexfile=indexfile, indexfile=indexfile,
datafile=datafile, datafile=datafile,
checkambig=True, checkambig=True,
mmaplargeindex=True, mmaplargeindex=True,
persistentnodemap=opener.options.get(b'persistent-nodemap', False), persistentnodemap=opener.options.get(b'persistent-nodemap', False),
concurrencychecker=concurrencychecker, concurrencychecker=concurrencychecker,
) )

mercurial/revlog.py

""" """
_flagserrorclass = error.RevlogError _flagserrorclass = error.RevlogError
def __init__( def __init__(
self, self,
opener, opener,
target, target,
postfix=None,
indexfile=None, indexfile=None,
datafile=None, datafile=None,
checkambig=False, checkambig=False,
mmaplargeindex=False, mmaplargeindex=False,
censorable=False, censorable=False,
upperboundcomp=None, upperboundcomp=None,
persistentnodemap=False, persistentnodemap=False,
concurrencychecker=None, concurrencychecker=None,
): ):
""" """
create a revlog object create a revlog object
opener is a function that abstracts the file opening operation opener is a function that abstracts the file opening operation
and can be used to implement COW semantics or the like. and can be used to implement COW semantics or the like.
`target`: a (KIND, ID) tuple that identify the content stored in `target`: a (KIND, ID) tuple that identify the content stored in
this revlog. It help the rest of the code to understand what the revlog this revlog. It help the rest of the code to understand what the revlog
is about without having to resort to heuristic and index filename is about without having to resort to heuristic and index filename
analysis. Note: that this must be reliably be set by normal code, but analysis. Note: that this must be reliably be set by normal code, but
that test, debug, or performance measurement code might not set this to that test, debug, or performance measurement code might not set this to
accurate value. accurate value.
""" """
self.upperboundcomp = upperboundcomp self.upperboundcomp = upperboundcomp
if not indexfile.endswith(b'.i'):
raise error.ProgrammingError(
b"revlog's indexfile should end with `.i`"
)
if datafile is None:
datafile = indexfile[:-2] + b".d"
if postfix is not None:
datafile = b'%s.%s' % (datafile, postfix)
if postfix is not None:
indexfile = b'%s.%s' % (indexfile, postfix)
self.indexfile = indexfile self.indexfile = indexfile
self.datafile = datafile or (indexfile[:-2] + b".d") self.datafile = datafile
self.nodemap_file = None self.nodemap_file = None
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
if len(tombstone) > self.rawsize(censorrev): if len(tombstone) > self.rawsize(censorrev):
raise error.Abort( raise error.Abort(
_(b'censor tombstone must be no longer than censored data') _(b'censor tombstone must be no longer than censored data')
) )
# Rewriting the revlog in place is hard. Our strategy for censoring is # Rewriting the revlog in place is hard. Our strategy for censoring is
# 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.
#
newindexfile = self.indexfile + b'.tmpcensored'
newdatafile = self.datafile + b'.tmpcensored'
# 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,
indexfile=newindexfile, postfix=b'tmpcensored',
datafile=newdatafile, 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():