This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9179

errors: name arguments to Abort constructor
ClosedPublic

Authored by martinvonz on Oct 8 2020, 7:10 PM.

Details

Reviewers
durin42
pulkit
Group Reviewers
hg-reviewers
Commits
rHGd2e1dcd4490d: errors: name arguments to Abort constructor

Diff Detail

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

Event Timeline

martinvonz created this revision.Oct 8 2020, 7:10 PM
pulkit accepted this revision.Oct 9 2020, 5:10 AM
This revision is now accepted and ready to land.Oct 9 2020, 5:10 AM
martinvonz added a commit: rHGd2e1dcd4490d: errors: name arguments to Abort constructor.Oct 9 2020, 6:16 AM
Closed by commit rHGd2e1dcd4490d: errors: name arguments to Abort constructor (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.
martinvonz added inline comments.Oct 9 2020, 11:06 AM
tests/test-url.py
395

This needs to be wrapped in pycompat.bytestr() to work on py3. Sorry I didn't notice before. Want me to fold that in in flight or send a follow-up?

Revision Contents
Changeset List

Diff 23120

hgext/largefiles/overrides.py

opts = {} opts = {}
match = orig(ctx, pats, opts, globbed, default, badfn=badfn) match = orig(ctx, pats, opts, globbed, default, badfn=badfn)
return composenormalfilematcher(match, manifest) return composenormalfilematcher(match, manifest)
with extensions.wrappedfunction(scmutil, b'match', normalfilesmatchfn): with extensions.wrappedfunction(scmutil, b'match', normalfilesmatchfn):
try: try:
result = orig(ui, repo, pats, opts, rename) result = orig(ui, repo, pats, opts, rename)
except error.Abort as e: except error.Abort as e:
if pycompat.bytestr(e) != _(b'no files to copy'): if e.message != _(b'no files to copy'):
raise e raise e
else: else:
nonormalfiles = True nonormalfiles = True
result = 0 result = 0
# The first rename can cause our current working directory to be removed. # The first rename can cause our current working directory to be removed.
# In that case there is nothing left to copy/rename so just quit. # In that case there is nothing left to copy/rename so just quit.
try: try:
repo.wvfs.unlinkpath(srclfile, ignoremissing=True) repo.wvfs.unlinkpath(srclfile, ignoremissing=True)
lfdirstate.remove(srclfile) lfdirstate.remove(srclfile)
else: else:
util.copyfile(repo.wjoin(srclfile), repo.wjoin(destlfile)) util.copyfile(repo.wjoin(srclfile), repo.wjoin(destlfile))
lfdirstate.add(destlfile) lfdirstate.add(destlfile)
lfdirstate.write() lfdirstate.write()
except error.Abort as e: except error.Abort as e:
if pycompat.bytestr(e) != _(b'no files to copy'): if e.message != _(b'no files to copy'):
raise e raise e
else: else:
nolfiles = True nolfiles = True
finally: finally:
wlock.release() wlock.release()
if nolfiles and nonormalfiles: if nolfiles and nonormalfiles:
raise error.Abort(_(b'no files to copy')) raise error.Abort(_(b'no files to copy'))

hgext/narrow/narrowwirepeer.py

ellipses, ellipses,
) )
else: else:
narrowbundle2.generate_ellipses_bundle2_for_widening( narrowbundle2.generate_ellipses_bundle2_for_widening(
bundler, repo, oldmatch, newmatch, cgversion, common, known, bundler, repo, oldmatch, newmatch, cgversion, common, known,
) )
except error.Abort as exc: except error.Abort as exc:
bundler = bundle2.bundle20(repo.ui) bundler = bundle2.bundle20(repo.ui)
manargs = [(b'message', pycompat.bytestr(exc))] manargs = [(b'message', exc.message)]
advargs = [] advargs = []
if exc.hint is not None: if exc.hint is not None:
advargs.append((b'hint', exc.hint)) advargs.append((b'hint', exc.hint))
bundler.addpart(bundle2.bundlepart(b'error:abort', manargs, advargs)) bundler.addpart(bundle2.bundlepart(b'error:abort', manargs, advargs))
preferuncompressed = True preferuncompressed = True
chunks = bundler.getchunks() chunks = bundler.getchunks()
return wireprototypes.streamres( return wireprototypes.streamres(

mercurial/bundle2.py

b'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False b'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False
) )
part.addparam(b'return', b'%i' % ret, mandatory=False) part.addparam(b'return', b'%i' % ret, mandatory=False)
try: try:
real_part.validate() real_part.validate()
except error.Abort as e: except error.Abort as e:
raise error.Abort( raise error.Abort(
_(b'bundle at %s is corrupted:\n%s') _(b'bundle at %s is corrupted:\n%s')
% (util.hidepassword(raw_url), bytes(e)) % (util.hidepassword(raw_url), e.message)
) )
assert not inpart.read() assert not inpart.read()
@parthandler(b'reply:changegroup', (b'return', b'in-reply-to')) @parthandler(b'reply:changegroup', (b'return', b'in-reply-to'))
def handlereplychangegroup(op, inpart): def handlereplychangegroup(op, inpart):
ret = int(inpart.params[b'return']) ret = int(inpart.params[b'return'])
replyto = int(inpart.params[b'in-reply-to']) replyto = int(inpart.params[b'in-reply-to'])

