This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4655

global: replace most uses of RevlogError with StorageError (API)
ClosedPublic

Authored by indygreg on Sep 18 2018, 8:06 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGb63dee7bd0d9: global: replace most uses of RevlogError with StorageError (API)
Summary

When catching errors in storage, we should be catching
StorageError instead of RevlogError. When throwing errors related
to storage, we shouldn't be using RevlogError unless we know
the error stemmed from revlogs. And we only reliably know that
if we're in revlog.py or are inheriting from a type defined in
revlog.py.

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.

Revision Contents
Changeset List

Diff 11281

hgext/lfs/blobstore.py

url = util.url(bytes(defaulturl)) url = util.url(bytes(defaulturl))
repo.ui.note(_('lfs: assuming remote store: %s\n') % url) repo.ui.note(_('lfs: assuming remote store: %s\n') % url)
scheme = url.scheme scheme = url.scheme
if scheme not in _storemap: if scheme not in _storemap:
raise error.Abort(_('lfs: unknown url scheme: %s') % scheme) raise error.Abort(_('lfs: unknown url scheme: %s') % scheme)
return _storemap[scheme](repo, url) return _storemap[scheme](repo, url)
class LfsRemoteError(error.RevlogError): class LfsRemoteError(error.StorageError):
pass pass
class LfsCorruptionError(error.Abort): class LfsCorruptionError(error.Abort):
"""Raised when a corrupt blob is detected, aborting an operation """Raised when a corrupt blob is detected, aborting an operation
It exists to allow specialized handling on the server side.""" It exists to allow specialized handling on the server side."""

hgext/lfs/pointer.py

from mercurial import ( from mercurial import (
error, error,
pycompat, pycompat,
) )
from mercurial.utils import ( from mercurial.utils import (
stringutil, stringutil,
) )
class InvalidPointer(error.RevlogError): class InvalidPointer(error.StorageError):
pass pass
class gitlfspointer(dict): class gitlfspointer(dict):
VERSION = 'https://git-lfs.github.com/spec/v1' VERSION = 'https://git-lfs.github.com/spec/v1'
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
self['version'] = self.VERSION self['version'] = self.VERSION
super(gitlfspointer, self).__init__(*args) super(gitlfspointer, self).__init__(*args)

hgext/transplant.py

