hgweb: simplify staticfile() now that we always pass it a single directory

I didn't realize this further simplifications enabled by D8786 until
now.

Differential Revision: https://phab.mercurial-scm.org/D8874

mercurial/hgweb/common.py

@@ -1,287 +1,282 b''
 # hgweb/common.py - Utility functions needed by hgweb_mod and hgwebdir_mod
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import base64
 import errno
 import mimetypes
 import os
 import stat
 
 from ..pycompat import (
     getattr,
     open,
 )
 from .. import (
     encoding,
     pycompat,
     util,
 )
 
 httpserver = util.httpserver
 
 HTTP_OK = 200
 HTTP_CREATED = 201
 HTTP_NOT_MODIFIED = 304
 HTTP_BAD_REQUEST = 400
 HTTP_UNAUTHORIZED = 401
 HTTP_FORBIDDEN = 403
 HTTP_NOT_FOUND = 404
 HTTP_METHOD_NOT_ALLOWED = 405
 HTTP_NOT_ACCEPTABLE = 406
 HTTP_UNSUPPORTED_MEDIA_TYPE = 415
 HTTP_SERVER_ERROR = 500
 
 
 def ismember(ui, username, userlist):
     """Check if username is a member of userlist.
 
     If userlist has a single '*' member, all users are considered members.
     Can be overridden by extensions to provide more complex authorization
     schemes.
     """
     return userlist == [b'*'] or username in userlist
 
 
 def checkauthz(hgweb, req, op):
     '''Check permission for operation based on request data (including
     authentication info). Return if op allowed, else raise an ErrorResponse
     exception.'''
 
     user = req.remoteuser
 
     deny_read = hgweb.configlist(b'web', b'deny_read')
     if deny_read and (not user or ismember(hgweb.repo.ui, user, deny_read)):
         raise ErrorResponse(HTTP_UNAUTHORIZED, b'read not authorized')
 
     allow_read = hgweb.configlist(b'web', b'allow_read')
     if allow_read and (not ismember(hgweb.repo.ui, user, allow_read)):
         raise ErrorResponse(HTTP_UNAUTHORIZED, b'read not authorized')
 
     if op == b'pull' and not hgweb.allowpull:
         raise ErrorResponse(HTTP_UNAUTHORIZED, b'pull not authorized')
     elif op == b'pull' or op is None:  # op is None for interface requests
         return
 
     # Allow LFS uploading via PUT requests
     if op == b'upload':
         if req.method != b'PUT':
             msg = b'upload requires PUT request'
             raise ErrorResponse(HTTP_METHOD_NOT_ALLOWED, msg)
     # enforce that you can only push using POST requests
     elif req.method != b'POST':
         msg = b'push requires POST request'
         raise ErrorResponse(HTTP_METHOD_NOT_ALLOWED, msg)
 
     # require ssl by default for pushing, auth info cannot be sniffed
     # and replayed
     if hgweb.configbool(b'web', b'push_ssl') and req.urlscheme != b'https':
         raise ErrorResponse(HTTP_FORBIDDEN, b'ssl required')
 
     deny = hgweb.configlist(b'web', b'deny_push')
     if deny and (not user or ismember(hgweb.repo.ui, user, deny)):
         raise ErrorResponse(HTTP_UNAUTHORIZED, b'push not authorized')
 
     allow = hgweb.configlist(b'web', b'allow-push')
     if not (allow and ismember(hgweb.repo.ui, user, allow)):
         raise ErrorResponse(HTTP_UNAUTHORIZED, b'push not authorized')
 
 
 # Hooks for hgweb permission checks; extensions can add hooks here.
 # Each hook is invoked like this: hook(hgweb, request, operation),
 # where operation is either read, pull, push or upload. Hooks should either
 # raise an ErrorResponse exception, or just return.
 #
 # It is possible to do both authentication and authorization through
 # this.
 permhooks = [checkauthz]
 
 
 class ErrorResponse(Exception):
     def __init__(self, code, message=None, headers=None):
         if message is None:
             message = _statusmessage(code)
         Exception.__init__(self, pycompat.sysstr(message))
         self.code = code
         if headers is None:
             headers = []
         self.headers = headers
         self.message = message
 
 
 class continuereader(object):
     """File object wrapper to handle HTTP 100-continue.
 
     This is used by servers so they automatically handle Expect: 100-continue
     request headers. On first read of the request body, the 100 Continue
     response is sent. This should trigger the client into actually sending
     the request body.
     """
 
     def __init__(self, f, write):
         self.f = f
         self._write = write
         self.continued = False
 
     def read(self, amt=-1):
         if not self.continued:
             self.continued = True
             self._write(b'HTTP/1.1 100 Continue\r\n\r\n')
         return self.f.read(amt)
 
     def __getattr__(self, attr):
         if attr in (b'close', b'readline', b'readlines', b'__iter__'):
             return getattr(self.f, attr)
         raise AttributeError
 
 
 def _statusmessage(code):
     responses = httpserver.basehttprequesthandler.responses
     return pycompat.bytesurl(responses.get(code, ('Error', 'Unknown error'))[0])
 
 
 def statusmessage(code, message=None):
     return b'%d %s' % (code, message or _statusmessage(code))
 
 
 def get_stat(spath, fn):
     """stat fn if it exists, spath otherwise"""
     cl_path = os.path.join(spath, fn)
     if os.path.exists(cl_path):
         return os.stat(cl_path)
     else:
         return os.stat(spath)
 
 
 def get_mtime(spath):
     return get_stat(spath, b"00changelog.i")[stat.ST_MTIME]
 
 
 def ispathsafe(path):
     """Determine if a path is safe to use for filesystem access."""
     parts = path.split(b'/')
     for part in parts:
         if (
             part in (b'', pycompat.oscurdir, pycompat.ospardir)
             or pycompat.ossep in part
             or pycompat.osaltsep is not None
             and pycompat.osaltsep in part
         ):
             return False
 
     return True
 
 
 def staticfile(directory, fname, res):
     """return a file inside directory with guessed Content-Type header
 
     fname always uses '/' as directory separator and isn't allowed to
     contain unusual path components.
     Content-Type is guessed using the mimetypes module.
     Return an empty string if fname is illegal or file not found.
 
     """
     if not ispathsafe(fname):
         return
 
     fpath = os.path.join(*fname.split(b'/'))
-    if isinstance(directory, bytes):
-        directory = [directory]
-    for d in directory:
-        path = os.path.join(d, fpath)
-        if os.path.exists(path):
-            break
+    path = os.path.join(directory, fpath)
     try:
         os.stat(path)
         ct = pycompat.sysbytes(
             mimetypes.guess_type(pycompat.fsdecode(path))[0] or r"text/plain"
         )
         with open(path, b'rb') as fh:
             data = fh.read()
 
         res.headers[b'Content-Type'] = ct
         res.setbodybytes(data)
         return res
     except TypeError:
         raise ErrorResponse(HTTP_SERVER_ERROR, b'illegal filename')
     except OSError as err:
         if err.errno == errno.ENOENT:
             raise ErrorResponse(HTTP_NOT_FOUND)
         else:
             raise ErrorResponse(
                 HTTP_SERVER_ERROR, encoding.strtolocal(err.strerror)
             )
 
 
 def paritygen(stripecount, offset=0):
     """count parity of horizontal stripes for easier reading"""
     if stripecount and offset:
         # account for offset, e.g. due to building the list in reverse
         count = (stripecount + offset) % stripecount
         parity = (stripecount + offset) // stripecount & 1
     else:
         count = 0
         parity = 0
     while True:
         yield parity
         count += 1
         if stripecount and count >= stripecount:
             parity = 1 - parity
             count = 0
 
 
 def get_contact(config):
     """Return repo contact information or empty string.
 
     web.contact is the primary source, but if that is not set, try
     ui.username or $EMAIL as a fallback to display something useful.
     """
     return (
         config(b"web", b"contact")
         or config(b"ui", b"username")
         or encoding.environ.get(b"EMAIL")
         or b""
     )
 
 
 def cspvalues(ui):
     """Obtain the Content-Security-Policy header and nonce value.
 
     Returns a 2-tuple of the CSP header value and the nonce value.
 
     First value is ``None`` if CSP isn't enabled. Second value is ``None``
     if CSP isn't enabled or if the CSP header doesn't need a nonce.
     """
     # Without demandimport, "import uuid" could have an immediate side-effect
     # running "ldconfig" on Linux trying to find libuuid.
     # With Python <= 2.7.12, that "ldconfig" is run via a shell and the shell
     # may pollute the terminal with:
     #
     #   shell-init: error retrieving current directory: getcwd: cannot access
     #   parent directories: No such file or directory
     #
     # Python >= 2.7.13 has fixed it by running "ldconfig" directly without a
     # shell (hg changeset a09ae70f3489).
     #
     # Moved "import uuid" from here so it's executed after we know we have
     # a sane cwd (i.e. after dispatch.py cwd check).
     #
     # We can move it back once we no longer need Python <= 2.7.12 support.
     import uuid
 
     # Don't allow untrusted CSP setting since it be disable protections
     # from a trusted/global source.
     csp = ui.config(b'web', b'csp', untrusted=False)
     nonce = None
 
     if csp and b'%nonce%' in csp:
         nonce = base64.urlsafe_b64encode(uuid.uuid4().bytes).rstrip(b'=')
         csp = csp.replace(b'%nonce%', nonce)
 
     return csp, nonce

