( )⚙ D7108 cleanup: hgdemandimport.tracing accepts strings, not bytes

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7108

cleanup: hgdemandimport.tracing accepts strings, not bytes
ClosedPublic

Authored by durin42 on Oct 15 2019, 11:22 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG101ae8bbfa02: cleanup: hgdemandimport.tracing accepts strings, not bytes
rHGecd3832a6cfd: cleanup: hgdemandimport.tracing accepts strings, not bytes
rHG707a4d56f05a: cleanup: hgdemandimport.tracing accepts strings, not bytes
Summary

This does mean that the resulting traces will have some b'' goo in them on
Python 3, but I think that's a worthwile price to pay since it doesn't break
any tests.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

Diff 17178

mercurial/debugcommands.py

nodes = [repo[r].node() for r in revs] nodes = [repo[r].node() for r in revs]
common, any, hds = setdiscovery.findcommonheads( common, any, hds = setdiscovery.findcommonheads(
ui, repo, remote, ancestorsof=nodes ui, repo, remote, ancestorsof=nodes
) )
return common, hds return common, hds
remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches, revs=None) remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches, revs=None)
localrevs = opts[b'rev'] localrevs = opts[b'rev']
with util.timedcm(b'debug-discovery') as t: with util.timedcm('debug-discovery') as t:
common, hds = doit(localrevs, remoterevs) common, hds = doit(localrevs, remoterevs)
# compute all statistics # compute all statistics
common = set(common) common = set(common)
rheads = set(hds) rheads = set(hds)
lheads = set(repo.heads()) lheads = set(repo.heads())
data = {} data = {}

mercurial/dispatch.py

finally: finally:
if exc is not None: if exc is not None:
raise exc raise exc
def run(): def run():
b"run the command in sys.argv" b"run the command in sys.argv"
initstdio() initstdio()
with tracing.log(b'parse args into request'): with tracing.log('parse args into request'):
req = request(pycompat.sysargv[1:]) req = request(pycompat.sysargv[1:])
err = None err = None
try: try:
status = dispatch(req) status = dispatch(req)
except error.StdioError as e: except error.StdioError as e:
err = e err = e
status = -1 status = -1
def _formatargs(args): def _formatargs(args):
return b' '.join(procutil.shellquote(a) for a in args) return b' '.join(procutil.shellquote(a) for a in args)
def dispatch(req): def dispatch(req):
"""run the command specified in req.args; returns an integer status code""" """run the command specified in req.args; returns an integer status code"""
with tracing.log(b'dispatch.dispatch'): with tracing.log('dispatch.dispatch'):
if req.ferr: if req.ferr:
ferr = req.ferr ferr = req.ferr
elif req.ui: elif req.ui:
ferr = req.ui.ferr ferr = req.ui.ferr
else: else:
ferr = procutil.stderr ferr = procutil.stderr
try: try:
try: try:
req._runexithandlers() req._runexithandlers()
except: # exiting, so no re-raises except: # exiting, so no re-raises
ret = ret or -1 ret = ret or -1
return ret return ret
def _runcatch(req): def _runcatch(req):
with tracing.log(b'dispatch._runcatch'): with tracing.log('dispatch._runcatch'):
def catchterm(*args): def catchterm(*args):
raise error.SignalInterrupt raise error.SignalInterrupt
ui = req.ui ui = req.ui
try: try:
for name in b'SIGBREAK', b'SIGHUP', b'SIGTERM': for name in b'SIGBREAK', b'SIGHUP', b'SIGTERM':
num = getattr(signal, name, None) num = getattr(signal, name, None)
finally: finally:
if repo and repo != req.repo: if repo and repo != req.repo:
repo.close() repo.close()
def _runcommand(ui, options, cmd, cmdfunc): def _runcommand(ui, options, cmd, cmdfunc):
"""Run a command function, possibly with profiling enabled.""" """Run a command function, possibly with profiling enabled."""
try: try:
with tracing.log(b"Running %s command" % cmd): with tracing.log("Running %s command" % cmd):
return cmdfunc() return cmdfunc()
except error.SignatureError: except error.SignatureError:
raise error.CommandError(cmd, _(b'invalid arguments')) raise error.CommandError(cmd, _(b'invalid arguments'))
def _exceptionwarning(ui): def _exceptionwarning(ui):
"""Produce a warning message for the current active exception""" """Produce a warning message for the current active exception"""

