This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2796

hgweb: always return iterable from @webcommand functions (API)
ClosedPublic

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

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG67fb0dca29bc: hgweb: always return iterable from @webcommand functions (API)
Summary

We had to hack up this function to support our transition to the
new response API. Now that we're done with the transition (!!),
we can return to returning an iterator of content chunks from
these functions.

It is tempting to return a normal object and not a generator.
However, as the keyword extension demonstrates, extensions may
wish to wrap commands and have a try..finally block around
execution. Since there is a generator producing content and
that generator could be executing code, the try..finally needs
to live for as long as the generator is running. That means we
have to return a generator so wrappers can consume the generator
inside a try..finally.

.. api::

hgweb @webcommand functions must use the new response object
passed in via ``web.res`` to initiate sending of a response.
The hgweb WSGI application will no longer start sending the
response automatically.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Mar 11 2018, 12:24 AM
durin42 accepted this revision.Mar 12 2018, 5:14 PM
This revision is now accepted and ready to land.Mar 12 2018, 5:14 PM
Closed by commit rHG67fb0dca29bc: hgweb: always return iterable from @webcommand functions (API) (authored by indygreg). · Explain WhyMar 12 2018, 5:34 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 6857

hgext/highlight/__init__.py

def generate_css(web, req, tmpl): def generate_css(web, req, tmpl):
pg_style = web.config('web', 'pygments_style', 'colorful') pg_style = web.config('web', 'pygments_style', 'colorful')
fmter = highlight.HtmlFormatter(style=pg_style) fmter = highlight.HtmlFormatter(style=pg_style)
web.res.headers['Content-Type'] = 'text/css' web.res.headers['Content-Type'] = 'text/css'
web.res.setbodybytes(''.join([ web.res.setbodybytes(''.join([
'/* pygments_style = %s */\n\n' % pg_style, '/* pygments_style = %s */\n\n' % pg_style,
fmter.get_style_defs(''), fmter.get_style_defs(''),
])) ]))
return web.res return web.res.sendresponse()
def extsetup(): def extsetup():
# monkeypatch in the new version # monkeypatch in the new version
extensions.wrapfunction(webcommands, '_filerevision', extensions.wrapfunction(webcommands, '_filerevision',
filerevision_highlight) filerevision_highlight)
extensions.wrapfunction(webcommands, 'annotate', annotate_highlight) extensions.wrapfunction(webcommands, 'annotate', annotate_highlight)
webcommands.highlightcss = generate_css webcommands.highlightcss = generate_css
webcommands.__all__.append('highlightcss') webcommands.__all__.append('highlightcss')

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:
res = orig(web, req, tmpl) for chunk in orig(web, req, tmpl):
if res is web.res:
res = res.sendresponse()
elif res is True:
return
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