mercurial/hgweb/hgwebdir_mod.py

@@ -1,580 +1,580 b''
 # hgweb/hgwebdir_mod.py - Web interface for a directory of repositories.
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import gc
 import os
 import time
 
 from ..i18n import _
 
 from .common import (
     ErrorResponse,
     HTTP_SERVER_ERROR,
     cspvalues,
     get_contact,
     get_mtime,
     ismember,
     paritygen,
     staticfile,
     statusmessage,
 )
 
 from .. import (
     configitems,
     encoding,
     error,
     extensions,
     hg,
     pathutil,
     profiling,
     pycompat,
     rcutil,
     registrar,
     scmutil,
     templater,
     templateutil,
     ui as uimod,
     util,
 )
 
 from . import (
     hgweb_mod,
     request as requestmod,
     webutil,
     wsgicgi,
 )
 from ..utils import dateutil
 
 
 def cleannames(items):
     return [(util.pconvert(name).strip(b'/'), path) for name, path in items]
 
 
 def findrepos(paths):
     repos = []
     for prefix, root in cleannames(paths):
         roothead, roottail = os.path.split(root)
         # "foo = /bar/*" or "foo = /bar/**" lets every repo /bar/N in or below
         # /bar/ be served as as foo/N .
         # '*' will not search inside dirs with .hg (except .hg/patches),
         # '**' will search inside dirs with .hg (and thus also find subrepos).
         try:
             recurse = {b'*': False, b'**': True}[roottail]
         except KeyError:
             repos.append((prefix, root))
             continue
         roothead = os.path.normpath(os.path.abspath(roothead))
         paths = scmutil.walkrepos(roothead, followsym=True, recurse=recurse)
         repos.extend(urlrepos(prefix, roothead, paths))
     return repos
 
 
 def urlrepos(prefix, roothead, paths):
     """yield url paths and filesystem paths from a list of repo paths
 
     >>> conv = lambda seq: [(v, util.pconvert(p)) for v,p in seq]
     >>> conv(urlrepos(b'hg', b'/opt', [b'/opt/r', b'/opt/r/r', b'/opt']))
     [('hg/r', '/opt/r'), ('hg/r/r', '/opt/r/r'), ('hg', '/opt')]
     >>> conv(urlrepos(b'', b'/opt', [b'/opt/r', b'/opt/r/r', b'/opt']))
     [('r', '/opt/r'), ('r/r', '/opt/r/r'), ('', '/opt')]
     """
     for path in paths:
         path = os.path.normpath(path)
         yield (
             prefix + b'/' + util.pconvert(path[len(roothead) :]).lstrip(b'/')
         ).strip(b'/'), path
 
 
 def readallowed(ui, req):
     """Check allow_read and deny_read config options of a repo's ui object
     to determine user permissions.  By default, with neither option set (or
     both empty), allow all users to read the repo.  There are two ways a
     user can be denied read access:  (1) deny_read is not empty, and the
     user is unauthenticated or deny_read contains user (or *), and (2)
     allow_read is not empty and the user is not in allow_read.  Return True
     if user is allowed to read the repo, else return False."""
 
     user = req.remoteuser
 
     deny_read = ui.configlist(b'web', b'deny_read', untrusted=True)
     if deny_read and (not user or ismember(ui, user, deny_read)):
         return False
 
     allow_read = ui.configlist(b'web', b'allow_read', untrusted=True)
     # by default, allow reading if no allow_read option has been set
     if not allow_read or ismember(ui, user, allow_read):
         return True
 
     return False
 
 
 def rawindexentries(ui, repos, req, subdir=b''):
     descend = ui.configbool(b'web', b'descend')
     collapse = ui.configbool(b'web', b'collapse')
     seenrepos = set()
     seendirs = set()
     for name, path in repos:
 
         if not name.startswith(subdir):
             continue
         name = name[len(subdir) :]
         directory = False
 
         if b'/' in name:
             if not descend:
                 continue
 
             nameparts = name.split(b'/')
             rootname = nameparts[0]
 
             if not collapse:
                 pass
             elif rootname in seendirs:
                 continue
             elif rootname in seenrepos:
                 pass
             else:
                 directory = True
                 name = rootname
 
                 # redefine the path to refer to the directory
                 discarded = b'/'.join(nameparts[1:])
 
                 # remove name parts plus accompanying slash
                 path = path[: -len(discarded) - 1]
 
                 try:
                     hg.repository(ui, path)
                     directory = False
                 except (IOError, error.RepoError):
                     pass
 
         parts = [
             req.apppath.strip(b'/'),
             subdir.strip(b'/'),
             name.strip(b'/'),
         ]
         url = b'/' + b'/'.join(p for p in parts if p) + b'/'
 
         # show either a directory entry or a repository
         if directory:
             # get the directory's time information
             try:
                 d = (get_mtime(path), dateutil.makedate()[1])
             except OSError:
                 continue
 
             # add '/' to the name to make it obvious that
             # the entry is a directory, not a regular repository
             row = {
                 b'contact': b"",
                 b'contact_sort': b"",
                 b'name': name + b'/',
                 b'name_sort': name,
                 b'url': url,
                 b'description': b"",
                 b'description_sort': b"",
                 b'lastchange': d,
                 b'lastchange_sort': d[1] - d[0],
                 b'archives': templateutil.mappinglist([]),
                 b'isdirectory': True,
                 b'labels': templateutil.hybridlist([], name=b'label'),
             }
 
             seendirs.add(name)
             yield row
             continue
 
         u = ui.copy()
         if rcutil.use_repo_hgrc():
             try:
                 u.readconfig(os.path.join(path, b'.hg', b'hgrc'))
             except Exception as e:
                 u.warn(_(b'error reading %s/.hg/hgrc: %s\n') % (path, e))
                 continue
 
         def get(section, name, default=uimod._unset):
             return u.config(section, name, default, untrusted=True)
 
         if u.configbool(b"web", b"hidden", untrusted=True):
             continue
 
         if not readallowed(u, req):
             continue
 
         # update time with local timezone
         try:
             r = hg.repository(ui, path)
         except IOError:
             u.warn(_(b'error accessing repository at %s\n') % path)
             continue
         except error.RepoError:
             u.warn(_(b'error accessing repository at %s\n') % path)
             continue
         try:
             d = (get_mtime(r.spath), dateutil.makedate()[1])
         except OSError:
             continue
 
         contact = get_contact(get)
         description = get(b"web", b"description")
         seenrepos.add(name)
         name = get(b"web", b"name", name)
         labels = u.configlist(b'web', b'labels', untrusted=True)
         row = {
             b'contact': contact or b"unknown",
             b'contact_sort': contact.upper() or b"unknown",
             b'name': name,
             b'name_sort': name,
             b'url': url,
             b'description': description or b"unknown",
             b'description_sort': description.upper() or b"unknown",
             b'lastchange': d,
             b'lastchange_sort': d[1] - d[0],
             b'archives': webutil.archivelist(u, b"tip", url),
             b'isdirectory': None,
             b'labels': templateutil.hybridlist(labels, name=b'label'),
         }
 
         yield row
 
 
 def _indexentriesgen(
     context, ui, repos, req, stripecount, sortcolumn, descending, subdir
 ):
     rows = rawindexentries(ui, repos, req, subdir=subdir)
 
     sortdefault = None, False
 
     if sortcolumn and sortdefault != (sortcolumn, descending):
         sortkey = b'%s_sort' % sortcolumn
         rows = sorted(rows, key=lambda x: x[sortkey], reverse=descending)
 
     for row, parity in zip(rows, paritygen(stripecount)):
         row[b'parity'] = parity
         yield row
 
 
 def indexentries(
     ui, repos, req, stripecount, sortcolumn=b'', descending=False, subdir=b''
 ):
     args = (ui, repos, req, stripecount, sortcolumn, descending, subdir)
     return templateutil.mappinggenerator(_indexentriesgen, args=args)
 
 
 class hgwebdir(object):
     """HTTP server for multiple repositories.
 
     Given a configuration, different repositories will be served depending
     on the request path.
 
     Instances are typically used as WSGI applications.
     """
 
     def __init__(self, conf, baseui=None):
         self.conf = conf
         self.baseui = baseui
         self.ui = None
         self.lastrefresh = 0
         self.motd = None
         self.refresh()
         if not baseui:
             # set up environment for new ui
             extensions.loadall(self.ui)
             extensions.populateui(self.ui)
 
     def refresh(self):
         if self.ui:
             refreshinterval = self.ui.configint(b'web', b'refreshinterval')
         else:
             item = configitems.coreitems[b'web'][b'refreshinterval']
             refreshinterval = item.default
 
         # refreshinterval <= 0 means to always refresh.
         if (
             refreshinterval > 0
             and self.lastrefresh + refreshinterval > time.time()
         ):
             return
 
         if self.baseui:
             u = self.baseui.copy()
         else:
             u = uimod.ui.load()
             u.setconfig(b'ui', b'report_untrusted', b'off', b'hgwebdir')
             u.setconfig(b'ui', b'nontty', b'true', b'hgwebdir')
             # displaying bundling progress bar while serving feels wrong and may
             # break some wsgi implementations.
             u.setconfig(b'progress', b'disable', b'true', b'hgweb')
 
         if not isinstance(self.conf, (dict, list, tuple)):
             map = {b'paths': b'hgweb-paths'}
             if not os.path.exists(self.conf):
                 raise error.Abort(_(b'config file %s not found!') % self.conf)
             u.readconfig(self.conf, remap=map, trust=True)
             paths = []
             for name, ignored in u.configitems(b'hgweb-paths'):
                 for path in u.configlist(b'hgweb-paths', name):
                     paths.append((name, path))
         elif isinstance(self.conf, (list, tuple)):
             paths = self.conf
         elif isinstance(self.conf, dict):
             paths = self.conf.items()
         extensions.populateui(u)
 
         repos = findrepos(paths)
         for prefix, root in u.configitems(b'collections'):
             prefix = util.pconvert(prefix)
             for path in scmutil.walkrepos(root, followsym=True):
                 repo = os.path.normpath(path)
                 name = util.pconvert(repo)
                 if name.startswith(prefix):
                     name = name[len(prefix) :]
                 repos.append((name.lstrip(b'/'), repo))
 
         self.repos = repos
         self.ui = u
         encoding.encoding = self.ui.config(b'web', b'encoding')
         self.style = self.ui.config(b'web', b'style')
         self.templatepath = self.ui.config(
             b'web', b'templates', untrusted=False
         )
         self.stripecount = self.ui.config(b'web', b'stripes')
         if self.stripecount:
             self.stripecount = int(self.stripecount)
         prefix = self.ui.config(b'web', b'prefix')
         if prefix.startswith(b'/'):
             prefix = prefix[1:]
         if prefix.endswith(b'/'):
             prefix = prefix[:-1]
         self.prefix = prefix
         self.lastrefresh = time.time()
 
     def run(self):
         if not encoding.environ.get(b'GATEWAY_INTERFACE', b'').startswith(
             b"CGI/1."
         ):
             raise RuntimeError(
                 b"This function is only intended to be "
                 b"called while running as a CGI script."
             )
         wsgicgi.launch(self)
 
     def __call__(self, env, respond):
         baseurl = self.ui.config(b'web', b'baseurl')
         req = requestmod.parserequestfromenv(env, altbaseurl=baseurl)
         res = requestmod.wsgiresponse(req, respond)
 
         return self.run_wsgi(req, res)
 
     def run_wsgi(self, req, res):
         profile = self.ui.configbool(b'profiling', b'enabled')
         with profiling.profile(self.ui, enabled=profile):
             try:
                 for r in self._runwsgi(req, res):
                     yield r
             finally:
                 # There are known cycles in localrepository that prevent
                 # those objects (and tons of held references) from being
                 # collected through normal refcounting. We mitigate those
                 # leaks by performing an explicit GC on every request.
                 # TODO remove this once leaks are fixed.
                 # TODO only run this on requests that create localrepository
                 # instances instead of every request.
                 gc.collect()
 
     def _runwsgi(self, req, res):
         try:
             self.refresh()
 
             csp, nonce = cspvalues(self.ui)
             if csp:
                 res.headers[b'Content-Security-Policy'] = csp
 
             virtual = req.dispatchpath.strip(b'/')
             tmpl = self.templater(req, nonce)
             ctype = tmpl.render(b'mimetype', {b'encoding': encoding.encoding})
 
             # Global defaults. These can be overridden by any handler.
             res.status = b'200 Script output follows'
             res.headers[b'Content-Type'] = ctype
 
             # a static file
             if virtual.startswith(b'static/') or b'static' in req.qsparams:
                 if virtual.startswith(b'static/'):
                     fname = virtual[7:]
                 else:
                     fname = req.qsparams[b'static']
                 static = self.ui.config(b"web", b"static", untrusted=False)
                 if not static:
                     tp = self.templatepath or templater.templatedir()
                     if tp is not None:
-                        static = [os.path.join(tp, b'static')]
+                        static = os.path.join(tp, b'static')
 
                 staticfile(static, fname, res)
                 return res.sendresponse()
 
             # top-level index
 
             repos = dict(self.repos)
 
             if (not virtual or virtual == b'index') and virtual not in repos:
                 return self.makeindex(req, res, tmpl)
 
             # nested indexes and hgwebs
 
             if virtual.endswith(b'/index') and virtual not in repos:
                 subdir = virtual[: -len(b'index')]
                 if any(r.startswith(subdir) for r in repos):
                     return self.makeindex(req, res, tmpl, subdir)
 
             def _virtualdirs():
                 # Check the full virtual path, and each parent
                 yield virtual
                 for p in pathutil.finddirs(virtual):
                     yield p
 
             for virtualrepo in _virtualdirs():
                 real = repos.get(virtualrepo)
                 if real:
                     # Re-parse the WSGI environment to take into account our
                     # repository path component.
                     uenv = req.rawenv
                     if pycompat.ispy3:
                         uenv = {
                             k.decode('latin1'): v
                             for k, v in pycompat.iteritems(uenv)
                         }
                     req = requestmod.parserequestfromenv(
                         uenv,
                         reponame=virtualrepo,
                         altbaseurl=self.ui.config(b'web', b'baseurl'),
                         # Reuse wrapped body file object otherwise state
                         # tracking can get confused.
                         bodyfh=req.bodyfh,
                     )
                     try:
                         # ensure caller gets private copy of ui
                         repo = hg.repository(self.ui.copy(), real)
                         return hgweb_mod.hgweb(repo).run_wsgi(req, res)
                     except IOError as inst:
                         msg = encoding.strtolocal(inst.strerror)
                         raise ErrorResponse(HTTP_SERVER_ERROR, msg)
                     except error.RepoError as inst:
                         raise ErrorResponse(HTTP_SERVER_ERROR, bytes(inst))
 
             # browse subdirectories
             subdir = virtual + b'/'
             if [r for r in repos if r.startswith(subdir)]:
                 return self.makeindex(req, res, tmpl, subdir)
 
             # prefixes not found
             res.status = b'404 Not Found'
             res.setbodygen(tmpl.generate(b'notfound', {b'repo': virtual}))
             return res.sendresponse()
 
         except ErrorResponse as e:
             res.status = statusmessage(e.code, pycompat.bytestr(e))
             res.setbodygen(
                 tmpl.generate(b'error', {b'error': e.message or b''})
             )
             return res.sendresponse()
         finally:
             del tmpl
 
     def makeindex(self, req, res, tmpl, subdir=b""):
         self.refresh()
         sortable = [b"name", b"description", b"contact", b"lastchange"]
         sortcolumn, descending = None, False
         if b'sort' in req.qsparams:
             sortcolumn = req.qsparams[b'sort']
             descending = sortcolumn.startswith(b'-')
             if descending:
                 sortcolumn = sortcolumn[1:]
             if sortcolumn not in sortable:
                 sortcolumn = b""
 
         sort = [
             (
                 b"sort_%s" % column,
                 b"%s%s"
                 % (
                     (not descending and column == sortcolumn) and b"-" or b"",
                     column,
                 ),
             )
             for column in sortable
         ]
 
         self.refresh()
 
         entries = indexentries(
             self.ui,
             self.repos,
             req,
             self.stripecount,
             sortcolumn=sortcolumn,
             descending=descending,
             subdir=subdir,
         )
 
         mapping = {
             b'entries': entries,
             b'subdir': subdir,
             b'pathdef': hgweb_mod.makebreadcrumb(b'/' + subdir, self.prefix),
             b'sortcolumn': sortcolumn,
             b'descending': descending,
         }
         mapping.update(sort)
         res.setbodygen(tmpl.generate(b'index', mapping))
         return res.sendresponse()
 
     def templater(self, req, nonce):
         def config(section, name, default=uimod._unset, untrusted=True):
             return self.ui.config(section, name, default, untrusted)
 
         vars = {}
         styles, (style, mapfile) = hgweb_mod.getstyle(
             req, config, self.templatepath
         )
         if style == styles[0]:
             vars[b'style'] = style
 
         sessionvars = webutil.sessionvars(vars, b'?')
         logourl = config(b'web', b'logourl')
         logoimg = config(b'web', b'logoimg')
         staticurl = (
             config(b'web', b'staticurl')
             or req.apppath.rstrip(b'/') + b'/static/'
         )
         if not staticurl.endswith(b'/'):
             staticurl += b'/'
 
         defaults = {
             b"encoding": encoding.encoding,
             b"url": req.apppath + b'/',
             b"logourl": logourl,
             b"logoimg": logoimg,
             b"staticurl": staticurl,
             b"sessionvars": sessionvars,
             b"style": style,
             b"nonce": nonce,
         }
         templatekeyword = registrar.templatekeyword(defaults)
 
         @templatekeyword(b'motd', requires=())
         def motd(context, mapping):
             if self.motd is not None:
                 yield self.motd
             else:
                 yield config(b'web', b'motd')
 
         tmpl = templater.templater.frommapfile(mapfile, defaults=defaults)
         return tmpl

mercurial/hgweb/webcommands.py