mercurial/extensions.py

else: else:
shortname = name shortname = name
if shortname in _builtin: if shortname in _builtin:
return None return None
if shortname in _extensions: if shortname in _extensions:
return _extensions[shortname] return _extensions[shortname]
ui.log(b'extension', b' - loading extension: %s\n', shortname) ui.log(b'extension', b' - loading extension: %s\n', shortname)
_extensions[shortname] = None _extensions[shortname] = None
with util.timedcm(b'load extension %s', shortname) as stats: with util.timedcm('load extension %s', shortname) as stats:
mod = _importext(name, path, bind(_reportimporterror, ui)) mod = _importext(name, path, bind(_reportimporterror, ui))
ui.log(b'extension', b' > %s extension loaded in %s\n', shortname, stats) ui.log(b'extension', b' > %s extension loaded in %s\n', shortname, stats)
if loadingtime is not None: if loadingtime is not None:
loadingtime[shortname] += stats.elapsed loadingtime[shortname] += stats.elapsed
# Before we do anything with the extension, check against minimum stated # Before we do anything with the extension, check against minimum stated
# compatibility. This gives extension authors a mechanism to have their # compatibility. This gives extension authors a mechanism to have their
# extensions short circuit when loaded with a known incompatible version # extensions short circuit when loaded with a known incompatible version
ui.log(b'extension', b' - validating extension tables: %s\n', shortname) ui.log(b'extension', b' - validating extension tables: %s\n', shortname)
_validatetables(ui, mod) _validatetables(ui, mod)
_extensions[shortname] = mod _extensions[shortname] = mod
_order.append(shortname) _order.append(shortname)
ui.log( ui.log(
b'extension', b' - invoking registered callbacks: %s\n', shortname b'extension', b' - invoking registered callbacks: %s\n', shortname
) )
with util.timedcm(b'callbacks extension %s', shortname) as stats: with util.timedcm('callbacks extension %s', shortname) as stats:
for fn in _aftercallbacks.get(shortname, []): for fn in _aftercallbacks.get(shortname, []):
fn(loaded=True) fn(loaded=True)
ui.log(b'extension', b' > callbacks completed in %s\n', stats) ui.log(b'extension', b' > callbacks completed in %s\n', stats)
return mod return mod
def _runuisetup(name, ui): def _runuisetup(name, ui):
uisetup = getattr(_extensions[name], 'uisetup', None) uisetup = getattr(_extensions[name], 'uisetup', None)
result = [(k, v) for (k, v) in result if k in whitelist] result = [(k, v) for (k, v) in result if k in whitelist]
newindex = len(_order) newindex = len(_order)
ui.log( ui.log(
b'extension', b'extension',
b'loading %sextensions\n', b'loading %sextensions\n',
b'additional ' if newindex else b'', b'additional ' if newindex else b'',
) )
ui.log(b'extension', b'- processing %d entries\n', len(result)) ui.log(b'extension', b'- processing %d entries\n', len(result))
with util.timedcm(b'load all extensions') as stats: with util.timedcm('load all extensions') as stats:
for (name, path) in result: for (name, path) in result:
if path: if path:
if path[0:1] == b'!': if path[0:1] == b'!':
if name not in _disabledextensions: if name not in _disabledextensions:
ui.log( ui.log(
b'extension', b'extension',
b' - skipping disabled extension: %s\n', b' - skipping disabled extension: %s\n',
name, name,
(b'configtable', configitems, b'loadconfigtable'), (b'configtable', configitems, b'loadconfigtable'),
] ]
ui.log(b'extension', b'- loading configtable attributes\n') ui.log(b'extension', b'- loading configtable attributes\n')
_loadextra(ui, newindex, earlyextraloaders) _loadextra(ui, newindex, earlyextraloaders)
broken = set() broken = set()
ui.log(b'extension', b'- executing uisetup hooks\n') ui.log(b'extension', b'- executing uisetup hooks\n')
with util.timedcm(b'all uisetup') as alluisetupstats: with util.timedcm('all uisetup') as alluisetupstats:
for name in _order[newindex:]: for name in _order[newindex:]:
ui.log(b'extension', b' - running uisetup for %s\n', name) ui.log(b'extension', b' - running uisetup for %s\n', name)
with util.timedcm(b'uisetup %s', name) as stats: with util.timedcm('uisetup %s', name) as stats:
if not _runuisetup(name, ui): if not _runuisetup(name, ui):
ui.log( ui.log(
b'extension', b'extension',
b' - the %s extension uisetup failed\n', b' - the %s extension uisetup failed\n',
name, name,
) )
broken.add(name) broken.add(name)
ui.log(b'extension', b' > uisetup for %s took %s\n', name, stats) ui.log(b'extension', b' > uisetup for %s took %s\n', name, stats)
loadingtime[name] += stats.elapsed loadingtime[name] += stats.elapsed
ui.log(b'extension', b'> all uisetup took %s\n', alluisetupstats) ui.log(b'extension', b'> all uisetup took %s\n', alluisetupstats)
ui.log(b'extension', b'- executing extsetup hooks\n') ui.log(b'extension', b'- executing extsetup hooks\n')
with util.timedcm(b'all extsetup') as allextetupstats: with util.timedcm('all extsetup') as allextetupstats:
for name in _order[newindex:]: for name in _order[newindex:]:
if name in broken: if name in broken:
continue continue
ui.log(b'extension', b' - running extsetup for %s\n', name) ui.log(b'extension', b' - running extsetup for %s\n', name)
with util.timedcm(b'extsetup %s', name) as stats: with util.timedcm('extsetup %s', name) as stats:
if not _runextsetup(name, ui): if not _runextsetup(name, ui):
ui.log( ui.log(
b'extension', b'extension',
b' - the %s extension extsetup failed\n', b' - the %s extension extsetup failed\n',
name, name,
) )
broken.add(name) broken.add(name)
ui.log(b'extension', b' > extsetup for %s took %s\n', name, stats) ui.log(b'extension', b' > extsetup for %s took %s\n', name, stats)
loadingtime[name] += stats.elapsed loadingtime[name] += stats.elapsed
ui.log(b'extension', b'> all extsetup took %s\n', allextetupstats) ui.log(b'extension', b'> all extsetup took %s\n', allextetupstats)
for name in broken: for name in broken:
ui.log(b'extension', b' - disabling broken %s extension\n', name) ui.log(b'extension', b' - disabling broken %s extension\n', name)
_extensions[name] = None _extensions[name] = None
# Call aftercallbacks that were never met. # Call aftercallbacks that were never met.
ui.log(b'extension', b'- executing remaining aftercallbacks\n') ui.log(b'extension', b'- executing remaining aftercallbacks\n')
with util.timedcm(b'aftercallbacks') as stats: with util.timedcm('aftercallbacks') as stats:
for shortname in _aftercallbacks: for shortname in _aftercallbacks:
if shortname in _extensions: if shortname in _extensions:
continue continue
for fn in _aftercallbacks[shortname]: for fn in _aftercallbacks[shortname]:
ui.log( ui.log(
b'extension', b'extension',
b' - extension %s not loaded, notify callbacks\n', b' - extension %s not loaded, notify callbacks\n',
(b'colortable', color, b'loadcolortable'), (b'colortable', color, b'loadcolortable'),
(b'filesetpredicate', fileset, b'loadpredicate'), (b'filesetpredicate', fileset, b'loadpredicate'),
(b'internalmerge', filemerge, b'loadinternalmerge'), (b'internalmerge', filemerge, b'loadinternalmerge'),
(b'revsetpredicate', revset, b'loadpredicate'), (b'revsetpredicate', revset, b'loadpredicate'),
(b'templatefilter', templatefilters, b'loadfilter'), (b'templatefilter', templatefilters, b'loadfilter'),
(b'templatefunc', templatefuncs, b'loadfunction'), (b'templatefunc', templatefuncs, b'loadfunction'),
(b'templatekeyword', templatekw, b'loadkeyword'), (b'templatekeyword', templatekw, b'loadkeyword'),
] ]
with util.timedcm(b'load registration objects') as stats: with util.timedcm('load registration objects') as stats:
_loadextra(ui, newindex, extraloaders) _loadextra(ui, newindex, extraloaders)
ui.log( ui.log(
b'extension', b'extension',
b'> extension registration object loading took %s\n', b'> extension registration object loading took %s\n',
stats, stats,
) )
# Report per extension loading time (except reposetup) # Report per extension loading time (except reposetup)

