( )⚙ D2786 hgweb: support using new response object for web commands

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2786

hgweb: support using new response object for web commands
ClosedPublic

Authored by indygreg on Mar 11 2018, 12:23 AM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG1f42d621f090: hgweb: support using new response object for web commands
Summary

We have a "requestcontext" type for holding state for the current
request. Why we pass in the wsgirequest and templater instance
to @webcommand functions, I don't know.

I like the idea of standardizing on using "requestcontext" for passing
all state to @webcommand functions because that scales well without
API changes every time you want to pass a new piece of data. So,
we add our new request and response instances to "requestcontext" so
@webcommand functions can access them.

We also teach our command dispatcher to recognize a new calling
convention. Instead of returning content from the @webcommand
function, we return our response object. This signals that this
response object is to be used for sending output. The keyword
extension was wrapping various @webcommand and assuming the output
was iterable, so we had to teach it about the new calling convention.

To prove everything works, we convert the "filelog" @webcommand
to use the new convention.

The new calling convention is a bit wonky. I intend to improve this
once all commands are ported to use the new response object.

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

indygreg created this revision.Mar 11 2018, 12:23 AM
durin42 accepted this revision.Mar 12 2018, 5:08 PM
This revision is now accepted and ready to land.Mar 12 2018, 5:08 PM
Closed by commit rHG1f42d621f090: hgweb: support using new response object for web commands (authored by indygreg). · Explain WhyMar 12 2018, 5:33 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 6922

hgext/keyword.py

def kwweb_skip(orig, web, req, tmpl): def kwweb_skip(orig, web, req, tmpl):
'''Wraps webcommands.x turning off keyword expansion.''' '''Wraps webcommands.x turning off keyword expansion.'''
kwt = getattr(web.repo, '_keywordkwt', None) kwt = getattr(web.repo, '_keywordkwt', None)
if kwt: if kwt:
origmatch = kwt.match origmatch = kwt.match
kwt.match = util.never kwt.match = util.never
try: try:
for chunk in orig(web, req, tmpl): res = orig(web, req, tmpl)
if res is web.res:
res = res.sendresponse()
for chunk in res:
yield chunk yield chunk
finally: finally:
if kwt: if kwt:
kwt.match = origmatch kwt.match = origmatch
def kw_amend(orig, ui, repo, old, extra, pats, opts): def kw_amend(orig, ui, repo, old, extra, pats, opts):
'''Wraps cmdutil.amend expanding keywords after amend.''' '''Wraps cmdutil.amend expanding keywords after amend.'''
kwt = getattr(repo, '_keywordkwt', None) kwt = getattr(repo, '_keywordkwt', None)

mercurial/hgweb/hgweb_mod.py