return False return False
return True return True
return matchfn return matchfn
def hasnode(repo, node): def hasnode(repo, node):
try: try:
return repo.changelog.rev(node) is not None return repo.changelog.rev(node) is not None
except error.RevlogError: except error.StorageError:
return False return False
def browserevs(ui, repo, nodes, opts): def browserevs(ui, repo, nodes, opts):
'''interactively transplant changesets''' '''interactively transplant changesets'''
displayer = logcmdutil.changesetdisplayer(ui, repo, opts) displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
transplants = [] transplants = []
merges = [] merges = []
prompt = _('apply changeset? [ynmpcq?]:' prompt = _('apply changeset? [ynmpcq?]:'

mercurial/changelog.py

# into a str object and the cached UTF-8 string is thus lost. # into a str object and the cached UTF-8 string is thus lost.
user, desc = encoding.fromlocal(user), encoding.fromlocal(desc) user, desc = encoding.fromlocal(user), encoding.fromlocal(desc)
user = user.strip() user = user.strip()
# An empty username or a username with a "\n" will make the # An empty username or a username with a "\n" will make the
# revision text contain two "\n\n" sequences -> corrupt # revision text contain two "\n\n" sequences -> corrupt
# repository since read cannot unpack the revision. # repository since read cannot unpack the revision.
if not user: if not user:
raise error.RevlogError(_("empty username")) raise error.StorageError(_("empty username"))
if "\n" in user: if "\n" in user:
raise error.RevlogError(_("username %r contains a newline") raise error.StorageError(_("username %r contains a newline")
% pycompat.bytestr(user)) % pycompat.bytestr(user))
desc = stripdesc(desc) desc = stripdesc(desc)
if date: if date:
parseddate = "%d %d" % dateutil.parsedate(date) parseddate = "%d %d" % dateutil.parsedate(date)
else: else:
parseddate = "%d %d" % dateutil.makedate() parseddate = "%d %d" % dateutil.makedate()
if extra: if extra:
branch = extra.get("branch") branch = extra.get("branch")
if branch in ("default", ""): if branch in ("default", ""):
del extra["branch"] del extra["branch"]
elif branch in (".", "null", "tip"): elif branch in (".", "null", "tip"):
raise error.RevlogError(_('the name \'%s\' is reserved') raise error.StorageError(_('the name \'%s\' is reserved')
% branch) % branch)
if extra: if extra:
extra = encodeextra(extra) extra = encodeextra(extra)
parseddate = "%s %s" % (parseddate, extra) parseddate = "%s %s" % (parseddate, extra)
l = [hex(manifest), user, parseddate] + sorted(files) + ["", desc] l = [hex(manifest), user, parseddate] + sorted(files) + ["", desc]
text = "\n".join(l) text = "\n".join(l)
return self.addrevision(text, transaction, len(self), p1, p2) return self.addrevision(text, transaction, len(self), p1, p2)
def branchinfo(self, rev): def branchinfo(self, rev):
"""return the branch name and open/close state of a revision """return the branch name and open/close state of a revision
This function exists because creating a changectx object This function exists because creating a changectx object
just to access this is costly.""" just to access this is costly."""
extra = self.read(rev)[5] extra = self.read(rev)[5]
return encoding.tolocal(extra.get("branch")), 'close' in extra return encoding.tolocal(extra.get("branch")), 'close' in extra

mercurial/error.py

self.key = key self.key = key
self.new = new self.new = new
self.old = old self.old = old
self.ret = ret self.ret = ret
# no i18n expected to be processed into a better message # no i18n expected to be processed into a better message
Abort.__init__(self, 'failed to update value for "%s/%s"' Abort.__init__(self, 'failed to update value for "%s/%s"'
% (namespace, key)) % (namespace, key))
class CensoredNodeError(RevlogError): class CensoredNodeError(StorageError):
"""error raised when content verification fails on a censored node """error raised when content verification fails on a censored node
Also contains the tombstone data substituted for the uncensored data. Also contains the tombstone data substituted for the uncensored data.
""" """
def __init__(self, filename, node, tombstone): def __init__(self, filename, node, tombstone):
from .node import short from .node import short
RevlogError.__init__(self, '%s:%s' % (filename, short(node))) StorageError.__init__(self, '%s:%s' % (filename, short(node)))
self.tombstone = tombstone self.tombstone = tombstone
class CensoredBaseError(RevlogError): class CensoredBaseError(StorageError):
"""error raised when a delta is rejected because its base is censored """error raised when a delta is rejected because its base is censored
A delta based on a censored revision must be formed as single patch A delta based on a censored revision must be formed as single patch
operation which replaces the entire base with new content. This ensures operation which replaces the entire base with new content. This ensures
the delta may be applied by clones which have not censored the base. the delta may be applied by clones which have not censored the base.
""" """
class InvalidBundleSpecification(Exception): class InvalidBundleSpecification(Exception):

mercurial/hgweb/hgweb_mod.py

msg = pycompat.bytestr(err) msg = pycompat.bytestr(err)
if (util.safehasattr(err, 'name') and if (util.safehasattr(err, 'name') and
not isinstance(err, error.ManifestLookupError)): not isinstance(err, error.ManifestLookupError)):
msg = 'revision not found: %s' % err.name msg = 'revision not found: %s' % err.name
res.status = '404 Not Found' res.status = '404 Not Found'
res.headers['Content-Type'] = ctype res.headers['Content-Type'] = ctype
return rctx.sendtemplate('error', error=msg) return rctx.sendtemplate('error', error=msg)
except (error.RepoError, error.RevlogError) as e: except (error.RepoError, error.StorageError) as e:
res.status = '500 Internal Server Error' res.status = '500 Internal Server Error'
res.headers['Content-Type'] = ctype res.headers['Content-Type'] = ctype
return rctx.sendtemplate('error', error=pycompat.bytestr(e)) return rctx.sendtemplate('error', error=pycompat.bytestr(e))
except error.Abort as e: except error.Abort as e:
res.status = '403 Forbidden' res.status = '403 Forbidden'
res.headers['Content-Type'] = ctype res.headers['Content-Type'] = ctype
return rctx.sendtemplate('error', error=pycompat.bytestr(e)) return rctx.sendtemplate('error', error=pycompat.bytestr(e))
except ErrorResponse as e: except ErrorResponse as e:

mercurial/manifest.py

return (lo, end + 1) return (lo, end + 1)
else: else:
return (lo, lo) return (lo, lo)
def _checkforbidden(l): def _checkforbidden(l):
"""Check filenames for illegal characters.""" """Check filenames for illegal characters."""
for f in l: for f in l:
if '\n' in f or '\r' in f: if '\n' in f or '\r' in f:
raise error.RevlogError( raise error.StorageError(
_("'\\n' and '\\r' disallowed in filenames: %r") _("'\\n' and '\\r' disallowed in filenames: %r")
% pycompat.bytestr(f)) % pycompat.bytestr(f))
# apply the changes collected during the bisect loop to our addlist # apply the changes collected during the bisect loop to our addlist
# return a delta suitable for addrevision # return a delta suitable for addrevision
def _addlistdelta(addlist, x): def _addlistdelta(addlist, x):
# for large addlist arrays, building a new array is cheaper # for large addlist arrays, building a new array is cheaper

mercurial/revlogutils/deltas.py

fulltext = mdiff.patch(basetext, delta) fulltext = mdiff.patch(basetext, delta)
try: try:
res = revlog._processflags(fulltext, flags, 'read', raw=True) res = revlog._processflags(fulltext, flags, 'read', raw=True)
fulltext, validatehash = res fulltext, validatehash = res
if validatehash: if validatehash:
revlog.checkhash(fulltext, expectednode, p1=p1, p2=p2) revlog.checkhash(fulltext, expectednode, p1=p1, p2=p2)
if flags & REVIDX_ISCENSORED: if flags & REVIDX_ISCENSORED:
raise error.RevlogError(_('node %s is not censored') % expectednode) raise error.StorageError(_('node %s is not censored') %
expectednode)
except error.CensoredNodeError: except error.CensoredNodeError:
# must pass the censored index flag to add censored revisions # must pass the censored index flag to add censored revisions
if not flags & REVIDX_ISCENSORED: if not flags & REVIDX_ISCENSORED:
raise raise
return fulltext return fulltext
@attr.s(slots=True, frozen=True) @attr.s(slots=True, frozen=True)
class _deltainfo(object): class _deltainfo(object):

mercurial/scmutil.py

if not isinstance(msg, bytes): if not isinstance(msg, bytes):
ui.error(" %r\n" % (msg,)) ui.error(" %r\n" % (msg,))
elif not msg: elif not msg:
ui.error(_(" empty string\n")) ui.error(_(" empty string\n"))
else: else:
ui.error("\n%r\n" % pycompat.bytestr(stringutil.ellipsis(msg))) ui.error("\n%r\n" % pycompat.bytestr(stringutil.ellipsis(msg)))
except error.CensoredNodeError as inst: except error.CensoredNodeError as inst:
ui.error(_("abort: file censored %s!\n") % inst) ui.error(_("abort: file censored %s!\n") % inst)
except error.RevlogError as inst: except error.StorageError as inst:
ui.error(_("abort: %s!\n") % inst) ui.error(_("abort: %s!\n") % inst)
except error.InterventionRequired as inst: except error.InterventionRequired as inst:
ui.error("%s\n" % inst) ui.error("%s\n" % inst)
if inst.hint: if inst.hint:
ui.error(_("(%s)\n") % inst.hint) ui.error(_("(%s)\n") % inst.hint)
return 1 return 1
except error.WdirUnsupported: except error.WdirUnsupported:
ui.error(_("abort: working directory revision cannot be specified\n")) ui.error(_("abort: working directory revision cannot be specified\n"))

mercurial/util.py

The returned data should have a header uniquely identifying this The returned data should have a header uniquely identifying this
compression format so decompression can be routed to this engine. compression format so decompression can be routed to this engine.
This header should be identified by the ``revlogheader()`` return This header should be identified by the ``revlogheader()`` return
value. value.
The object has a ``decompress(data)`` method that decompresses The object has a ``decompress(data)`` method that decompresses
data. The method will only be called if ``data`` begins with data. The method will only be called if ``data`` begins with
``revlogheader()``. The method should return the raw, uncompressed ``revlogheader()``. The method should return the raw, uncompressed
data or raise a ``RevlogError``. data or raise a ``StorageError``.
The object is reusable but is not thread safe. The object is reusable but is not thread safe.
""" """
raise NotImplementedError() raise NotImplementedError()
class _CompressedStreamReader(object): class _CompressedStreamReader(object):
def __init__(self, fh): def __init__(self, fh):
if safehasattr(fh, 'unbufferedread'): if safehasattr(fh, 'unbufferedread'):
if sum(map(len, parts)) < insize: if sum(map(len, parts)) < insize:
return ''.join(parts) return ''.join(parts)
return None return None
def decompress(self, data): def decompress(self, data):
try: try:
return zlib.decompress(data) return zlib.decompress(data)
except zlib.error as e: except zlib.error as e:
raise error.RevlogError(_('revlog decompress error: %s') % raise error.StorageError(_('revlog decompress error: %s') %
stringutil.forcebytestr(e)) stringutil.forcebytestr(e))
def revlogcompressor(self, opts=None): def revlogcompressor(self, opts=None):
return self.zlibrevlogcompressor() return self.zlibrevlogcompressor()
compengines.register(_zlibengine()) compengines.register(_zlibengine())
class _bz2engine(compressionengine): class _bz2engine(compressionengine):
def name(self): def name(self):
chunk = dobj.decompress(data[pos:pos2]) chunk = dobj.decompress(data[pos:pos2])
if chunk: if chunk:
chunks.append(chunk) chunks.append(chunk)
pos = pos2 pos = pos2
# Frame should be exhausted, so no finish() API. # Frame should be exhausted, so no finish() API.
return ''.join(chunks) return ''.join(chunks)
except Exception as e: except Exception as e:
raise error.RevlogError(_('revlog decompress error: %s') % raise error.StorageError(_('revlog decompress error: %s') %
stringutil.forcebytestr(e)) stringutil.forcebytestr(e))
def revlogcompressor(self, opts=None): def revlogcompressor(self, opts=None):
opts = opts or {} opts = opts or {}
return self.zstdrevlogcompressor(self._module, return self.zstdrevlogcompressor(self._module,
level=opts.get('level', 3)) level=opts.get('level', 3))
compengines.register(_zstdengine()) compengines.register(_zstdengine())

mercurial/verify.py

if linkrevs: if linkrevs:
lr = linkrevs[0] lr = linkrevs[0]
else: else:
lr = None lr = None
try: try:
fl = repo.file(f) fl = repo.file(f)
except error.RevlogError as e: except error.StorageError as e:
self.err(lr, _("broken revlog! (%s)") % e, f) self.err(lr, _("broken revlog! (%s)") % e, f)
continue continue
for ff in fl.files(): for ff in fl.files():
try: try:
storefiles.remove(ff) storefiles.remove(ff)
except KeyError: except KeyError:
if self.warnorphanstorefiles: if self.warnorphanstorefiles:

tests/simplestorerepo.py

if len(node) != 20: if len(node) != 20:
raise ValueError('expected 20 byte node') raise ValueError('expected 20 byte node')
def validaterev(rev): def validaterev(rev):
if not isinstance(rev, int): if not isinstance(rev, int):
raise ValueError('expected int') raise ValueError('expected int')
class simplestoreerror(error.StorageError):
pass
@interfaceutil.implementer(repository.irevisiondelta) @interfaceutil.implementer(repository.irevisiondelta)
@attr.s(slots=True, frozen=True) @attr.s(slots=True, frozen=True)
class simplestorerevisiondelta(object): class simplestorerevisiondelta(object):
node = attr.ib() node = attr.ib()
p1node = attr.ib() p1node = attr.ib()
p2node = attr.ib() p2node = attr.ib()
basenode = attr.ib() basenode = attr.ib()
linknode = attr.ib() linknode = attr.ib()
node = self.node(rev) node = self.node(rev)
return len(self.revision(node, raw=True)) return len(self.revision(node, raw=True))
def _processflags(self, text, flags, operation, raw=False): def _processflags(self, text, flags, operation, raw=False):
if flags == 0: if flags == 0:
return text, True return text, True
if flags & ~revlog.REVIDX_KNOWN_FLAGS: if flags & ~revlog.REVIDX_KNOWN_FLAGS:
raise error.RevlogError(_("incompatible revision flag '%#x'") % raise simplestoreerror(_("incompatible revision flag '%#x'") %
(flags & ~revlog.REVIDX_KNOWN_FLAGS)) (flags & ~revlog.REVIDX_KNOWN_FLAGS))
validatehash = True validatehash = True
# Depending on the operation (read or write), the order might be # Depending on the operation (read or write), the order might be
# reversed due to non-commutative transforms. # reversed due to non-commutative transforms.
orderedflags = revlog.REVIDX_FLAGS_ORDER orderedflags = revlog.REVIDX_FLAGS_ORDER
if operation == 'write': if operation == 'write':
orderedflags = reversed(orderedflags) orderedflags = reversed(orderedflags)
for flag in orderedflags: for flag in orderedflags:
# If a flagprocessor has been registered for a known flag, apply the # If a flagprocessor has been registered for a known flag, apply the
# related operation transform and update result tuple. # related operation transform and update result tuple.
if flag & flags: if flag & flags:
vhash = True vhash = True
if flag not in revlog._flagprocessors: if flag not in revlog._flagprocessors:
message = _("missing processor for flag '%#x'") % (flag) message = _("missing processor for flag '%#x'") % (flag)
raise error.RevlogError(message) raise simplestoreerror(message)
processor = revlog._flagprocessors[flag] processor = revlog._flagprocessors[flag]
if processor is not None: if processor is not None:
readtransform, writetransform, rawtransform = processor readtransform, writetransform, rawtransform = processor
if raw: if raw:
vhash = rawtransform(self, text) vhash = rawtransform(self, text)
elif operation == 'read': elif operation == 'read':
text, vhash = readtransform(self, text) text, vhash = readtransform(self, text)
else: # write operation else: # write operation
text, vhash = writetransform(self, text) text, vhash = writetransform(self, text)
validatehash = validatehash and vhash validatehash = validatehash and vhash
return text, validatehash 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 != revlog.hash(text, p1, p2): if node != revlog.hash(text, p1, p2):
raise error.RevlogError(_("integrity check failed on %s") % raise simplestoreerror(_("integrity check failed on %s") %
self._path) self._path)
def revision(self, node, raw=False): def revision(self, node, raw=False):
validatenode(node) validatenode(node)
if node == nullid: if node == nullid:
return b'' return b''