mercurial/chgserver.py

try: try:
self.ui, lui = _loadnewui(self.ui, args, self.cdebug) self.ui, lui = _loadnewui(self.ui, args, self.cdebug)
except error.ParseError as inst: except error.ParseError as inst:
dispatch._formatparse(self.ui.warn, inst) dispatch._formatparse(self.ui.warn, inst)
self.ui.flush() self.ui.flush()
self.cresult.write(b'exit 255') self.cresult.write(b'exit 255')
return return
except error.Abort as inst: except error.Abort as inst:
self.ui.error(_(b"abort: %s\n") % inst) self.ui.error(_(b"abort: %s\n") % inst.message)
if inst.hint: if inst.hint:
self.ui.error(_(b"(%s)\n") % inst.hint) self.ui.error(_(b"(%s)\n") % inst.hint)
self.ui.flush() self.ui.flush()
self.cresult.write(b'exit 255') self.cresult.write(b'exit 255')
return return
newhash = hashstate.fromui(lui, self.hashstate.mtimepaths) newhash = hashstate.fromui(lui, self.hashstate.mtimepaths)
insts = [] insts = []
if newhash.mtimehash != self.hashstate.mtimehash: if newhash.mtimehash != self.hashstate.mtimehash:

mercurial/commandserver.py

sv = None sv = None
try: try:
sv = createcmdserver(repo, conn, fin, fout, prereposetups) sv = createcmdserver(repo, conn, fin, fout, prereposetups)
try: try:
sv.serve() sv.serve()
# handle exceptions that may be raised by command server. most of # handle exceptions that may be raised by command server. most of
# known exceptions are caught by dispatch. # known exceptions are caught by dispatch.
except error.Abort as inst: except error.Abort as inst:
ui.error(_(b'abort: %s\n') % inst) ui.error(_(b'abort: %s\n') % inst.message)
except IOError as inst: except IOError as inst:
if inst.errno != errno.EPIPE: if inst.errno != errno.EPIPE:
raise raise
except KeyboardInterrupt: except KeyboardInterrupt:
pass pass
finally: finally:
sv.cleanup() sv.cleanup()
except: # re-raises except: # re-raises

mercurial/crecord.py