# hgweb/hgweb_mod.py - Web interface for a repository. # hgweb/hgweb_mod.py - Web interface for a repository.
# #
# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net> # Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import contextlib import contextlib
import os import os
from .common import ( from .common import (
ErrorResponse, ErrorResponse,
HTTP_BAD_REQUEST, HTTP_BAD_REQUEST,
HTTP_OK,
cspvalues, cspvalues,
permhooks, permhooks,
statusmessage, statusmessage,
) )
from .. import ( from .. import (
encoding, encoding,
error, error,
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)
else: else:
# Set some globals appropriate for web handlers. Commands can # Set some globals appropriate for web handlers. Commands can
# override easily enough. # override easily enough.
res.status = '200 Script output follows' res.status = '200 Script output follows'
res.headers['Content-Type'] = ctype res.headers['Content-Type'] = ctype
content = getattr(webcommands, cmd)(rctx, wsgireq, tmpl) return getattr(webcommands, cmd)(rctx, wsgireq, tmpl)
if content is res:
return res.sendresponse()
elif content is True:
return []
else:
wsgireq.respond(HTTP_OK, ctype)
return content
except (error.LookupError, error.RepoLookupError) as err: except (error.LookupError, error.RepoLookupError) as err:
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'

mercurial/hgweb/webcommands.py

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``, When called, functions receive as arguments a ``requestcontext``,
``wsgirequest``, and a templater instance for generatoring output. ``wsgirequest``, and a templater instance for generatoring output.
The functions should populate the ``rctx.res`` object with details The functions should populate the ``rctx.res`` object with details
about the HTTP response. about the HTTP response.
The function can return the ``requestcontext.res`` instance to signal The function returns a generator to be consumed by the WSGI application.
that it wants to use this object to generate the response. If an iterable For most commands, this should be the result from
is returned, the ``wsgirequest`` instance will be used and the returned ``web.res.sendresponse()``.
content will constitute the response body. ``True`` can be returned to
indicate that the function already sent output and the caller doesn't
need to do anything more to send the response.
Usage: Usage:
@webcommand('mycommand') @webcommand('mycommand')
def mycommand(web, req, tmpl): def mycommand(web, req, tmpl):
pass pass
""" """
if mt.startswith('text/'): if mt.startswith('text/'):
mt += '; charset="%s"' % encoding.encoding mt += '; charset="%s"' % encoding.encoding
web.res.headers['Content-Type'] = mt web.res.headers['Content-Type'] = mt
filename = (path.rpartition('/')[-1] filename = (path.rpartition('/')[-1]
.replace('\\', '\\\\').replace('"', '\\"')) .replace('\\', '\\\\').replace('"', '\\"'))
web.res.headers['Content-Disposition'] = 'inline; filename="%s"' % filename web.res.headers['Content-Disposition'] = 'inline; filename="%s"' % filename
web.res.setbodybytes(text) web.res.setbodybytes(text)
return web.res return web.res.sendresponse()
def _filerevision(web, req, tmpl, fctx): def _filerevision(web, req, tmpl, fctx):
f = fctx.path() f = fctx.path()
text = fctx.data() text = fctx.data()
parity = paritygen(web.stripecount) parity = paritygen(web.stripecount)
ishead = fctx.filerev() in fctx.filelog().headrevs() ishead = fctx.filerev() in fctx.filelog().headrevs()
if util.binary(text): if util.binary(text):
path=webutil.up(f), path=webutil.up(f),
text=lines(), text=lines(),
symrev=webutil.symrevorshortnode(req, fctx), symrev=webutil.symrevorshortnode(req, fctx),
rename=webutil.renamelink(fctx), rename=webutil.renamelink(fctx),
permissions=fctx.manifest().flags(f), permissions=fctx.manifest().flags(f),
ishead=int(ishead), ishead=int(ishead),
**pycompat.strkwargs(webutil.commonentry(web.repo, fctx)))) **pycompat.strkwargs(webutil.commonentry(web.repo, fctx))))
return web.res return web.res.sendresponse()
@webcommand('file') @webcommand('file')
def file(web, req, tmpl): def file(web, req, tmpl):
""" """
/file/{revision}[/{path}] /file/{revision}[/{path}]
------------------------- -------------------------
Show information about a directory or file in the repository. Show information about a directory or file in the repository.
entries=changelist, entries=changelist,
archives=web.archivelist('tip'), archives=web.archivelist('tip'),
morevars=morevars, morevars=morevars,
lessvars=lessvars, lessvars=lessvars,
modedesc=searchfunc[1], modedesc=searchfunc[1],
showforcekw=showforcekw, showforcekw=showforcekw,
showunforcekw=showunforcekw)) showunforcekw=showunforcekw))
return web.res return web.res.sendresponse()
@webcommand('changelog') @webcommand('changelog')
def changelog(web, req, tmpl, shortlog=False): def changelog(web, req, tmpl, shortlog=False):
""" """
/changelog[/{revision}] /changelog[/{revision}]
----------------------- -----------------------
Show information about multiple changesets. Show information about multiple changesets.
latestentry=latestentry, latestentry=latestentry,
nextentry=nextentry, nextentry=nextentry,
archives=web.archivelist('tip'), archives=web.archivelist('tip'),
revcount=revcount, revcount=revcount,
morevars=morevars, morevars=morevars,
lessvars=lessvars, lessvars=lessvars,
query=query)) query=query))
return web.res return web.res.sendresponse()
@webcommand('shortlog') @webcommand('shortlog')
def shortlog(web, req, tmpl): def shortlog(web, req, tmpl):
""" """
/shortlog /shortlog
--------- ---------
Show basic information about a set of changesets. Show basic information about a set of changesets.
The ``changeset`` template is rendered. Contents of the ``changesettag``, The ``changeset`` template is rendered. Contents of the ``changesettag``,
``changesetbookmark``, ``filenodelink``, ``filenolink``, and the many ``changesetbookmark``, ``filenodelink``, ``filenolink``, and the many
templates related to diffs may all be used to produce the output. templates related to diffs may all be used to produce the output.
""" """
ctx = webutil.changectx(web.repo, req) ctx = webutil.changectx(web.repo, req)
web.res.setbodygen(tmpl('changeset', web.res.setbodygen(tmpl('changeset',
**webutil.changesetentry(web, req, tmpl, ctx))) **webutil.changesetentry(web, req, tmpl, ctx)))
return web.res return web.res.sendresponse()
rev = webcommand('rev')(changeset) rev = webcommand('rev')(changeset)
def decodepath(path): def decodepath(path):
"""Hook for mapping a path in the repository to a path in the """Hook for mapping a path in the repository to a path in the
working copy. working copy.
Extensions (e.g., largefiles) can override this to remap files in Extensions (e.g., largefiles) can override this to remap files in
path=abspath, path=abspath,
up=webutil.up(abspath), up=webutil.up(abspath),
upparity=next(parity), upparity=next(parity),
fentries=filelist, fentries=filelist,
dentries=dirlist, dentries=dirlist,
archives=web.archivelist(hex(node)), archives=web.archivelist(hex(node)),
**pycompat.strkwargs(webutil.commonentry(web.repo, ctx)))) **pycompat.strkwargs(webutil.commonentry(web.repo, ctx))))
return web.res return web.res.sendresponse()
@webcommand('tags') @webcommand('tags')
def tags(web, req, tmpl): def tags(web, req, tmpl):
""" """
/tags /tags
----- -----
Show information about tags. Show information about tags.
web.res.setbodygen(tmpl( web.res.setbodygen(tmpl(
'tags', 'tags',
node=hex(web.repo.changelog.tip()), node=hex(web.repo.changelog.tip()),
entries=lambda **x: entries(False, False, **x), entries=lambda **x: entries(False, False, **x),
entriesnotip=lambda **x: entries(True, False, **x), entriesnotip=lambda **x: entries(True, False, **x),
latestentry=lambda **x: entries(True, True, **x))) latestentry=lambda **x: entries(True, True, **x)))
return web.res return web.res.sendresponse()
@webcommand('bookmarks') @webcommand('bookmarks')
def bookmarks(web, req, tmpl): def bookmarks(web, req, tmpl):
""" """
/bookmarks /bookmarks
---------- ----------
Show information about bookmarks. Show information about bookmarks.
web.res.setbodygen(tmpl( web.res.setbodygen(tmpl(
'bookmarks', 'bookmarks',
node=hex(web.repo.changelog.tip()), node=hex(web.repo.changelog.tip()),
lastchange=[{'date': web.repo[latestrev].date()}], lastchange=[{'date': web.repo[latestrev].date()}],
entries=lambda **x: entries(latestonly=False, **x), entries=lambda **x: entries(latestonly=False, **x),
latestentry=lambda **x: entries(latestonly=True, **x))) latestentry=lambda **x: entries(latestonly=True, **x)))
return web.res return web.res.sendresponse()
@webcommand('branches') @webcommand('branches')
def branches(web, req, tmpl): def branches(web, req, tmpl):
""" """
/branches /branches
--------- ---------
Show information about branches. Show information about branches.
All known branches are contained in the output, even closed branches. All known branches are contained in the output, even closed branches.
No arguments are accepted. No arguments are accepted.
The ``branches`` template is rendered. The ``branches`` template is rendered.
""" """
entries = webutil.branchentries(web.repo, web.stripecount) entries = webutil.branchentries(web.repo, web.stripecount)
latestentry = webutil.branchentries(web.repo, web.stripecount, 1) latestentry = webutil.branchentries(web.repo, web.stripecount, 1)
web.res.setbodygen(tmpl( web.res.setbodygen(tmpl(
'branches', 'branches',
node=hex(web.repo.changelog.tip()), node=hex(web.repo.changelog.tip()),
entries=entries, entries=entries,
latestentry=latestentry)) latestentry=latestentry))
return web.res return web.res.sendresponse()
@webcommand('summary') @webcommand('summary')
def summary(web, req, tmpl): def summary(web, req, tmpl):
""" """
/summary /summary
-------- --------
Show a summary of repository state. Show a summary of repository state.
bookmarks=bookmarks, bookmarks=bookmarks,
branches=webutil.branchentries(web.repo, web.stripecount, 10), branches=webutil.branchentries(web.repo, web.stripecount, 10),
shortlog=changelist, shortlog=changelist,
node=tip.hex(), node=tip.hex(),
symrev='tip', symrev='tip',
archives=web.archivelist('tip'), archives=web.archivelist('tip'),
labels=web.configlist('web', 'labels'))) labels=web.configlist('web', 'labels')))
return web.res return web.res.sendresponse()
@webcommand('filediff') @webcommand('filediff')
def filediff(web, req, tmpl): def filediff(web, req, tmpl):
""" """
/diff/{revision}/{path} /diff/{revision}/{path}
----------------------- -----------------------
Show how a file changed in a particular commit. Show how a file changed in a particular commit.
web.res.setbodygen(tmpl( web.res.setbodygen(tmpl(
'filediff', 'filediff',
file=path, file=path,
symrev=webutil.symrevorshortnode(req, ctx), symrev=webutil.symrevorshortnode(req, ctx),
rename=rename, rename=rename,
diff=diffs, diff=diffs,
**pycompat.strkwargs(webutil.commonentry(web.repo, ctx)))) **pycompat.strkwargs(webutil.commonentry(web.repo, ctx))))
return web.res return web.res.sendresponse()
diff = webcommand('diff')(filediff) diff = webcommand('diff')(filediff)
@webcommand('comparison') @webcommand('comparison')
def comparison(web, req, tmpl): def comparison(web, req, tmpl):
""" """
/comparison/{revision}/{path} /comparison/{revision}/{path}
----------------------------- -----------------------------
rename=rename, rename=rename,
leftrev=leftrev, leftrev=leftrev,
leftnode=hex(leftnode), leftnode=hex(leftnode),
rightrev=rightrev, rightrev=rightrev,
rightnode=hex(rightnode), rightnode=hex(rightnode),
comparison=comparison, comparison=comparison,
**pycompat.strkwargs(webutil.commonentry(web.repo, ctx)))) **pycompat.strkwargs(webutil.commonentry(web.repo, ctx))))
return web.res return web.res.sendresponse()
@webcommand('annotate') @webcommand('annotate')
def annotate(web, req, tmpl): def annotate(web, req, tmpl):
""" """
/annotate/{revision}/{path} /annotate/{revision}/{path}
--------------------------- ---------------------------
Show changeset information for each line in a file. Show changeset information for each line in a file.
path=webutil.up(f), path=webutil.up(f),
symrev=webutil.symrevorshortnode(req, fctx), symrev=webutil.symrevorshortnode(req, fctx),
rename=webutil.renamelink(fctx), rename=webutil.renamelink(fctx),
permissions=fctx.manifest().flags(f), permissions=fctx.manifest().flags(f),
ishead=int(ishead), ishead=int(ishead),
diffopts=diffopts, diffopts=diffopts,
**pycompat.strkwargs(webutil.commonentry(web.repo, fctx)))) **pycompat.strkwargs(webutil.commonentry(web.repo, fctx))))
return web.res return web.res.sendresponse()
@webcommand('filelog') @webcommand('filelog')
def filelog(web, req, tmpl): def filelog(web, req, tmpl):
""" """
/filelog/{revision}/{path} /filelog/{revision}/{path}
-------------------------- --------------------------
Show information about the history of a file in the repository. Show information about the history of a file in the repository.
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 return web.res.sendresponse()
@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.
assert list(web.res.sendresponse()) == [] assert list(web.res.sendresponse()) == []
bodyfh = web.res.getbodyfile() bodyfh = web.res.getbodyfile()
archival.archive(web.repo, bodyfh, cnode, artype, prefix=name, archival.archive(web.repo, bodyfh, cnode, artype, prefix=name,
matchfn=match, matchfn=match,
subrepos=web.configbool("web", "archivesubrepos")) subrepos=web.configbool("web", "archivesubrepos"))
return True return []
@webcommand('static') @webcommand('static')
def static(web, req, tmpl): def static(web, req, tmpl):
fname = req.req.qsparams['file'] fname = req.req.qsparams['file']
# a repo owner may set web.static in .hg/hgrc to get any file # a repo owner may set web.static in .hg/hgrc to get any file
# readable by the user running the CGI script # readable by the user running the CGI script
static = web.config("web", "static", None, untrusted=False) static = web.config("web", "static", None, untrusted=False)
if not static: if not static:
tp = web.templatepath or templater.templatepaths() tp = web.templatepath or templater.templatepaths()
if isinstance(tp, str): if isinstance(tp, str):
tp = [tp] tp = [tp]
static = [os.path.join(p, 'static') for p in tp] static = [os.path.join(p, 'static') for p in tp]
staticfile(static, fname, web.res) staticfile(static, fname, web.res)
return web.res return web.res.sendresponse()
@webcommand('graph') @webcommand('graph')
def graph(web, req, tmpl): def graph(web, req, tmpl):
""" """
/graph[/{revision}] /graph[/{revision}]
------------------- -------------------
Show information about the graphical topology of the repository. Show information about the graphical topology of the repository.
bg_height=bg_height, bg_height=bg_height,
changesets=count, changesets=count,
nextentry=nextentry, nextentry=nextentry,
jsdata=lambda **x: jsdata(), jsdata=lambda **x: jsdata(),
nodes=lambda **x: nodes(), nodes=lambda **x: nodes(),
node=ctx.hex(), node=ctx.hex(),
changenav=changenav)) changenav=changenav))
return web.res return web.res.sendresponse()
def _getdoc(e): def _getdoc(e):
doc = e[0].__doc__ doc = e[0].__doc__
if doc: if doc:
doc = _(doc).partition('\n')[0] doc = _(doc).partition('\n')[0]
else: else:
doc = _('(no help text available)') doc = _('(no help text available)')
return doc return doc
yield {'topic': c, 'summary': doc} yield {'topic': c, 'summary': doc}
web.res.setbodygen(tmpl( web.res.setbodygen(tmpl(
'helptopics', 'helptopics',
topics=topics, topics=topics,
earlycommands=earlycommands, earlycommands=earlycommands,
othercommands=othercommands, othercommands=othercommands,
title='Index')) title='Index'))
return web.res return web.res.sendresponse()
# Render an index of sub-topics. # Render an index of sub-topics.
if topicname in helpmod.subtopics: if topicname in helpmod.subtopics:
topics = [] topics = []
for entries, summary, _doc in helpmod.subtopics[topicname]: for entries, summary, _doc in helpmod.subtopics[topicname]:
topics.append({ topics.append({
'topic': '%s.%s' % (topicname, entries[0]), 'topic': '%s.%s' % (topicname, entries[0]),
'basename': entries[0], 'basename': entries[0],
'summary': summary, 'summary': summary,
}) })
web.res.setbodygen(tmpl( web.res.setbodygen(tmpl(
'helptopics', 'helptopics',
topics=topics, topics=topics,
title=topicname, title=topicname,
subindex=True)) subindex=True))
return web.res return web.res.sendresponse()
u = webutil.wsgiui.load() u = webutil.wsgiui.load()
u.verbose = True u.verbose = True
# Render a page from a sub-topic. # Render a page from a sub-topic.
if '.' in topicname: if '.' in topicname:
# TODO implement support for rendering sections, like # TODO implement support for rendering sections, like
# `hg help` works. # `hg help` works.
except error.Abort: except error.Abort:
raise ErrorResponse(HTTP_NOT_FOUND) raise ErrorResponse(HTTP_NOT_FOUND)
web.res.setbodygen(tmpl( web.res.setbodygen(tmpl(
'help', 'help',
topic=topicname, topic=topicname,
doc=doc)) doc=doc))
return web.res return web.res.sendresponse()
# tell hggettext to extract docstrings from these functions: # tell hggettext to extract docstrings from these functions:
i18nfunctions = commands.values() i18nfunctions = commands.values()