mercurial/exthelper.py

for command, wrapper, opts in self._commandwrappers: for command, wrapper, opts in self._commandwrappers:
entry = extensions.wrapcommand(commands.table, command, wrapper) entry = extensions.wrapcommand(commands.table, command, wrapper)
if opts: if opts:
for opt in opts: for opt in opts:
entry[1].append(opt) entry[1].append(opt)
for cont, funcname, wrapper in self._functionwrappers: for cont, funcname, wrapper in self._functionwrappers:
extensions.wrapfunction(cont, funcname, wrapper) extensions.wrapfunction(cont, funcname, wrapper)
for c in self._uicallables: for c in self._uicallables:
with tracing.log(b'finaluisetup: %s', pycompat.sysbytes(repr(c))): with tracing.log('finaluisetup: %s', repr(c)):
c(ui) c(ui)
def finaluipopulate(self, ui): def finaluipopulate(self, ui):
"""Method to be used as the extension uipopulate """Method to be used as the extension uipopulate
This is called once per ui instance to: This is called once per ui instance to:
- Set up additional ui members - Set up additional ui members
continue continue
knownexts[ext] = e.cmdtable knownexts[ext] = e.cmdtable
entry = extensions.wrapcommand(knownexts[ext], command, wrapper) entry = extensions.wrapcommand(knownexts[ext], command, wrapper)
if opts: if opts:
for opt in opts: for opt in opts:
entry[1].append(opt) entry[1].append(opt)
for c in self._extcallables: for c in self._extcallables:
with tracing.log(b'finalextsetup: %s', pycompat.sysbytes(repr(c))): with tracing.log('finalextsetup: %s', repr(c)):
c(ui) c(ui)
def finalreposetup(self, ui, repo): def finalreposetup(self, ui, repo):
"""Method to be used as the extension reposetup """Method to be used as the extension reposetup
The following operations belong here: The following operations belong here:
- All hooks but pre-* and post-* - All hooks but pre-* and post-*
- Modify configuration variables - Modify configuration variables
- Changes to repo.__class__, repo.dirstate.__class__ - Changes to repo.__class__, repo.dirstate.__class__
""" """
for c in self._repocallables: for c in self._repocallables:
with tracing.log(b'finalreposetup: %s', pycompat.sysbytes(repr(c))): with tracing.log('finalreposetup: %s', repr(c)):
c(ui, repo) c(ui, repo)
def uisetup(self, call): def uisetup(self, call):
"""Decorated function will be executed during uisetup """Decorated function will be executed during uisetup
example:: example::
@eh.uisetup @eh.uisetup