@@ -1,1596 +1,1596 b''
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import copy
 import mimetypes
 import os
 import re
 
 from ..i18n import _
 from ..node import hex, short
 from ..pycompat import getattr
 
 from .common import (
     ErrorResponse,
     HTTP_FORBIDDEN,
     HTTP_NOT_FOUND,
     get_contact,
     paritygen,
     staticfile,
 )
 
 from .. import (
     archival,
     dagop,
     encoding,
     error,
     graphmod,
     pycompat,
     revset,
     revsetlang,
     scmutil,
     smartset,
     templater,
     templateutil,
 )
 
 from ..utils import stringutil
 
 from . import webutil
 
 __all__ = []
 commands = {}
 
 
 class webcommand(object):
     """Decorator used to register a web command handler.
 
     The decorator takes as its positional arguments the name/path the
     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 returns a generator to be consumed by the WSGI application.
     For most commands, this should be the result from
     ``web.res.sendresponse()``. Many commands will call ``web.sendtemplate()``
     to render a template.
 
     Usage:
 
     @webcommand('mycommand')
     def mycommand(web):
         pass
     """
 
     def __init__(self, name):
         self.name = name
 
     def __call__(self, func):
         __all__.append(self.name)
         commands[self.name] = func
         return func
 
 
 @webcommand(b'log')
 def log(web):
     """
     /log[/{revision}[/{path}]]
     --------------------------
 
     Show repository or file history.
 
     For URLs of the form ``/log/{revision}``, a list of changesets starting at
     the specified changeset identifier is shown. If ``{revision}`` is not
     defined, the default is ``tip``. This form is equivalent to the
     ``changelog`` handler.
 
     For URLs of the form ``/log/{revision}/{file}``, the history for a specific
     file will be shown. This form is equivalent to the ``filelog`` handler.
     """
 
     if web.req.qsparams.get(b'file'):
         return filelog(web)
     else:
         return changelog(web)
 
 
 @webcommand(b'rawfile')
 def rawfile(web):
     guessmime = web.configbool(b'web', b'guessmime')
 
     path = webutil.cleanpath(web.repo, web.req.qsparams.get(b'file', b''))
     if not path:
         return manifest(web)
 
     try:
         fctx = webutil.filectx(web.repo, web.req)
     except error.LookupError as inst:
         try:
             return manifest(web)
         except ErrorResponse:
             raise inst
 
     path = fctx.path()
     text = fctx.data()
     mt = b'application/binary'
     if guessmime:
         mt = mimetypes.guess_type(pycompat.fsdecode(path))[0]
         if mt is None:
             if stringutil.binary(text):
                 mt = b'application/binary'
             else:
                 mt = b'text/plain'
         else:
             mt = pycompat.sysbytes(mt)
 
     if mt.startswith(b'text/'):
         mt += b'; charset="%s"' % encoding.encoding
 
     web.res.headers[b'Content-Type'] = mt
     filename = (
         path.rpartition(b'/')[-1].replace(b'\\', b'\\\\').replace(b'"', b'\\"')
     )
     web.res.headers[b'Content-Disposition'] = (
         b'inline; filename="%s"' % filename
     )
     web.res.setbodybytes(text)
     return web.res.sendresponse()
 
 
 def _filerevision(web, fctx):
     f = fctx.path()
     text = fctx.data()
     parity = paritygen(web.stripecount)
     ishead = fctx.filenode() in fctx.filelog().heads()
 
     if stringutil.binary(text):
         mt = pycompat.sysbytes(
             mimetypes.guess_type(pycompat.fsdecode(f))[0]
             or r'application/octet-stream'
         )
         text = b'(binary:%s)' % mt
 
     def lines(context):
         for lineno, t in enumerate(text.splitlines(True)):
             yield {
                 b"line": t,
                 b"lineid": b"l%d" % (lineno + 1),
                 b"linenumber": b"% 6d" % (lineno + 1),
                 b"parity": next(parity),
             }
 
     return web.sendtemplate(
         b'filerevision',
         file=f,
         path=webutil.up(f),
         text=templateutil.mappinggenerator(lines),
         symrev=webutil.symrevorshortnode(web.req, fctx),
         rename=webutil.renamelink(fctx),
         permissions=fctx.manifest().flags(f),
         ishead=int(ishead),
         **pycompat.strkwargs(webutil.commonentry(web.repo, fctx))
     )
 
 
 @webcommand(b'file')
 def file(web):
     """
     /file/{revision}[/{path}]
     -------------------------
 
     Show information about a directory or file in the repository.
 
     Info about the ``path`` given as a URL parameter will be rendered.
 
     If ``path`` is a directory, information about the entries in that
     directory will be rendered. This form is equivalent to the ``manifest``
     handler.
 
     If ``path`` is a file, information about that file will be shown via
     the ``filerevision`` template.
 
     If ``path`` is not defined, information about the root directory will
     be rendered.
     """
     if web.req.qsparams.get(b'style') == b'raw':
         return rawfile(web)
 
     path = webutil.cleanpath(web.repo, web.req.qsparams.get(b'file', b''))
     if not path:
         return manifest(web)
     try:
         return _filerevision(web, webutil.filectx(web.repo, web.req))
     except error.LookupError as inst:
         try:
             return manifest(web)
         except ErrorResponse:
             raise inst
 
 
 def _search(web):
     MODE_REVISION = b'rev'
     MODE_KEYWORD = b'keyword'
     MODE_REVSET = b'revset'
 
     def revsearch(ctx):
         yield ctx
 
     def keywordsearch(query):
         lower = encoding.lower
         qw = lower(query).split()
 
         def revgen():
             cl = web.repo.changelog
             for i in pycompat.xrange(len(web.repo) - 1, 0, -100):
                 l = []
                 for j in cl.revs(max(0, i - 99), i):
                     ctx = web.repo[j]
                     l.append(ctx)
                 l.reverse()
                 for e in l:
                     yield e
 
         for ctx in revgen():
             miss = 0
             for q in qw:
                 if not (
                     q in lower(ctx.user())
                     or q in lower(ctx.description())
                     or q in lower(b" ".join(ctx.files()))
                 ):
                     miss = 1
                     break
             if miss:
                 continue
 
             yield ctx
 
     def revsetsearch(revs):
         for r in revs:
             yield web.repo[r]
 
     searchfuncs = {
         MODE_REVISION: (revsearch, b'exact revision search'),
         MODE_KEYWORD: (keywordsearch, b'literal keyword search'),
         MODE_REVSET: (revsetsearch, b'revset expression search'),
     }
 
     def getsearchmode(query):
         try:
             ctx = scmutil.revsymbol(web.repo, query)
         except (error.RepoError, error.LookupError):
             # query is not an exact revision pointer, need to
             # decide if it's a revset expression or keywords
             pass
         else:
             return MODE_REVISION, ctx
 
         revdef = b'reverse(%s)' % query
         try:
             tree = revsetlang.parse(revdef)
         except error.ParseError:
             # can't parse to a revset tree
             return MODE_KEYWORD, query
 
         if revsetlang.depth(tree) <= 2:
             # no revset syntax used
             return MODE_KEYWORD, query
 
         if any(
             (token, (value or b'')[:3]) == (b'string', b're:')
             for token, value, pos in revsetlang.tokenize(revdef)
         ):
             return MODE_KEYWORD, query
 
         funcsused = revsetlang.funcsused(tree)
         if not funcsused.issubset(revset.safesymbols):
             return MODE_KEYWORD, query
 
         try:
             mfunc = revset.match(
                 web.repo.ui, revdef, lookup=revset.lookupfn(web.repo)
             )
             revs = mfunc(web.repo)
             return MODE_REVSET, revs
             # ParseError: wrongly placed tokens, wrongs arguments, etc
             # RepoLookupError: no such revision, e.g. in 'revision:'
             # Abort: bookmark/tag not exists
             # LookupError: ambiguous identifier, e.g. in '(bc)' on a large repo
         except (
             error.ParseError,
             error.RepoLookupError,
             error.Abort,
             LookupError,
         ):
             return MODE_KEYWORD, query
 
     def changelist(context):
         count = 0
 
         for ctx in searchfunc[0](funcarg):
             count += 1
             n = scmutil.binnode(ctx)
             showtags = webutil.showtag(web.repo, b'changelogtag', n)
             files = webutil.listfilediffs(ctx.files(), n, web.maxfiles)
 
             lm = webutil.commonentry(web.repo, ctx)
             lm.update(
                 {
                     b'parity': next(parity),
                     b'changelogtag': showtags,
                     b'files': files,
                 }
             )
             yield lm
 
             if count >= revcount:
                 break
 
     query = web.req.qsparams[b'rev']
     revcount = web.maxchanges
     if b'revcount' in web.req.qsparams:
         try:
             revcount = int(web.req.qsparams.get(b'revcount', revcount))
             revcount = max(revcount, 1)
             web.tmpl.defaults[b'sessionvars'][b'revcount'] = revcount
         except ValueError:
             pass
 
     lessvars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     lessvars[b'revcount'] = max(revcount // 2, 1)
     lessvars[b'rev'] = query
     morevars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     morevars[b'revcount'] = revcount * 2
     morevars[b'rev'] = query
 
     mode, funcarg = getsearchmode(query)
 
     if b'forcekw' in web.req.qsparams:
         showforcekw = b''
         showunforcekw = searchfuncs[mode][1]
         mode = MODE_KEYWORD
         funcarg = query
     else:
         if mode != MODE_KEYWORD:
             showforcekw = searchfuncs[MODE_KEYWORD][1]
         else:
             showforcekw = b''
         showunforcekw = b''
 
     searchfunc = searchfuncs[mode]
 
     tip = web.repo[b'tip']
     parity = paritygen(web.stripecount)
 
     return web.sendtemplate(
         b'search',
         query=query,
         node=tip.hex(),
         symrev=b'tip',
         entries=templateutil.mappinggenerator(changelist, name=b'searchentry'),
         archives=web.archivelist(b'tip'),
         morevars=morevars,
         lessvars=lessvars,
         modedesc=searchfunc[1],
         showforcekw=showforcekw,
         showunforcekw=showunforcekw,
     )
 
 
 @webcommand(b'changelog')
 def changelog(web, shortlog=False):
     """
     /changelog[/{revision}]
     -----------------------
 
     Show information about multiple changesets.
 
     If the optional ``revision`` URL argument is absent, information about
     all changesets starting at ``tip`` will be rendered. If the ``revision``
     argument is present, changesets will be shown starting from the specified
     revision.
 
     If ``revision`` is absent, the ``rev`` query string argument may be
     defined. This will perform a search for changesets.
 
     The argument for ``rev`` can be a single revision, a revision set,
     or a literal keyword to search for in changeset data (equivalent to
     :hg:`log -k`).
 
     The ``revcount`` query string argument defines the maximum numbers of
     changesets to render.
 
     For non-searches, the ``changelog`` template will be rendered.
     """
 
     query = b''
     if b'node' in web.req.qsparams:
         ctx = webutil.changectx(web.repo, web.req)
         symrev = webutil.symrevorshortnode(web.req, ctx)
     elif b'rev' in web.req.qsparams:
         return _search(web)
     else:
         ctx = web.repo[b'tip']
         symrev = b'tip'
 
     def changelist(maxcount):
         revs = []
         if pos != -1:
             revs = web.repo.changelog.revs(pos, 0)
 
         for entry in webutil.changelistentries(web, revs, maxcount, parity):
             yield entry
 
     if shortlog:
         revcount = web.maxshortchanges
     else:
         revcount = web.maxchanges
 
     if b'revcount' in web.req.qsparams:
         try:
             revcount = int(web.req.qsparams.get(b'revcount', revcount))
             revcount = max(revcount, 1)
             web.tmpl.defaults[b'sessionvars'][b'revcount'] = revcount
         except ValueError:
             pass
 
     lessvars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     lessvars[b'revcount'] = max(revcount // 2, 1)
     morevars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     morevars[b'revcount'] = revcount * 2
 
     count = len(web.repo)
     pos = ctx.rev()
     parity = paritygen(web.stripecount)
 
     changenav = webutil.revnav(web.repo).gen(pos, revcount, count)
 
     entries = list(changelist(revcount + 1))
     latestentry = entries[:1]
     if len(entries) > revcount:
         nextentry = entries[-1:]
         entries = entries[:-1]
     else:
         nextentry = []
 
     return web.sendtemplate(
         b'shortlog' if shortlog else b'changelog',
         changenav=changenav,
         node=ctx.hex(),
         rev=pos,
         symrev=symrev,
         changesets=count,
         entries=templateutil.mappinglist(entries),
         latestentry=templateutil.mappinglist(latestentry),
         nextentry=templateutil.mappinglist(nextentry),
         archives=web.archivelist(b'tip'),
         revcount=revcount,
         morevars=morevars,
         lessvars=lessvars,
         query=query,
     )
 
 
 @webcommand(b'shortlog')
 def shortlog(web):
     """
     /shortlog
     ---------
 
     Show basic information about a set of changesets.
 
     This accepts the same parameters as the ``changelog`` handler. The only
     difference is the ``shortlog`` template will be rendered instead of the
     ``changelog`` template.
     """
     return changelog(web, shortlog=True)
 
 
 @webcommand(b'changeset')
 def changeset(web):
     """
     /changeset[/{revision}]
     -----------------------
 
     Show information about a single changeset.
 
     A URL path argument is the changeset identifier to show. See ``hg help
     revisions`` for possible values. If not defined, the ``tip`` changeset
     will be shown.
 
     The ``changeset`` template is rendered. Contents of the ``changesettag``,
     ``changesetbookmark``, ``filenodelink``, ``filenolink``, and the many
     templates related to diffs may all be used to produce the output.
     """
     ctx = webutil.changectx(web.repo, web.req)
 
     return web.sendtemplate(b'changeset', **webutil.changesetentry(web, ctx))
 
 
 rev = webcommand(b'rev')(changeset)
 
 
 def decodepath(path):
     """Hook for mapping a path in the repository to a path in the
     working copy.
 
     Extensions (e.g., largefiles) can override this to remap files in
     the virtual file system presented by the manifest command below."""
     return path
 
 
 @webcommand(b'manifest')
 def manifest(web):
     """
     /manifest[/{revision}[/{path}]]
     -------------------------------
 
     Show information about a directory.
 
     If the URL path arguments are omitted, information about the root
     directory for the ``tip`` changeset will be shown.
 
     Because this handler can only show information for directories, it
     is recommended to use the ``file`` handler instead, as it can handle both
     directories and files.
 
     The ``manifest`` template will be rendered for this handler.
     """
     if b'node' in web.req.qsparams:
         ctx = webutil.changectx(web.repo, web.req)
         symrev = webutil.symrevorshortnode(web.req, ctx)
     else:
         ctx = web.repo[b'tip']
         symrev = b'tip'
     path = webutil.cleanpath(web.repo, web.req.qsparams.get(b'file', b''))
     mf = ctx.manifest()
     node = scmutil.binnode(ctx)
 
     files = {}
     dirs = {}
     parity = paritygen(web.stripecount)
 
     if path and path[-1:] != b"/":
         path += b"/"
     l = len(path)
     abspath = b"/" + path
 
     for full, n in pycompat.iteritems(mf):
         # the virtual path (working copy path) used for the full
         # (repository) path
         f = decodepath(full)
 
         if f[:l] != path:
             continue
         remain = f[l:]
         elements = remain.split(b'/')
         if len(elements) == 1:
             files[remain] = full
         else:
             h = dirs  # need to retain ref to dirs (root)
             for elem in elements[0:-1]:
                 if elem not in h:
                     h[elem] = {}
                 h = h[elem]
                 if len(h) > 1:
                     break
             h[None] = None  # denotes files present
 
     if mf and not files and not dirs:
         raise ErrorResponse(HTTP_NOT_FOUND, b'path not found: ' + path)
 
     def filelist(context):
         for f in sorted(files):
             full = files[f]
 
             fctx = ctx.filectx(full)
             yield {
                 b"file": full,
                 b"parity": next(parity),
                 b"basename": f,
                 b"date": fctx.date(),
                 b"size": fctx.size(),
                 b"permissions": mf.flags(full),
             }
 
     def dirlist(context):
         for d in sorted(dirs):
 
             emptydirs = []
             h = dirs[d]
             while isinstance(h, dict) and len(h) == 1:
                 k, v = next(iter(h.items()))
                 if v:
                     emptydirs.append(k)
                 h = v
 
             path = b"%s%s" % (abspath, d)
             yield {
                 b"parity": next(parity),
                 b"path": path,
                 b"emptydirs": b"/".join(emptydirs),
                 b"basename": d,
             }
 
     return web.sendtemplate(
         b'manifest',
         symrev=symrev,
         path=abspath,
         up=webutil.up(abspath),
         upparity=next(parity),
         fentries=templateutil.mappinggenerator(filelist),
         dentries=templateutil.mappinggenerator(dirlist),
         archives=web.archivelist(hex(node)),
         **pycompat.strkwargs(webutil.commonentry(web.repo, ctx))
     )
 
 
 @webcommand(b'tags')
 def tags(web):
     """
     /tags
     -----
 
     Show information about tags.
 
     No arguments are accepted.
 
     The ``tags`` template is rendered.
     """
     i = list(reversed(web.repo.tagslist()))
     parity = paritygen(web.stripecount)
 
     def entries(context, notip, latestonly):
         t = i
         if notip:
             t = [(k, n) for k, n in i if k != b"tip"]
         if latestonly:
             t = t[:1]
         for k, n in t:
             yield {
                 b"parity": next(parity),
                 b"tag": k,
                 b"date": web.repo[n].date(),
                 b"node": hex(n),
             }
 
     return web.sendtemplate(
         b'tags',
         node=hex(web.repo.changelog.tip()),
         entries=templateutil.mappinggenerator(entries, args=(False, False)),
         entriesnotip=templateutil.mappinggenerator(entries, args=(True, False)),
         latestentry=templateutil.mappinggenerator(entries, args=(True, True)),
     )
 
 
 @webcommand(b'bookmarks')
 def bookmarks(web):
     """
     /bookmarks
     ----------
 
     Show information about bookmarks.
 
     No arguments are accepted.
 
     The ``bookmarks`` template is rendered.
     """
     i = [b for b in web.repo._bookmarks.items() if b[1] in web.repo]
     sortkey = lambda b: (web.repo[b[1]].rev(), b[0])
     i = sorted(i, key=sortkey, reverse=True)
     parity = paritygen(web.stripecount)
 
     def entries(context, latestonly):
         t = i
         if latestonly:
             t = i[:1]
         for k, n in t:
             yield {
                 b"parity": next(parity),
                 b"bookmark": k,
                 b"date": web.repo[n].date(),
                 b"node": hex(n),
             }
 
     if i:
         latestrev = i[0][1]
     else:
         latestrev = -1
     lastdate = web.repo[latestrev].date()
 
     return web.sendtemplate(
         b'bookmarks',
         node=hex(web.repo.changelog.tip()),
         lastchange=templateutil.mappinglist([{b'date': lastdate}]),
         entries=templateutil.mappinggenerator(entries, args=(False,)),
         latestentry=templateutil.mappinggenerator(entries, args=(True,)),
     )
 
 
 @webcommand(b'branches')
 def branches(web):
     """
     /branches
     ---------
 
     Show information about branches.
 
     All known branches are contained in the output, even closed branches.
 
     No arguments are accepted.
 
     The ``branches`` template is rendered.
     """
     entries = webutil.branchentries(web.repo, web.stripecount)
     latestentry = webutil.branchentries(web.repo, web.stripecount, 1)
 
     return web.sendtemplate(
         b'branches',
         node=hex(web.repo.changelog.tip()),
         entries=entries,
         latestentry=latestentry,
     )
 
 
 @webcommand(b'summary')
 def summary(web):
     """
     /summary
     --------
 
     Show a summary of repository state.
 
     Information about the latest changesets, bookmarks, tags, and branches
     is captured by this handler.
 
     The ``summary`` template is rendered.
     """
     i = reversed(web.repo.tagslist())
 
     def tagentries(context):
         parity = paritygen(web.stripecount)
         count = 0
         for k, n in i:
             if k == b"tip":  # skip tip
                 continue
 
             count += 1
             if count > 10:  # limit to 10 tags
                 break
 
             yield {
                 b'parity': next(parity),
                 b'tag': k,
                 b'node': hex(n),
                 b'date': web.repo[n].date(),
             }
 
     def bookmarks(context):
         parity = paritygen(web.stripecount)
         marks = [b for b in web.repo._bookmarks.items() if b[1] in web.repo]
         sortkey = lambda b: (web.repo[b[1]].rev(), b[0])
         marks = sorted(marks, key=sortkey, reverse=True)
         for k, n in marks[:10]:  # limit to 10 bookmarks
             yield {
                 b'parity': next(parity),
                 b'bookmark': k,
                 b'date': web.repo[n].date(),
                 b'node': hex(n),
             }
 
     def changelist(context):
         parity = paritygen(web.stripecount, offset=start - end)
         l = []  # build a list in forward order for efficiency
         revs = []
         if start < end:
             revs = web.repo.changelog.revs(start, end - 1)
         for i in revs:
             ctx = web.repo[i]
             lm = webutil.commonentry(web.repo, ctx)
             lm[b'parity'] = next(parity)
             l.append(lm)
 
         for entry in reversed(l):
             yield entry
 
     tip = web.repo[b'tip']
     count = len(web.repo)
     start = max(0, count - web.maxchanges)
     end = min(count, start + web.maxchanges)
 
     desc = web.config(b"web", b"description")
     if not desc:
         desc = b'unknown'
     labels = web.configlist(b'web', b'labels')
 
     return web.sendtemplate(
         b'summary',
         desc=desc,
         owner=get_contact(web.config) or b'unknown',
         lastchange=tip.date(),
         tags=templateutil.mappinggenerator(tagentries, name=b'tagentry'),
         bookmarks=templateutil.mappinggenerator(bookmarks),
         branches=webutil.branchentries(web.repo, web.stripecount, 10),
         shortlog=templateutil.mappinggenerator(
             changelist, name=b'shortlogentry'
         ),
         node=tip.hex(),
         symrev=b'tip',
         archives=web.archivelist(b'tip'),
         labels=templateutil.hybridlist(labels, name=b'label'),
     )
 
 
 @webcommand(b'filediff')
 def filediff(web):
     """
     /diff/{revision}/{path}
     -----------------------
 
     Show how a file changed in a particular commit.
 
     The ``filediff`` template is rendered.
 
     This handler is registered under both the ``/diff`` and ``/filediff``
     paths. ``/diff`` is used in modern code.
     """
     fctx, ctx = None, None
     try:
         fctx = webutil.filectx(web.repo, web.req)
     except LookupError:
         ctx = webutil.changectx(web.repo, web.req)
         path = webutil.cleanpath(web.repo, web.req.qsparams[b'file'])
         if path not in ctx.files():
             raise
 
     if fctx is not None:
         path = fctx.path()
         ctx = fctx.changectx()
     basectx = ctx.p1()
 
     style = web.config(b'web', b'style')
     if b'style' in web.req.qsparams:
         style = web.req.qsparams[b'style']
 
     diffs = webutil.diffs(web, ctx, basectx, [path], style)
     if fctx is not None:
         rename = webutil.renamelink(fctx)
         ctx = fctx
     else:
         rename = templateutil.mappinglist([])
         ctx = ctx
 
     return web.sendtemplate(
         b'filediff',
         file=path,
         symrev=webutil.symrevorshortnode(web.req, ctx),
         rename=rename,
         diff=diffs,
         **pycompat.strkwargs(webutil.commonentry(web.repo, ctx))
     )
 
 
 diff = webcommand(b'diff')(filediff)
 
 
 @webcommand(b'comparison')
 def comparison(web):
     """
     /comparison/{revision}/{path}
     -----------------------------
 
     Show a comparison between the old and new versions of a file from changes
     made on a particular revision.
 
     This is similar to the ``diff`` handler. However, this form features
     a split or side-by-side diff rather than a unified diff.
 
     The ``context`` query string argument can be used to control the lines of
     context in the diff.
 
     The ``filecomparison`` template is rendered.
     """
     ctx = webutil.changectx(web.repo, web.req)
     if b'file' not in web.req.qsparams:
         raise ErrorResponse(HTTP_NOT_FOUND, b'file not given')
     path = webutil.cleanpath(web.repo, web.req.qsparams[b'file'])
 
     parsecontext = lambda v: v == b'full' and -1 or int(v)
     if b'context' in web.req.qsparams:
         context = parsecontext(web.req.qsparams[b'context'])
     else:
         context = parsecontext(web.config(b'web', b'comparisoncontext'))
 
     def filelines(f):
         if f.isbinary():
             mt = pycompat.sysbytes(
                 mimetypes.guess_type(pycompat.fsdecode(f.path()))[0]
                 or r'application/octet-stream'
             )
             return [_(b'(binary file %s, hash: %s)') % (mt, hex(f.filenode()))]
         return f.data().splitlines()
 
     fctx = None
     parent = ctx.p1()
     leftrev = parent.rev()
     leftnode = parent.node()
     rightrev = ctx.rev()
     rightnode = scmutil.binnode(ctx)
     if path in ctx:
         fctx = ctx[path]
         rightlines = filelines(fctx)
         if path not in parent:
             leftlines = ()
         else:
             pfctx = parent[path]
             leftlines = filelines(pfctx)
     else:
         rightlines = ()
         pfctx = ctx.p1()[path]
         leftlines = filelines(pfctx)
 
     comparison = webutil.compare(context, leftlines, rightlines)
     if fctx is not None:
         rename = webutil.renamelink(fctx)
         ctx = fctx
     else:
         rename = templateutil.mappinglist([])
         ctx = ctx
 
     return web.sendtemplate(
         b'filecomparison',
         file=path,
         symrev=webutil.symrevorshortnode(web.req, ctx),
         rename=rename,
         leftrev=leftrev,
         leftnode=hex(leftnode),
         rightrev=rightrev,
         rightnode=hex(rightnode),
         comparison=comparison,
         **pycompat.strkwargs(webutil.commonentry(web.repo, ctx))
     )
 
 
 @webcommand(b'annotate')
 def annotate(web):
     """
     /annotate/{revision}/{path}
     ---------------------------
 
     Show changeset information for each line in a file.
 
     The ``ignorews``, ``ignorewsamount``, ``ignorewseol``, and
     ``ignoreblanklines`` query string arguments have the same meaning as
     their ``[annotate]`` config equivalents. It uses the hgrc boolean
     parsing logic to interpret the value. e.g. ``0`` and ``false`` are
     false and ``1`` and ``true`` are true. If not defined, the server
     default settings are used.
 
     The ``fileannotate`` template is rendered.
     """
     fctx = webutil.filectx(web.repo, web.req)
     f = fctx.path()
     parity = paritygen(web.stripecount)
     ishead = fctx.filenode() in fctx.filelog().heads()
 
     # parents() is called once per line and several lines likely belong to
     # same revision. So it is worth caching.
     # TODO there are still redundant operations within basefilectx.parents()
     # and from the fctx.annotate() call itself that could be cached.
     parentscache = {}
 
     def parents(context, f):
         rev = f.rev()
         if rev not in parentscache:
             parentscache[rev] = []
             for p in f.parents():
                 entry = {
                     b'node': p.hex(),
                     b'rev': p.rev(),
                 }
                 parentscache[rev].append(entry)
 
         for p in parentscache[rev]:
             yield p
 
     def annotate(context):
         if fctx.isbinary():
             mt = pycompat.sysbytes(
                 mimetypes.guess_type(pycompat.fsdecode(fctx.path()))[0]
                 or r'application/octet-stream'
             )
             lines = [
                 dagop.annotateline(
                     fctx=fctx.filectx(fctx.filerev()),
                     lineno=1,
                     text=b'(binary:%s)' % mt,
                 )
             ]
         else:
             lines = webutil.annotate(web.req, fctx, web.repo.ui)
 
         previousrev = None
         blockparitygen = paritygen(1)
         for lineno, aline in enumerate(lines):
             f = aline.fctx
             rev = f.rev()
             if rev != previousrev:
                 blockhead = True
                 blockparity = next(blockparitygen)
             else:
                 blockhead = None
             previousrev = rev
             yield {
                 b"parity": next(parity),
                 b"node": f.hex(),
                 b"rev": rev,
                 b"author": f.user(),
                 b"parents": templateutil.mappinggenerator(parents, args=(f,)),
                 b"desc": f.description(),
                 b"extra": f.extra(),
                 b"file": f.path(),
                 b"blockhead": blockhead,
                 b"blockparity": blockparity,
                 b"targetline": aline.lineno,
                 b"line": aline.text,
                 b"lineno": lineno + 1,
                 b"lineid": b"l%d" % (lineno + 1),
                 b"linenumber": b"% 6d" % (lineno + 1),
                 b"revdate": f.date(),
             }
 
     diffopts = webutil.difffeatureopts(web.req, web.repo.ui, b'annotate')
     diffopts = {k: getattr(diffopts, k) for k in diffopts.defaults}
 
     return web.sendtemplate(
         b'fileannotate',
         file=f,
         annotate=templateutil.mappinggenerator(annotate),
         path=webutil.up(f),
         symrev=webutil.symrevorshortnode(web.req, fctx),
         rename=webutil.renamelink(fctx),
         permissions=fctx.manifest().flags(f),
         ishead=int(ishead),
         diffopts=templateutil.hybriddict(diffopts),
         **pycompat.strkwargs(webutil.commonentry(web.repo, fctx))
     )
 
 
 @webcommand(b'filelog')
 def filelog(web):
     """
     /filelog/{revision}/{path}
     --------------------------
 
     Show information about the history of a file in the repository.
 
     The ``revcount`` query string argument can be defined to control the
     maximum number of entries to show.
 
     The ``filelog`` template will be rendered.
     """
 
     try:
         fctx = webutil.filectx(web.repo, web.req)
         f = fctx.path()
         fl = fctx.filelog()
     except error.LookupError:
         f = webutil.cleanpath(web.repo, web.req.qsparams[b'file'])
         fl = web.repo.file(f)
         numrevs = len(fl)
         if not numrevs:  # file doesn't exist at all
             raise
         rev = webutil.changectx(web.repo, web.req).rev()
         first = fl.linkrev(0)
         if rev < first:  # current rev is from before file existed
             raise
         frev = numrevs - 1
         while fl.linkrev(frev) > rev:
             frev -= 1
         fctx = web.repo.filectx(f, fl.linkrev(frev))
 
     revcount = web.maxshortchanges
     if b'revcount' in web.req.qsparams:
         try:
             revcount = int(web.req.qsparams.get(b'revcount', revcount))
             revcount = max(revcount, 1)
             web.tmpl.defaults[b'sessionvars'][b'revcount'] = revcount
         except ValueError:
             pass
 
     lrange = webutil.linerange(web.req)
 
     lessvars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     lessvars[b'revcount'] = max(revcount // 2, 1)
     morevars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     morevars[b'revcount'] = revcount * 2
 
     patch = b'patch' in web.req.qsparams
     if patch:
         lessvars[b'patch'] = morevars[b'patch'] = web.req.qsparams[b'patch']
     descend = b'descend' in web.req.qsparams
     if descend:
         lessvars[b'descend'] = morevars[b'descend'] = web.req.qsparams[
             b'descend'
         ]
 
     count = fctx.filerev() + 1
     start = max(0, count - revcount)  # first rev on this page
     end = min(count, start + revcount)  # last rev on this page
     parity = paritygen(web.stripecount, offset=start - end)
 
     repo = web.repo
     filelog = fctx.filelog()
     revs = [
         filerev
         for filerev in filelog.revs(start, end - 1)
         if filelog.linkrev(filerev) in repo
     ]
     entries = []
 
     diffstyle = web.config(b'web', b'style')
     if b'style' in web.req.qsparams:
         diffstyle = web.req.qsparams[b'style']
 
     def diff(fctx, linerange=None):
         ctx = fctx.changectx()
         basectx = ctx.p1()
         path = fctx.path()
         return webutil.diffs(
             web,
             ctx,
             basectx,
             [path],
             diffstyle,
             linerange=linerange,
             lineidprefix=b'%s-' % ctx.hex()[:12],
         )
 
     linerange = None
     if lrange is not None:
         linerange = webutil.formatlinerange(*lrange)
         # deactivate numeric nav links when linerange is specified as this
         # would required a dedicated "revnav" class
         nav = templateutil.mappinglist([])
         if descend:
             it = dagop.blockdescendants(fctx, *lrange)
         else:
             it = dagop.blockancestors(fctx, *lrange)
         for i, (c, lr) in enumerate(it, 1):
             diffs = None
             if patch:
                 diffs = diff(c, linerange=lr)
             # follow renames accross filtered (not in range) revisions
             path = c.path()
             lm = webutil.commonentry(repo, c)
             lm.update(
                 {
                     b'parity': next(parity),
                     b'filerev': c.rev(),
                     b'file': path,
                     b'diff': diffs,
                     b'linerange': webutil.formatlinerange(*lr),
                     b'rename': templateutil.mappinglist([]),
                 }
             )
             entries.append(lm)
             if i == revcount:
                 break
         lessvars[b'linerange'] = webutil.formatlinerange(*lrange)
         morevars[b'linerange'] = lessvars[b'linerange']
     else:
         for i in revs:
             iterfctx = fctx.filectx(i)
             diffs = None
             if patch:
                 diffs = diff(iterfctx)
             lm = webutil.commonentry(repo, iterfctx)
             lm.update(
                 {
                     b'parity': next(parity),
                     b'filerev': i,
                     b'file': f,
                     b'diff': diffs,
                     b'rename': webutil.renamelink(iterfctx),
                 }
             )
             entries.append(lm)
         entries.reverse()
         revnav = webutil.filerevnav(web.repo, fctx.path())
         nav = revnav.gen(end - 1, revcount, count)
 
     latestentry = entries[:1]
 
     return web.sendtemplate(
         b'filelog',
         file=f,
         nav=nav,
         symrev=webutil.symrevorshortnode(web.req, fctx),
         entries=templateutil.mappinglist(entries),
         descend=descend,
         patch=patch,
         latestentry=templateutil.mappinglist(latestentry),
         linerange=linerange,
         revcount=revcount,
         morevars=morevars,
         lessvars=lessvars,
         **pycompat.strkwargs(webutil.commonentry(web.repo, fctx))
     )
 
 
 @webcommand(b'archive')
 def archive(web):
     """
     /archive/{revision}.{format}[/{path}]
     -------------------------------------
 
     Obtain an archive of repository content.
 
     The content and type of the archive is defined by a URL path parameter.
     ``format`` is the file extension of the archive type to be generated. e.g.
     ``zip`` or ``tar.bz2``. Not all archive types may be allowed by your
     server configuration.
 
     The optional ``path`` URL parameter controls content to include in the
     archive. If omitted, every file in the specified revision is present in the
     archive. If included, only the specified file or contents of the specified
     directory will be included in the archive.
 
     No template is used for this handler. Raw, binary content is generated.
     """
 
     type_ = web.req.qsparams.get(b'type')
     allowed = web.configlist(b"web", b"allow-archive")
     key = web.req.qsparams[b'node']
 
     if type_ not in webutil.archivespecs:
         msg = b'Unsupported archive type: %s' % stringutil.pprint(type_)
         raise ErrorResponse(HTTP_NOT_FOUND, msg)
 
     if not ((type_ in allowed or web.configbool(b"web", b"allow" + type_))):
         msg = b'Archive type not allowed: %s' % type_
         raise ErrorResponse(HTTP_FORBIDDEN, msg)
 
     reponame = re.sub(br"\W+", b"-", os.path.basename(web.reponame))
     cnode = web.repo.lookup(key)
     arch_version = key
     if cnode == key or key == b'tip':
         arch_version = short(cnode)
     name = b"%s-%s" % (reponame, arch_version)
 
     ctx = webutil.changectx(web.repo, web.req)
     match = scmutil.match(ctx, [])
     file = web.req.qsparams.get(b'file')
     if file:
         pats = [b'path:' + file]
         match = scmutil.match(ctx, pats, default=b'path')
         if pats:
             files = [f for f in ctx.manifest().keys() if match(f)]
             if not files:
                 raise ErrorResponse(
                     HTTP_NOT_FOUND, b'file(s) not found: %s' % file
                 )
 
     mimetype, artype, extension, encoding = webutil.archivespecs[type_]
 
     web.res.headers[b'Content-Type'] = mimetype
     web.res.headers[b'Content-Disposition'] = b'attachment; filename=%s%s' % (
         name,
         extension,
     )
 
     if encoding:
         web.res.headers[b'Content-Encoding'] = encoding
 
     web.res.setbodywillwrite()
     if list(web.res.sendresponse()):
         raise error.ProgrammingError(
             b'sendresponse() should not emit data if writing later'
         )
 
     bodyfh = web.res.getbodyfile()
 
     archival.archive(
         web.repo,
         bodyfh,
         cnode,
         artype,
         prefix=name,
         match=match,
         subrepos=web.configbool(b"web", b"archivesubrepos"),
     )
 
     return []
 
 
 @webcommand(b'static')
 def static(web):
     fname = web.req.qsparams[b'file']
     # a repo owner may set web.static in .hg/hgrc to get any file
     # readable by the user running the CGI script
     static = web.config(b"web", b"static", untrusted=False)
     if not static:
         tp = web.templatepath or templater.templatedir()
-        static = [os.path.join(tp, b'static')]
+        static = os.path.join(tp, b'static')
 
     staticfile(static, fname, web.res)
     return web.res.sendresponse()
 
 
 @webcommand(b'graph')
 def graph(web):
     """
     /graph[/{revision}]
     -------------------
 
     Show information about the graphical topology of the repository.
 
     Information rendered by this handler can be used to create visual
     representations of repository topology.
 
     The ``revision`` URL parameter controls the starting changeset. If it's
     absent, the default is ``tip``.
 
     The ``revcount`` query string argument can define the number of changesets
     to show information for.
 
     The ``graphtop`` query string argument can specify the starting changeset
     for producing ``jsdata`` variable that is used for rendering graph in
     JavaScript. By default it has the same value as ``revision``.
 
     This handler will render the ``graph`` template.
     """
 
     if b'node' in web.req.qsparams:
         ctx = webutil.changectx(web.repo, web.req)
         symrev = webutil.symrevorshortnode(web.req, ctx)
     else:
         ctx = web.repo[b'tip']
         symrev = b'tip'
     rev = ctx.rev()
 
     bg_height = 39
     revcount = web.maxshortchanges
     if b'revcount' in web.req.qsparams:
         try:
             revcount = int(web.req.qsparams.get(b'revcount', revcount))
             revcount = max(revcount, 1)
             web.tmpl.defaults[b'sessionvars'][b'revcount'] = revcount
         except ValueError:
             pass
 
     lessvars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     lessvars[b'revcount'] = max(revcount // 2, 1)
     morevars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     morevars[b'revcount'] = revcount * 2
 
     graphtop = web.req.qsparams.get(b'graphtop', ctx.hex())
     graphvars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     graphvars[b'graphtop'] = graphtop
 
     count = len(web.repo)
     pos = rev
 
     uprev = min(max(0, count - 1), rev + revcount)
     downrev = max(0, rev - revcount)
     changenav = webutil.revnav(web.repo).gen(pos, revcount, count)
 
     tree = []
     nextentry = []
     lastrev = 0
     if pos != -1:
         allrevs = web.repo.changelog.revs(pos, 0)
         revs = []
         for i in allrevs:
             revs.append(i)
             if len(revs) >= revcount + 1:
                 break
 
         if len(revs) > revcount:
             nextentry = [webutil.commonentry(web.repo, web.repo[revs[-1]])]
             revs = revs[:-1]
 
         lastrev = revs[-1]
 
         # We have to feed a baseset to dagwalker as it is expecting smartset
         # object. This does not have a big impact on hgweb performance itself
         # since hgweb graphing code is not itself lazy yet.
         dag = graphmod.dagwalker(web.repo, smartset.baseset(revs))
         # As we said one line above... not lazy.
         tree = list(
             item
             for item in graphmod.colored(dag, web.repo)
             if item[1] == graphmod.CHANGESET
         )
 
     def fulltree():
         pos = web.repo[graphtop].rev()
         tree = []
         if pos != -1:
             revs = web.repo.changelog.revs(pos, lastrev)
             dag = graphmod.dagwalker(web.repo, smartset.baseset(revs))
             tree = list(
                 item
                 for item in graphmod.colored(dag, web.repo)
                 if item[1] == graphmod.CHANGESET
             )
         return tree
 
     def jsdata(context):
         for (id, type, ctx, vtx, edges) in fulltree():
             yield {
                 b'node': pycompat.bytestr(ctx),
                 b'graphnode': webutil.getgraphnode(web.repo, ctx),
                 b'vertex': vtx,
                 b'edges': edges,
             }
 
     def nodes(context):
         parity = paritygen(web.stripecount)
         for row, (id, type, ctx, vtx, edges) in enumerate(tree):
             entry = webutil.commonentry(web.repo, ctx)
             edgedata = [
                 {
                     b'col': edge[0],
                     b'nextcol': edge[1],
                     b'color': (edge[2] - 1) % 6 + 1,
                     b'width': edge[3],
                     b'bcolor': edge[4],
                 }
                 for edge in edges
             ]
 
             entry.update(
                 {
                     b'col': vtx[0],
                     b'color': (vtx[1] - 1) % 6 + 1,
                     b'parity': next(parity),
                     b'edges': templateutil.mappinglist(edgedata),
                     b'row': row,
                     b'nextrow': row + 1,
                 }
             )
 
             yield entry
 
     rows = len(tree)
 
     return web.sendtemplate(
         b'graph',
         rev=rev,
         symrev=symrev,
         revcount=revcount,
         uprev=uprev,
         lessvars=lessvars,
         morevars=morevars,
         downrev=downrev,
         graphvars=graphvars,
         rows=rows,
         bg_height=bg_height,
         changesets=count,
         nextentry=templateutil.mappinglist(nextentry),
         jsdata=templateutil.mappinggenerator(jsdata),
         nodes=templateutil.mappinggenerator(nodes),
         node=ctx.hex(),
         archives=web.archivelist(b'tip'),
         changenav=changenav,
     )
 
 
 def _getdoc(e):
     doc = e[0].__doc__
     if doc:
         doc = _(doc).partition(b'\n')[0]
     else:
         doc = _(b'(no help text available)')
     return doc
 
 
 @webcommand(b'help')
 def help(web):
     """
     /help[/{topic}]
     ---------------
 
     Render help documentation.
 
     This web command is roughly equivalent to :hg:`help`. If a ``topic``
     is defined, that help topic will be rendered. If not, an index of
     available help topics will be rendered.
 
     The ``help`` template will be rendered when requesting help for a topic.
     ``helptopics`` will be rendered for the index of help topics.
     """
     from .. import commands, help as helpmod  # avoid cycle
 
     topicname = web.req.qsparams.get(b'node')
     if not topicname:
 
         def topics(context):
             for h in helpmod.helptable:
                 entries, summary, _doc = h[0:3]
                 yield {b'topic': entries[0], b'summary': summary}
 
         early, other = [], []
         primary = lambda s: s.partition(b'|')[0]
         for c, e in pycompat.iteritems(commands.table):
             doc = _getdoc(e)
             if b'DEPRECATED' in doc or c.startswith(b'debug'):
                 continue
             cmd = primary(c)
             if getattr(e[0], 'helpbasic', False):
                 early.append((cmd, doc))
             else:
                 other.append((cmd, doc))
 
         early.sort()
         other.sort()
 
         def earlycommands(context):
             for c, doc in early:
                 yield {b'topic': c, b'summary': doc}
 
         def othercommands(context):
             for c, doc in other:
                 yield {b'topic': c, b'summary': doc}
 
         return web.sendtemplate(
             b'helptopics',
             topics=templateutil.mappinggenerator(topics),
             earlycommands=templateutil.mappinggenerator(earlycommands),
             othercommands=templateutil.mappinggenerator(othercommands),
             title=b'Index',
         )
 
     # Render an index of sub-topics.
     if topicname in helpmod.subtopics:
         topics = []
         for entries, summary, _doc in helpmod.subtopics[topicname]:
             topics.append(
                 {
                     b'topic': b'%s.%s' % (topicname, entries[0]),
                     b'basename': entries[0],
                     b'summary': summary,
                 }
             )
 
         return web.sendtemplate(
             b'helptopics',
             topics=templateutil.mappinglist(topics),
             title=topicname,
             subindex=True,
         )
 
     u = webutil.wsgiui.load()
     u.verbose = True
 
     # Render a page from a sub-topic.
     if b'.' in topicname:
         # TODO implement support for rendering sections, like
         # `hg help` works.
         topic, subtopic = topicname.split(b'.', 1)
         if topic not in helpmod.subtopics:
             raise ErrorResponse(HTTP_NOT_FOUND)
     else:
         topic = topicname
         subtopic = None
 
     try:
         doc = helpmod.help_(u, commands, topic, subtopic=subtopic)
     except error.Abort:
         raise ErrorResponse(HTTP_NOT_FOUND)
 
     return web.sendtemplate(b'help', topic=topicname, doc=doc)
 
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = commands.values()