class requestcontext(object): class requestcontext(object):
"""Holds state/context for an individual request. """Holds state/context for an individual request.
Servers can be multi-threaded. Holding state on the WSGI application Servers can be multi-threaded. Holding state on the WSGI application
is prone to race conditions. Instances of this class exist to hold is prone to race conditions. Instances of this class exist to hold
mutable and race-free state for requests. mutable and race-free state for requests.
""" """
def __init__(self, app, repo): def __init__(self, app, repo, req, res):
self.repo = repo self.repo = repo
self.reponame = app.reponame self.reponame = app.reponame
self.req = req
self.res = res
self.archivespecs = archivespecs self.archivespecs = archivespecs
self.maxchanges = self.configint('web', 'maxchanges') self.maxchanges = self.configint('web', 'maxchanges')
self.stripecount = self.configint('web', 'stripes') self.stripecount = self.configint('web', 'stripes')
self.maxshortchanges = self.configint('web', 'maxshortchanges') self.maxshortchanges = self.configint('web', 'maxshortchanges')
self.maxfiles = self.configint('web', 'maxfiles') self.maxfiles = self.configint('web', 'maxfiles')
self.allowpull = self.configbool('web', 'allow-pull') self.allowpull = self.configbool('web', 'allow-pull')
profile = repo.ui.configbool('profiling', 'enabled') profile = repo.ui.configbool('profiling', 'enabled')
with profiling.profile(repo.ui, enabled=profile): with profiling.profile(repo.ui, enabled=profile):
for r in self._runwsgi(wsgireq, repo): for r in self._runwsgi(wsgireq, repo):
yield r yield r
def _runwsgi(self, wsgireq, repo): def _runwsgi(self, wsgireq, repo):
req = wsgireq.req req = wsgireq.req
res = wsgireq.res res = wsgireq.res
rctx = requestcontext(self, repo) rctx = requestcontext(self, repo, req, res)
# This state is global across all threads. # This state is global across all threads.
encoding.encoding = rctx.config('web', 'encoding') encoding.encoding = rctx.config('web', 'encoding')
rctx.repo.ui.environ = wsgireq.env rctx.repo.ui.environ = wsgireq.env
if rctx.csp: if rctx.csp:
# hgwebdir may have added CSP header. Since we generate our own, # hgwebdir may have added CSP header. Since we generate our own,
# replace it. # replace it.
if cmd not in webcommands.__all__: if cmd not in webcommands.__all__:
msg = 'no such method: %s' % cmd msg = 'no such method: %s' % cmd
raise ErrorResponse(HTTP_BAD_REQUEST, msg) raise ErrorResponse(HTTP_BAD_REQUEST, msg)
elif cmd == 'file' and req.qsparams.get('style') == 'raw': elif cmd == 'file' and req.qsparams.get('style') == 'raw':
rctx.ctype = ctype rctx.ctype = ctype
content = webcommands.rawfile(rctx, wsgireq, tmpl) content = webcommands.rawfile(rctx, wsgireq, tmpl)
else: else:
# Set some globals appropriate for web handlers. Commands can
# override easily enough.
res.status = '200 Script output follows'
res.headers['Content-Type'] = ctype
content = getattr(webcommands, cmd)(rctx, wsgireq, tmpl) content = getattr(webcommands, cmd)(rctx, wsgireq, tmpl)
if content is res:
return res.sendresponse()
wsgireq.respond(HTTP_OK, ctype) wsgireq.respond(HTTP_OK, ctype)
return content return content
except (error.LookupError, error.RepoLookupError) as err: except (error.LookupError, error.RepoLookupError) as err:
wsgireq.respond(HTTP_NOT_FOUND, ctype) wsgireq.respond(HTTP_NOT_FOUND, ctype)
msg = pycompat.bytestr(err) msg = pycompat.bytestr(err)
if (util.safehasattr(err, 'name') and if (util.safehasattr(err, 'name') and

mercurial/hgweb/webcommands.py

commands = {} commands = {}
class webcommand(object): class webcommand(object):
"""Decorator used to register a web command handler. """Decorator used to register a web command handler.
The decorator takes as its positional arguments the name/path the The decorator takes as its positional arguments the name/path the
command should be accessible under. command should be accessible under.
When called, functions receive as arguments a ``requestcontext``,
``wsgirequest``, and a templater instance for generatoring output.
The functions should populate the ``rctx.res`` object with details
about the HTTP response.
The function can return the ``requestcontext.res`` instance to signal
that it wants to use this object to generate the response. If an iterable
is returned, the ``wsgirequest`` instance will be used and the returned
content will constitute the response body.
Usage: Usage:
@webcommand('mycommand') @webcommand('mycommand')
def mycommand(web, req, tmpl): def mycommand(web, req, tmpl):
pass pass
""" """
def __init__(self, name): def __init__(self, name):
rename=webutil.renamelink(iterfctx), rename=webutil.renamelink(iterfctx),
**pycompat.strkwargs(webutil.commonentry(repo, iterfctx)))) **pycompat.strkwargs(webutil.commonentry(repo, iterfctx))))
entries.reverse() entries.reverse()
revnav = webutil.filerevnav(web.repo, fctx.path()) revnav = webutil.filerevnav(web.repo, fctx.path())
nav = revnav.gen(end - 1, revcount, count) nav = revnav.gen(end - 1, revcount, count)
latestentry = entries[:1] latestentry = entries[:1]
return tmpl("filelog", web.res.setbodygen(tmpl(
'filelog',
file=f, file=f,
nav=nav, nav=nav,
symrev=webutil.symrevorshortnode(req, fctx), symrev=webutil.symrevorshortnode(req, fctx),
entries=entries, entries=entries,
descend=descend, descend=descend,
patch=patch, patch=patch,
latestentry=latestentry, latestentry=latestentry,
linerange=linerange, linerange=linerange,
revcount=revcount, revcount=revcount,
morevars=morevars, morevars=morevars,
lessvars=lessvars, lessvars=lessvars,
**pycompat.strkwargs(webutil.commonentry(web.repo, fctx))) **pycompat.strkwargs(webutil.commonentry(web.repo, fctx))))
return web.res
@webcommand('archive') @webcommand('archive')
def archive(web, req, tmpl): def archive(web, req, tmpl):
""" """
/archive/{revision}.{format}[/{path}] /archive/{revision}.{format}[/{path}]
------------------------------------- -------------------------------------
Obtain an archive of repository content. Obtain an archive of repository content.