mercurial/hg.py

"""return a repository object for the specified path""" """return a repository object for the specified path"""
obj = _peerlookup(path).instance( obj = _peerlookup(path).instance(
ui, path, create, intents=intents, createopts=createopts ui, path, create, intents=intents, createopts=createopts
) )
ui = getattr(obj, "ui", ui) ui = getattr(obj, "ui", ui)
for f in presetupfuncs or []: for f in presetupfuncs or []:
f(ui, obj) f(ui, obj)
ui.log(b'extension', b'- executing reposetup hooks\n') ui.log(b'extension', b'- executing reposetup hooks\n')
with util.timedcm(b'all reposetup') as allreposetupstats: with util.timedcm('all reposetup') as allreposetupstats:
for name, module in extensions.extensions(ui): for name, module in extensions.extensions(ui):
ui.log(b'extension', b' - running reposetup for %s\n', name) ui.log(b'extension', b' - running reposetup for %s\n', name)
hook = getattr(module, 'reposetup', None) hook = getattr(module, 'reposetup', None)
if hook: if hook:
with util.timedcm(b'reposetup %r', name) as stats: with util.timedcm('reposetup %r', name) as stats:
hook(ui, obj) hook(ui, obj)
ui.log( ui.log(
b'extension', b' > reposetup for %s took %s\n', name, stats b'extension', b' > reposetup for %s took %s\n', name, stats
) )
ui.log(b'extension', b'> all reposetup took %s\n', allreposetupstats) ui.log(b'extension', b'> all reposetup took %s\n', allreposetupstats)
if not obj.local(): if not obj.local():
for f in wirepeersetupfuncs: for f in wirepeersetupfuncs:
f(ui, obj) f(ui, obj)