patch.write(diffhelptext + hunkhelptext) patch.write(diffhelptext + hunkhelptext)
chunk.header.write(patch) chunk.header.write(patch)
chunk.write(patch) chunk.write(patch)
# start the editor and wait for it to complete # start the editor and wait for it to complete
try: try:
patch = self.ui.edit(patch.getvalue(), b"", action=b"diff") patch = self.ui.edit(patch.getvalue(), b"", action=b"diff")
except error.Abort as exc: except error.Abort as exc:
self.errorstr = stringutil.forcebytestr(exc) self.errorstr = exc.message
return None return None
finally: finally:
self.stdscr.clear() self.stdscr.clear()
self.stdscr.refresh() self.stdscr.refresh()
# remove comment lines # remove comment lines
patch = [ patch = [
line + b'\n' line + b'\n'

mercurial/debugcommands.py

problems += 1 problems += 1
# check username # check username
username = None username = None
err = None err = None
try: try:
username = ui.username() username = ui.username()
except error.Abort as e: except error.Abort as e:
err = stringutil.forcebytestr(e) err = e.message
problems += 1 problems += 1
fm.condwrite( fm.condwrite(
username, b'username', _(b"checking username (%s)\n"), username username, b'username', _(b"checking username (%s)\n"), username
) )
fm.condwrite( fm.condwrite(
err, err,
b'usernameerror', b'usernameerror',

mercurial/dispatch.py

req.ui.fin = req.fin req.ui.fin = req.fin
if req.fout: if req.fout:
req.ui.fout = req.fout req.ui.fout = req.fout
if req.ferr: if req.ferr:
req.ui.ferr = req.ferr req.ui.ferr = req.ferr
if req.fmsg: if req.fmsg:
req.ui.fmsg = req.fmsg req.ui.fmsg = req.fmsg
except error.Abort as inst: except error.Abort as inst:
ferr.write(_(b"abort: %s\n") % inst) ferr.write(_(b"abort: %s\n") % inst.message)
if inst.hint: if inst.hint:
ferr.write(_(b"(%s)\n") % inst.hint) ferr.write(_(b"(%s)\n") % inst.hint)
return -1 return -1
except error.ParseError as inst: except error.ParseError as inst:
_formatparse(ferr.write, inst) _formatparse(ferr.write, inst)
return -1 return -1
msg = _formatargs(req.args) msg = _formatargs(req.args)

mercurial/error.py

) )
% opname, % opname,
) )
class Abort(Hint, Exception): class Abort(Hint, Exception):
"""Raised if a command needs to print an error and exit.""" """Raised if a command needs to print an error and exit."""
__bytes__ = _tobytes def __init__(self, message, hint=None):
self.message = message
self.hint = hint
# Pass the message into the Exception constructor to help extensions
# that look for exc.args[0].
Exception.__init__(self, message)
def __bytes__(self):
return self.message
if pycompat.ispy3: if pycompat.ispy3:
def __str__(self): def __str__(self):
# the output would be unreadable if the message was translated, # the output would be unreadable if the message was translated,
# but do not replace it with encoding.strfromlocal(), which # but do not replace it with encoding.strfromlocal(), which
# may raise another exception. # may raise another exception.
return pycompat.sysstr(self.__bytes__()) return pycompat.sysstr(self.__bytes__())

mercurial/hgweb/hgweb_mod.py

return rctx.sendtemplate(b'error', error=msg) return rctx.sendtemplate(b'error', error=msg)
except (error.RepoError, error.StorageError) as e: except (error.RepoError, error.StorageError) as e:
res.status = b'500 Internal Server Error' res.status = b'500 Internal Server Error'
res.headers[b'Content-Type'] = ctype res.headers[b'Content-Type'] = ctype
return rctx.sendtemplate(b'error', error=pycompat.bytestr(e)) return rctx.sendtemplate(b'error', error=pycompat.bytestr(e))
except error.Abort as e: except error.Abort as e:
res.status = b'403 Forbidden' res.status = b'403 Forbidden'
res.headers[b'Content-Type'] = ctype res.headers[b'Content-Type'] = ctype
return rctx.sendtemplate(b'error', error=pycompat.bytestr(e)) return rctx.sendtemplate(b'error', error=e.message)
except ErrorResponse as e: except ErrorResponse as e:
for k, v in e.headers: for k, v in e.headers:
res.headers[k] = v res.headers[k] = v
res.status = statusmessage(e.code, pycompat.bytestr(e)) res.status = statusmessage(e.code, pycompat.bytestr(e))
res.headers[b'Content-Type'] = ctype res.headers[b'Content-Type'] = ctype
return rctx.sendtemplate(b'error', error=pycompat.bytestr(e)) return rctx.sendtemplate(b'error', error=pycompat.bytestr(e))
def check_perm(self, rctx, req, op): def check_perm(self, rctx, req, op):

mercurial/match.py

includepats = readpatternfile(fullpath, warn) includepats = readpatternfile(fullpath, warn)
for k, p, source in _donormalize( for k, p, source in _donormalize(
includepats, default, root, cwd, auditor, warn includepats, default, root, cwd, auditor, warn
): ):
kindpats.append((k, p, source or pat)) kindpats.append((k, p, source or pat))
except error.Abort as inst: except error.Abort as inst:
raise error.Abort( raise error.Abort(
b'%s: %s' b'%s: %s'
% (pat, inst[0]) # pytype: disable=unsupported-operands % (
pat,
inst.message,
) # pytype: disable=unsupported-operands
) )
except IOError as inst: except IOError as inst:
if warn: if warn:
warn( warn(
_(b"skipping unreadable pattern file '%s': %s\n") _(b"skipping unreadable pattern file '%s': %s\n")
% (pat, stringutil.forcebytestr(inst.strerror)) % (pat, stringutil.forcebytestr(inst.strerror))
) )
continue continue

mercurial/scmutil.py

