This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6799

flagutil: use it in simplestorerepo
ClosedPublic

Authored by marmoute on Sep 7 2019, 5:26 AM.

Details

Reviewers
yuja
durin42
indygreg
Group Reviewers
hg-reviewers
Commits
rHG705428da231f: flagutil: use it in simplestorerepo
Summary

This remove the other code duplication of the _processflags code.

To be honest, this code looks very dead since it is not run by either developer
nor buildbot. However, we update the code to make the task of reviving this less
daunting.

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.Sep 7 2019, 5:26 AM
indygreg accepted this revision.Sep 7 2019, 12:58 PM
This revision is now accepted and ready to land.Sep 7 2019, 12:58 PM
marmoute added a commit: rHG705428da231f: flagutil: use it in simplestorerepo.Sep 7 2019, 1:00 PM
Closed by commit rHG705428da231f: flagutil: use it in simplestorerepo (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mtests/simplestorerepo.py (45 lines)

Diff 16437

tests/simplestorerepo.py

@interfaceutil.implementer(repository.iverifyproblem) @interfaceutil.implementer(repository.iverifyproblem)
@attr.s(frozen=True) @attr.s(frozen=True)
class simplefilestoreproblem(object): class simplefilestoreproblem(object):
warning = attr.ib(default=None) warning = attr.ib(default=None)
error = attr.ib(default=None) error = attr.ib(default=None)
node = attr.ib(default=None) node = attr.ib(default=None)
@interfaceutil.implementer(repository.ifilestorage) @interfaceutil.implementer(repository.ifilestorage)
class filestorage(object): class filestorage(flagutil.flagprocessorsmixin):
"""Implements storage for a tracked path. """Implements storage for a tracked path.
Data is stored in the VFS in a directory corresponding to the tracked Data is stored in the VFS in a directory corresponding to the tracked
path. path.
Index data is stored in an ``index`` file using CBOR. Index data is stored in an ``index`` file using CBOR.
Fulltext data is stored in files having names of the node. Fulltext data is stored in files having names of the node.
""" """
_flagserrorclass = simplestoreerror
def __init__(self, svfs, path): def __init__(self, svfs, path):
self._svfs = svfs self._svfs = svfs
self._path = path self._path = path
self._storepath = b'/'.join([b'data', path]) self._storepath = b'/'.join([b'data', path])
self._indexpath = b'/'.join([self._storepath, b'index']) self._indexpath = b'/'.join([self._storepath, b'index'])
indexdata = self._svfs.tryread(self._indexpath) indexdata = self._svfs.tryread(self._indexpath)
if indexdata: if indexdata:
indexdata = cborutil.decodeall(indexdata) indexdata = cborutil.decodeall(indexdata)
self._indexdata = indexdata or [] self._indexdata = indexdata or []
self._indexbynode = {} self._indexbynode = {}
self._indexbyrev = {} self._indexbyrev = {}
self._index = [] self._index = []
self._refreshindex() self._refreshindex()
self._flagprocessors = dict(flagutil.flagprocessors)
def _refreshindex(self): def _refreshindex(self):
self._indexbynode.clear() self._indexbynode.clear()
self._indexbyrev.clear() self._indexbyrev.clear()
self._index = [] self._index = []
for i, entry in enumerate(self._indexdata): for i, entry in enumerate(self._indexdata):
self._indexbynode[entry[b'node']] = entry self._indexbynode[entry[b'node']] = entry
self._indexbyrev[i] = entry self._indexbyrev[i] = entry
validaterev(rev) validaterev(rev)
if ((self._flags(baserev) & revlog.REVIDX_RAWTEXT_CHANGING_FLAGS) if ((self._flags(baserev) & revlog.REVIDX_RAWTEXT_CHANGING_FLAGS)
or (self._flags(rev) & revlog.REVIDX_RAWTEXT_CHANGING_FLAGS)): or (self._flags(rev) & revlog.REVIDX_RAWTEXT_CHANGING_FLAGS)):
return False return False
return True return True
def _processflags(self, text, flags, operation, raw=False):
if flags == 0:
return text, True
if flags & ~flagutil.REVIDX_KNOWN_FLAGS:
raise simplestoreerror(_("incompatible revision flag '%#x'") %
(flags & ~flagutil.REVIDX_KNOWN_FLAGS))
validatehash = True
# Depending on the operation (read or write), the order might be
# reversed due to non-commutative transforms.
orderedflags = revlog.REVIDX_FLAGS_ORDER
if operation == 'write':
orderedflags = reversed(orderedflags)
for flag in orderedflags:
# If a flagprocessor has been registered for a known flag, apply the
# related operation transform and update result tuple.
if flag & flags:
vhash = True
if flag not in revlog._flagprocessors:
message = _("missing processor for flag '%#x'") % (flag)
raise simplestoreerror(message)
processor = revlog._flagprocessors[flag]
if processor is not None:
readtransform, writetransform, rawtransform = processor
if raw:
vhash = rawtransform(self, text)
elif operation == 'read':
text, vhash = readtransform(self, text)
else: # write operation
text, vhash = writetransform(self, text)
validatehash = validatehash and vhash
return text, validatehash
def checkhash(self, text, node, p1=None, p2=None, rev=None): def checkhash(self, text, node, p1=None, p2=None, rev=None):
if p1 is None and p2 is None: if p1 is None and p2 is None:
p1, p2 = self.parents(node) p1, p2 = self.parents(node)
if node != storageutil.hashrevisionsha1(text, p1, p2): if node != storageutil.hashrevisionsha1(text, p1, p2):
raise simplestoreerror(_("integrity check failed on %s") % raise simplestoreerror(_("integrity check failed on %s") %
self._path) self._path)
def revision(self, nodeorrev, raw=False): def revision(self, nodeorrev, raw=False):