except error.InterventionRequired as inst: except error.InterventionRequired as inst:
ui.error(b"%s\n" % inst) ui.error(b"%s\n" % inst)
if inst.hint: if inst.hint:
ui.error(_(b"(%s)\n") % inst.hint) ui.error(_(b"(%s)\n") % inst.hint)
return 1 return 1
except error.WdirUnsupported: except error.WdirUnsupported:
ui.error(_(b"abort: working directory revision cannot be specified\n")) ui.error(_(b"abort: working directory revision cannot be specified\n"))
except error.Abort as inst: except error.Abort as inst:
ui.error(_(b"abort: %s\n") % inst) ui.error(_(b"abort: %s\n") % inst.message)
if inst.hint: if inst.hint:
ui.error(_(b"(%s)\n") % inst.hint) ui.error(_(b"(%s)\n") % inst.hint)
except ImportError as inst: except ImportError as inst:
ui.error(_(b"abort: %s!\n") % stringutil.forcebytestr(inst)) ui.error(_(b"abort: %s!\n") % stringutil.forcebytestr(inst))
m = stringutil.forcebytestr(inst).split()[-1] m = stringutil.forcebytestr(inst).split()[-1]
if m in b"mpatch bdiff".split(): if m in b"mpatch bdiff".split():
ui.error(_(b"(did you forget to compile extensions?)\n")) ui.error(_(b"(did you forget to compile extensions?)\n"))
elif m in b"zlib".split(): elif m in b"zlib".split():

mercurial/subrepo.py

try: try:
res = func(self, *args, **kargs) res = func(self, *args, **kargs)
except SubrepoAbort as ex: except SubrepoAbort as ex:
# This exception has already been handled # This exception has already been handled
raise ex raise ex
except error.Abort as ex: except error.Abort as ex:
subrepo = subrelpath(self) subrepo = subrelpath(self)
errormsg = ( errormsg = (
stringutil.forcebytestr(ex) ex.message + b' ' + _(b'(in subrepository "%s")') % subrepo
+ b' '
+ _(b'(in subrepository "%s")') % subrepo
) )
# avoid handling this exception by raising a SubrepoAbort exception # avoid handling this exception by raising a SubrepoAbort exception
raise SubrepoAbort( raise SubrepoAbort(
errormsg, hint=ex.hint, subrepo=subrepo, cause=sys.exc_info() errormsg, hint=ex.hint, subrepo=subrepo, cause=sys.exc_info()
) )
return res return res
return decoratedmethod return decoratedmethod

mercurial/wireprotov1server.py

info, chunks = exchange.getbundlechunks( info, chunks = exchange.getbundlechunks(
repo, b'serve', **pycompat.strkwargs(opts) repo, b'serve', **pycompat.strkwargs(opts)
) )
prefercompressed = info.get(b'prefercompressed', True) prefercompressed = info.get(b'prefercompressed', True)
except error.Abort as exc: except error.Abort as exc:
# cleanly forward Abort error to the client # cleanly forward Abort error to the client
if not exchange.bundle2requested(opts.get(b'bundlecaps')): if not exchange.bundle2requested(opts.get(b'bundlecaps')):
if proto.name == b'http-v1': if proto.name == b'http-v1':
return wireprototypes.ooberror(pycompat.bytestr(exc) + b'\n') return wireprototypes.ooberror(exc.message + b'\n')
raise # cannot do better for bundle1 + ssh raise # cannot do better for bundle1 + ssh
# bundle2 request expect a bundle2 reply # bundle2 request expect a bundle2 reply
bundler = bundle2.bundle20(repo.ui) bundler = bundle2.bundle20(repo.ui)
manargs = [(b'message', pycompat.bytestr(exc))] manargs = [(b'message', exc.message)]
advargs = [] advargs = []
if exc.hint is not None: if exc.hint is not None:
advargs.append((b'hint', exc.hint)) advargs.append((b'hint', exc.hint))
bundler.addpart(bundle2.bundlepart(b'error:abort', manargs, advargs)) bundler.addpart(bundle2.bundlepart(b'error:abort', manargs, advargs))
chunks = bundler.getchunks() chunks = bundler.getchunks()
prefercompressed = False prefercompressed = False
return wireprototypes.streamres( return wireprototypes.streamres(
if not getattr(exc, 'duringunbundle2', False): if not getattr(exc, 'duringunbundle2', False):
try: try:
raise raise
except error.Abort as exc: except error.Abort as exc:
# The old code we moved used procutil.stderr directly. # The old code we moved used procutil.stderr directly.
# We did not change it to minimise code change. # We did not change it to minimise code change.
# This need to be moved to something proper. # This need to be moved to something proper.
# Feel free to do it. # Feel free to do it.
procutil.stderr.write(b"abort: %s\n" % exc) procutil.stderr.write(b"abort: %s\n" % exc.message)
if exc.hint is not None: if exc.hint is not None:
procutil.stderr.write(b"(%s)\n" % exc.hint) procutil.stderr.write(b"(%s)\n" % exc.hint)
procutil.stderr.flush() procutil.stderr.flush()
return wireprototypes.pushres( return wireprototypes.pushres(
0, output.getvalue() if output else b'' 0, output.getvalue() if output else b''
) )
except error.PushRaced: except error.PushRaced:
return wireprototypes.pusherr( return wireprototypes.pusherr(
part.addparam(b'ret', exc.ret, mandatory=False) part.addparam(b'ret', exc.ret, mandatory=False)
except error.BundleValueError as exc: except error.BundleValueError as exc:
errpart = bundler.newpart(b'error:unsupportedcontent') errpart = bundler.newpart(b'error:unsupportedcontent')
if exc.parttype is not None: if exc.parttype is not None:
errpart.addparam(b'parttype', exc.parttype) errpart.addparam(b'parttype', exc.parttype)
if exc.params: if exc.params:
errpart.addparam(b'params', b'\0'.join(exc.params)) errpart.addparam(b'params', b'\0'.join(exc.params))
except error.Abort as exc: except error.Abort as exc:
manargs = [(b'message', stringutil.forcebytestr(exc))] manargs = [(b'message', exc.message)]
advargs = [] advargs = []
if exc.hint is not None: if exc.hint is not None:
advargs.append((b'hint', exc.hint)) advargs.append((b'hint', exc.hint))
bundler.addpart( bundler.addpart(
bundle2.bundlepart(b'error:abort', manargs, advargs) bundle2.bundlepart(b'error:abort', manargs, advargs)
) )
except error.PushRaced as exc: except error.PushRaced as exc:
bundler.newpart( bundler.newpart(
b'error:pushraced', b'error:pushraced',
[(b'message', stringutil.forcebytestr(exc))], [(b'message', stringutil.forcebytestr(exc))],
) )
return wireprototypes.streamreslegacy(gen=bundler.getchunks()) return wireprototypes.streamreslegacy(gen=bundler.getchunks())

tests/bruterebase.py

spec = revsetlang.formatspec(b'%ld', subset) spec = revsetlang.formatspec(b'%ld', subset)
tr = repo.transaction(b'rebase') tr = repo.transaction(b'rebase')
tr._report = lambda x: 0 # hide "transaction abort" tr._report = lambda x: 0 # hide "transaction abort"
ui.pushbuffer() ui.pushbuffer()
try: try:
rebase.rebase(ui, repo, dest=dest, rev=[spec]) rebase.rebase(ui, repo, dest=dest, rev=[spec])
except error.Abort as ex: except error.Abort as ex:
summary = b'ABORT: %s' % ex summary = b'ABORT: %s' % ex.message
except Exception as ex: except Exception as ex:
summary = b'CRASH: %s' % ex summary = b'CRASH: %s' % ex
else: else:
# short summary about new nodes # short summary about new nodes
cl = repo.changelog cl = repo.changelog
descs = [] descs = []
for rev in xrange(repolen, len(repo)): for rev in xrange(repolen, len(repo)):
desc = b'%s:' % getdesc(rev) desc = b'%s:' % getdesc(rev)

tests/test-url.py

>>> url(b'./foo:bar') >>> url(b'./foo:bar')
<url path: './foo:bar'> <url path: './foo:bar'>
Non-localhost file URL: Non-localhost file URL:
>>> try: >>> try:
... u = url(b'file://mercurial-scm.org/foo') ... u = url(b'file://mercurial-scm.org/foo')
... except error.Abort as e: ... except error.Abort as e:
... forcebytestr(e) ... e.message
martinvonzAuthorUnsubmitted
Done

This needs to be wrapped in pycompat.bytestr() to work on py3. Sorry I didn't notice before. Want me to fold that in in flight or send a follow-up?

martinvonz: This needs to be wrapped in `pycompat.bytestr()` to work on py3. Sorry I didn't notice before.
'file:// URLs can only refer to localhost' 'file:// URLs can only refer to localhost'
Empty URL: Empty URL:
>>> u = url(b'') >>> u = url(b'')
>>> u >>> u
<url path: ''> <url path: ''>
>>> str(u) >>> str(u)