hgweb: use absolute_import

mercurial/hgweb/__init__.py

@@ -1,31 +1,37 b''
 # hgweb/__init__.py - web interface to a mercurial repository
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005 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 os
-import hgweb_mod, hgwebdir_mod
+
+from . import (
+    hgweb_mod,
+    hgwebdir_mod,
+)
 
 def hgweb(config, name=None, baseui=None):
     '''create an hgweb wsgi object
 
     config can be one of:
     - repo object (single repo view)
     - path to repo (single repo view)
     - path to config file (multi-repo view)
     - dict of virtual:real pairs (multi-repo view)
     - list of virtual:real tuples (multi-repo view)
     '''
 
     if ((isinstance(config, str) and not os.path.isdir(config)) or
         isinstance(config, dict) or isinstance(config, list)):
         # create a multi-dir interface
         return hgwebdir_mod.hgwebdir(config, baseui=baseui)
     return hgweb_mod.hgweb(config, name=name, baseui=baseui)
 
 def hgwebdir(config, baseui=None):
     return hgwebdir_mod.hgwebdir(config, baseui=baseui)
 

mercurial/hgweb/common.py

@@ -1,189 +1,193 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 BaseHTTPServer
-import errno, mimetypes, os
+import errno
+import mimetypes
+import os
 
 HTTP_OK = 200
 HTTP_NOT_MODIFIED = 304
 HTTP_BAD_REQUEST = 400
 HTTP_UNAUTHORIZED = 401
 HTTP_FORBIDDEN = 403
 HTTP_NOT_FOUND = 404
 HTTP_METHOD_NOT_ALLOWED = 405
 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 == ['*'] 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.env.get('REMOTE_USER')
 
     deny_read = hgweb.configlist('web', 'deny_read')
     if deny_read and (not user or ismember(hgweb.repo.ui, user, deny_read)):
         raise ErrorResponse(HTTP_UNAUTHORIZED, 'read not authorized')
 
     allow_read = hgweb.configlist('web', 'allow_read')
     if allow_read and (not ismember(hgweb.repo.ui, user, allow_read)):
         raise ErrorResponse(HTTP_UNAUTHORIZED, 'read not authorized')
 
     if op == 'pull' and not hgweb.allowpull:
         raise ErrorResponse(HTTP_UNAUTHORIZED, 'pull not authorized')
     elif op == 'pull' or op is None: # op is None for interface requests
         return
 
     # enforce that you can only push using POST requests
     if req.env['REQUEST_METHOD'] != 'POST':
         msg = 'push requires POST request'
         raise ErrorResponse(HTTP_METHOD_NOT_ALLOWED, msg)
 
     # require ssl by default for pushing, auth info cannot be sniffed
     # and replayed
     scheme = req.env.get('wsgi.url_scheme')
     if hgweb.configbool('web', 'push_ssl', True) and scheme != 'https':
         raise ErrorResponse(HTTP_FORBIDDEN, 'ssl required')
 
     deny = hgweb.configlist('web', 'deny_push')
     if deny and (not user or ismember(hgweb.repo.ui, user, deny)):
         raise ErrorResponse(HTTP_UNAUTHORIZED, 'push not authorized')
 
     allow = hgweb.configlist('web', 'allow_push')
     if not (allow and ismember(hgweb.repo.ui, user, allow)):
         raise ErrorResponse(HTTP_UNAUTHORIZED, '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 or push. 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=[]):
         if message is None:
             message = _statusmessage(code)
         Exception.__init__(self, message)
         self.code = code
         self.headers = headers
 
 class continuereader(object):
     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('HTTP/1.1 100 Continue\r\n\r\n')
         return self.f.read(amt)
 
     def __getattr__(self, attr):
         if attr in ('close', 'readline', 'readlines', '__iter__'):
             return getattr(self.f, attr)
         raise AttributeError
 
 def _statusmessage(code):
     responses = BaseHTTPServer.BaseHTTPRequestHandler.responses
     return responses.get(code, ('Error', 'Unknown error'))[0]
 
 def statusmessage(code, message=None):
     return '%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, "00changelog.i").st_mtime
 
 def staticfile(directory, fname, req):
     """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.
 
     """
     parts = fname.split('/')
     for part in parts:
         if (part in ('', os.curdir, os.pardir) or
             os.sep in part or os.altsep is not None and os.altsep in part):
             return
     fpath = os.path.join(*parts)
     if isinstance(directory, str):
         directory = [directory]
     for d in directory:
         path = os.path.join(d, fpath)
         if os.path.exists(path):
             break
     try:
         os.stat(path)
         ct = mimetypes.guess_type(path)[0] or "text/plain"
         fp = open(path, 'rb')
         data = fp.read()
         fp.close()
         req.respond(HTTP_OK, ct, body=data)
     except TypeError:
         raise ErrorResponse(HTTP_SERVER_ERROR, 'illegal filename')
     except OSError as err:
         if err.errno == errno.ENOENT:
             raise ErrorResponse(HTTP_NOT_FOUND)
         else:
             raise ErrorResponse(HTTP_SERVER_ERROR, 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("web", "contact") or
             config("ui", "username") or
             os.environ.get("EMAIL") or "")
 
 def caching(web, req):
     tag = str(web.mtime)
     if req.env.get('HTTP_IF_NONE_MATCH') == tag:
         raise ErrorResponse(HTTP_NOT_MODIFIED)
     req.headers.append(('ETag', tag))

mercurial/hgweb/hgweb_mod.py

@@ -1,441 +1,466 b''
 # hgweb/hgweb_mod.py - Web interface for a repository.
 #
 # 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 contextlib
 import os
-from mercurial import hg, hook, error, encoding, templater, util, repoview
-from mercurial import ui as uimod
-from mercurial import templatefilters
-from common import ErrorResponse, permhooks, caching
-from common import HTTP_OK, HTTP_NOT_MODIFIED, HTTP_BAD_REQUEST
-from common import HTTP_NOT_FOUND, HTTP_SERVER_ERROR
-from request import wsgirequest
-import webcommands, protocol, webutil, wsgicgi
+
+from .common import (
+    ErrorResponse,
+    HTTP_BAD_REQUEST,
+    HTTP_NOT_FOUND,
+    HTTP_NOT_MODIFIED,
+    HTTP_OK,
+    HTTP_SERVER_ERROR,
+    caching,
+    permhooks,
+)
+from .request import wsgirequest
+
+from .. import (
+    encoding,
+    error,
+    hg,
+    hook,
+    repoview,
+    templatefilters,
+    templater,
+    ui as uimod,
+    util,
+)
+
+from . import (
+    protocol,
+    webcommands,
+    webutil,
+    wsgicgi,
+)
 
 perms = {
     'changegroup': 'pull',
     'changegroupsubset': 'pull',
     'getbundle': 'pull',
     'stream_out': 'pull',
     'listkeys': 'pull',
     'unbundle': 'push',
     'pushkey': 'push',
 }
 
 def makebreadcrumb(url, prefix=''):
     '''Return a 'URL breadcrumb' list
 
     A 'URL breadcrumb' is a list of URL-name pairs,
     corresponding to each of the path items on a URL.
     This can be used to create path navigation entries.
     '''
     if url.endswith('/'):
         url = url[:-1]
     if prefix:
         url = '/' + prefix + url
     relpath = url
     if relpath.startswith('/'):
         relpath = relpath[1:]
 
     breadcrumb = []
     urlel = url
     pathitems = [''] + relpath.split('/')
     for pathel in reversed(pathitems):
         if not pathel or not urlel:
             break
         breadcrumb.append({'url': urlel, 'name': pathel})
         urlel = os.path.dirname(urlel)
     return reversed(breadcrumb)
 
 class requestcontext(object):
     """Holds state/context for an individual request.
 
     Servers can be multi-threaded. Holding state on the WSGI application
     is prone to race conditions. Instances of this class exist to hold
     mutable and race-free state for requests.
     """
     def __init__(self, app, repo):
         self.repo = repo
         self.reponame = app.reponame
 
         self.archives = ('zip', 'gz', 'bz2')
 
         self.maxchanges = self.configint('web', 'maxchanges', 10)
         self.stripecount = self.configint('web', 'stripes', 1)
         self.maxshortchanges = self.configint('web', 'maxshortchanges', 60)
         self.maxfiles = self.configint('web', 'maxfiles', 10)
         self.allowpull = self.configbool('web', 'allowpull', True)
 
         # we use untrusted=False to prevent a repo owner from using
         # web.templates in .hg/hgrc to get access to any file readable
         # by the user running the CGI script
         self.templatepath = self.config('web', 'templates', untrusted=False)
 
         # This object is more expensive to build than simple config values.
         # It is shared across requests. The app will replace the object
         # if it is updated. Since this is a reference and nothing should
         # modify the underlying object, it should be constant for the lifetime
         # of the request.
         self.websubtable = app.websubtable
 
     # Trust the settings from the .hg/hgrc files by default.
     def config(self, section, name, default=None, untrusted=True):
         return self.repo.ui.config(section, name, default,
                                    untrusted=untrusted)
 
     def configbool(self, section, name, default=False, untrusted=True):
         return self.repo.ui.configbool(section, name, default,
                                        untrusted=untrusted)
 
     def configint(self, section, name, default=None, untrusted=True):
         return self.repo.ui.configint(section, name, default,
                                       untrusted=untrusted)
 
     def configlist(self, section, name, default=None, untrusted=True):
         return self.repo.ui.configlist(section, name, default,
                                        untrusted=untrusted)
 
     archivespecs = {
         'bz2': ('application/x-bzip2', 'tbz2', '.tar.bz2', None),
         'gz': ('application/x-gzip', 'tgz', '.tar.gz', None),
         'zip': ('application/zip', 'zip', '.zip', None),
     }
 
     def archivelist(self, nodeid):
         allowed = self.configlist('web', 'allow_archive')
         for typ, spec in self.archivespecs.iteritems():
             if typ in allowed or self.configbool('web', 'allow%s' % typ):
                 yield {'type': typ, 'extension': spec[2], 'node': nodeid}
 
     def templater(self, req):
         # determine scheme, port and server name
         # this is needed to create absolute urls
 
         proto = req.env.get('wsgi.url_scheme')
         if proto == 'https':
             proto = 'https'
             default_port = '443'
         else:
             proto = 'http'
             default_port = '80'
 
         port = req.env['SERVER_PORT']
         port = port != default_port and (':' + port) or ''
         urlbase = '%s://%s%s' % (proto, req.env['SERVER_NAME'], port)
         logourl = self.config('web', 'logourl', 'https://mercurial-scm.org/')
         logoimg = self.config('web', 'logoimg', 'hglogo.png')
         staticurl = self.config('web', 'staticurl') or req.url + 'static/'
         if not staticurl.endswith('/'):
             staticurl += '/'
 
         # some functions for the templater
 
         def motd(**map):
             yield self.config('web', 'motd', '')
 
         # figure out which style to use
 
         vars = {}
         styles = (
             req.form.get('style', [None])[0],
             self.config('web', 'style'),
             'paper',
         )
         style, mapfile = templater.stylemap(styles, self.templatepath)
         if style == styles[0]:
             vars['style'] = style
 
         start = req.url[-1] == '?' and '&' or '?'
         sessionvars = webutil.sessionvars(vars, start)
 
         if not self.reponame:
             self.reponame = (self.config('web', 'name')
                              or req.env.get('REPO_NAME')
                              or req.url.strip('/') or self.repo.root)
 
         def websubfilter(text):
             return templatefilters.websub(text, self.websubtable)
 
         # create the templater
 
         tmpl = templater.templater(mapfile,
                                    filters={'websub': websubfilter},
                                    defaults={'url': req.url,
                                              'logourl': logourl,
                                              'logoimg': logoimg,
                                              'staticurl': staticurl,
                                              'urlbase': urlbase,
                                              'repo': self.reponame,
                                              'encoding': encoding.encoding,
                                              'motd': motd,
                                              'sessionvars': sessionvars,
                                              'pathdef': makebreadcrumb(req.url),
                                              'style': style,
                                             })
         return tmpl
 
 
 class hgweb(object):
     """HTTP server for individual repositories.
 
     Instances of this class serve HTTP responses for a particular
     repository.
 
     Instances are typically used as WSGI applications.
 
     Some servers are multi-threaded. On these servers, there may
     be multiple active threads inside __call__.
     """
     def __init__(self, repo, name=None, baseui=None):
         if isinstance(repo, str):
             if baseui:
                 u = baseui.copy()
             else:
                 u = uimod.ui()
             r = hg.repository(u, repo)
         else:
             # we trust caller to give us a private copy
             r = repo
 
         r.ui.setconfig('ui', 'report_untrusted', 'off', 'hgweb')
         r.baseui.setconfig('ui', 'report_untrusted', 'off', 'hgweb')
         r.ui.setconfig('ui', 'nontty', 'true', 'hgweb')
         r.baseui.setconfig('ui', 'nontty', 'true', 'hgweb')
         # resolve file patterns relative to repo root
         r.ui.setconfig('ui', 'forcecwd', r.root, 'hgweb')
         r.baseui.setconfig('ui', 'forcecwd', r.root, 'hgweb')
         # displaying bundling progress bar while serving feel wrong and may
         # break some wsgi implementation.
         r.ui.setconfig('progress', 'disable', 'true', 'hgweb')
         r.baseui.setconfig('progress', 'disable', 'true', 'hgweb')
         self._repos = [hg.cachedlocalrepo(self._webifyrepo(r))]
         self._lastrepo = self._repos[0]
         hook.redirect(True)
         self.reponame = name
 
     def _webifyrepo(self, repo):
         repo = getwebview(repo)
         self.websubtable = webutil.getwebsubs(repo)
         return repo
 
     @contextlib.contextmanager
     def _obtainrepo(self):
         """Obtain a repo unique to the caller.
 
         Internally we maintain a stack of cachedlocalrepo instances
         to be handed out. If one is available, we pop it and return it,
         ensuring it is up to date in the process. If one is not available,
         we clone the most recently used repo instance and return it.
 
         It is currently possible for the stack to grow without bounds
         if the server allows infinite threads. However, servers should
         have a thread limit, thus establishing our limit.
         """
         if self._repos:
             cached = self._repos.pop()
             r, created = cached.fetch()
         else:
             cached = self._lastrepo.copy()
             r, created = cached.fetch()
         if created:
             r = self._webifyrepo(r)
 
         self._lastrepo = cached
         self.mtime = cached.mtime
         try:
             yield r
         finally:
             self._repos.append(cached)
 
     def run(self):
         """Start a server from CGI environment.
 
         Modern servers should be using WSGI and should avoid this
         method, if possible.
         """
         if not os.environ.get('GATEWAY_INTERFACE', '').startswith("CGI/1."):
             raise RuntimeError("This function is only intended to be "
                                "called while running as a CGI script.")
         wsgicgi.launch(self)
 
     def __call__(self, env, respond):
         """Run the WSGI application.
 
         This may be called by multiple threads.
         """
         req = wsgirequest(env, respond)
         return self.run_wsgi(req)
 
     def run_wsgi(self, req):
         """Internal method to run the WSGI application.
 
         This is typically only called by Mercurial. External consumers
         should be using instances of this class as the WSGI application.
         """
         with self._obtainrepo() as repo:
             for r in self._runwsgi(req, repo):
                 yield r
 
     def _runwsgi(self, req, repo):
         rctx = requestcontext(self, repo)
 
         # This state is global across all threads.
         encoding.encoding = rctx.config('web', 'encoding', encoding.encoding)
         rctx.repo.ui.environ = req.env
 
         # work with CGI variables to create coherent structure
         # use SCRIPT_NAME, PATH_INFO and QUERY_STRING as well as our REPO_NAME
 
         req.url = req.env['SCRIPT_NAME']
         if not req.url.endswith('/'):
             req.url += '/'
         if 'REPO_NAME' in req.env:
             req.url += req.env['REPO_NAME'] + '/'
 
         if 'PATH_INFO' in req.env:
             parts = req.env['PATH_INFO'].strip('/').split('/')
             repo_parts = req.env.get('REPO_NAME', '').split('/')
             if parts[:len(repo_parts)] == repo_parts:
                 parts = parts[len(repo_parts):]
             query = '/'.join(parts)
         else:
             query = req.env['QUERY_STRING'].partition('&')[0]
             query = query.partition(';')[0]
 
         # process this if it's a protocol request
         # protocol bits don't need to create any URLs
         # and the clients always use the old URL structure
 
         cmd = req.form.get('cmd', [''])[0]
         if protocol.iscmd(cmd):
             try:
                 if query:
                     raise ErrorResponse(HTTP_NOT_FOUND)
                 if cmd in perms:
                     self.check_perm(rctx, req, perms[cmd])
                 return protocol.call(rctx.repo, req, cmd)
             except ErrorResponse as inst:
                 # A client that sends unbundle without 100-continue will
                 # break if we respond early.
                 if (cmd == 'unbundle' and
                     (req.env.get('HTTP_EXPECT',
                                  '').lower() != '100-continue') or
                     req.env.get('X-HgHttp2', '')):
                     req.drain()
                 else:
                     req.headers.append(('Connection', 'Close'))
                 req.respond(inst, protocol.HGTYPE,
                             body='0\n%s\n' % inst)
                 return ''
 
         # translate user-visible url structure to internal structure
 
         args = query.split('/', 2)
         if 'cmd' not in req.form and args and args[0]:
 
             cmd = args.pop(0)
             style = cmd.rfind('-')
             if style != -1:
                 req.form['style'] = [cmd[:style]]
                 cmd = cmd[style + 1:]
 
             # avoid accepting e.g. style parameter as command
             if util.safehasattr(webcommands, cmd):
                 req.form['cmd'] = [cmd]
 
             if cmd == 'static':
                 req.form['file'] = ['/'.join(args)]
             else:
                 if args and args[0]:
                     node = args.pop(0).replace('%2F', '/')
                     req.form['node'] = [node]
                 if args:
                     req.form['file'] = args
 
             ua = req.env.get('HTTP_USER_AGENT', '')
             if cmd == 'rev' and 'mercurial' in ua:
                 req.form['style'] = ['raw']
 
             if cmd == 'archive':
                 fn = req.form['node'][0]
                 for type_, spec in rctx.archivespecs.iteritems():
                     ext = spec[2]
                     if fn.endswith(ext):
                         req.form['node'] = [fn[:-len(ext)]]
                         req.form['type'] = [type_]
 
         # process the web interface request
 
         try:
             tmpl = rctx.templater(req)
             ctype = tmpl('mimetype', encoding=encoding.encoding)
             ctype = templater.stringify(ctype)
 
             # check read permissions non-static content
             if cmd != 'static':
                 self.check_perm(rctx, req, None)
 
             if cmd == '':
                 req.form['cmd'] = [tmpl.cache['default']]
                 cmd = req.form['cmd'][0]
 
             if rctx.configbool('web', 'cache', True):
                 caching(self, req) # sets ETag header or raises NOT_MODIFIED
             if cmd not in webcommands.__all__:
                 msg = 'no such method: %s' % cmd
                 raise ErrorResponse(HTTP_BAD_REQUEST, msg)
             elif cmd == 'file' and 'raw' in req.form.get('style', []):
                 rctx.ctype = ctype
                 content = webcommands.rawfile(rctx, req, tmpl)
             else:
                 content = getattr(webcommands, cmd)(rctx, req, tmpl)
                 req.respond(HTTP_OK, ctype)
 
             return content
 
         except (error.LookupError, error.RepoLookupError) as err:
             req.respond(HTTP_NOT_FOUND, ctype)
             msg = str(err)
             if (util.safehasattr(err, 'name') and
                 not isinstance(err,  error.ManifestLookupError)):
                 msg = 'revision not found: %s' % err.name
             return tmpl('error', error=msg)
         except (error.RepoError, error.RevlogError) as inst:
             req.respond(HTTP_SERVER_ERROR, ctype)
             return tmpl('error', error=str(inst))
         except ErrorResponse as inst:
             req.respond(inst, ctype)
             if inst.code == HTTP_NOT_MODIFIED:
                 # Not allowed to return a body on a 304
                 return ['']
             return tmpl('error', error=str(inst))
 
     def check_perm(self, rctx, req, op):
         for permhook in permhooks:
             permhook(rctx, req, op)
 
 def getwebview(repo):
     """The 'web.view' config controls changeset filter to hgweb. Possible
     values are ``served``, ``visible`` and ``all``. Default is ``served``.
     The ``served`` filter only shows changesets that can be pulled from the
     hgweb instance.  The``visible`` filter includes secret changesets but
     still excludes "hidden" one.
 
     See the repoview module for details.
 
     The option has been around undocumented since Mercurial 2.5, but no
     user ever asked about it. So we better keep it undocumented for now."""
     viewconfig = repo.ui.config('web', 'view', 'served',
                                 untrusted=True)
     if viewconfig == 'all':
         return repo.unfiltered()
     elif viewconfig in repoview.filtertable:
         return repo.filtered(viewconfig)
     else:
         return repo.filtered('served')
 

mercurial/hgweb/hgwebdir_mod.py

@@ -1,485 +1,511 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.
 
-import os, re, time
-from mercurial.i18n import _
-from mercurial import hg, scmutil, util, templater
-from mercurial import ui as uimod
-from mercurial import error, encoding
-from common import ErrorResponse, get_mtime, staticfile, paritygen, ismember, \
-                   get_contact, HTTP_OK, HTTP_NOT_FOUND, HTTP_SERVER_ERROR
-import hgweb_mod
-from request import wsgirequest
-import webutil, wsgicgi
+from __future__ import absolute_import
+
+import os
+import re
+import time
+
+from ..i18n import _
+
+from .common import (
+    ErrorResponse,
+    HTTP_NOT_FOUND,
+    HTTP_OK,
+    HTTP_SERVER_ERROR,
+    get_contact,
+    get_mtime,
+    ismember,
+    paritygen,
+    staticfile,
+)
+from .request import wsgirequest
+
+from .. import (
+    encoding,
+    error,
+    hg,
+    scmutil,
+    templater,
+    ui as uimod,
+    util,
+)
+
+from . import (
+    hgweb_mod,
+    webutil,
+    wsgicgi,
+)
 
 def cleannames(items):
     return [(util.pconvert(name).strip('/'), 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 = {'*': False, '**': 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('hg', '/opt', ['/opt/r', '/opt/r/r', '/opt']))
     [('hg/r', '/opt/r'), ('hg/r/r', '/opt/r/r'), ('hg', '/opt')]
     >>> conv(urlrepos('', '/opt', ['/opt/r', '/opt/r/r', '/opt']))
     [('r', '/opt/r'), ('r/r', '/opt/r/r'), ('', '/opt')]
     """
     for path in paths:
         path = os.path.normpath(path)
         yield (prefix + '/' +
                util.pconvert(path[len(roothead):]).lstrip('/')).strip('/'), path
 
 def geturlcgivars(baseurl, port):
     """
     Extract CGI variables from baseurl
 
     >>> geturlcgivars("http://host.org/base", "80")
     ('host.org', '80', '/base')
     >>> geturlcgivars("http://host.org:8000/base", "80")
     ('host.org', '8000', '/base')
     >>> geturlcgivars('/base', 8000)
     ('', '8000', '/base')
     >>> geturlcgivars("base", '8000')
     ('', '8000', '/base')
     >>> geturlcgivars("http://host", '8000')
     ('host', '8000', '/')
     >>> geturlcgivars("http://host/", '8000')
     ('host', '8000', '/')
     """
     u = util.url(baseurl)
     name = u.host or ''
     if u.port:
         port = u.port
     path = u.path or ""
     if not path.startswith('/'):
         path = '/' + path
 
     return name, str(port), path
 
 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()
 
     def refresh(self):
         refreshinterval = 20
         if self.ui:
             refreshinterval = self.ui.configint('web', 'refreshinterval',
                                                 refreshinterval)
 
         # 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()
             u.setconfig('ui', 'report_untrusted', 'off', 'hgwebdir')
             u.setconfig('ui', 'nontty', 'true', 'hgwebdir')
             # displaying bundling progress bar while serving feels wrong and may
             # break some wsgi implementations.
             u.setconfig('progress', 'disable', 'true', 'hgweb')
 
         if not isinstance(self.conf, (dict, list, tuple)):
             map = {'paths': 'hgweb-paths'}
             if not os.path.exists(self.conf):
                 raise error.Abort(_('config file %s not found!') % self.conf)
             u.readconfig(self.conf, remap=map, trust=True)
             paths = []
             for name, ignored in u.configitems('hgweb-paths'):
                 for path in u.configlist('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()
 
         repos = findrepos(paths)
         for prefix, root in u.configitems('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('/'), repo))
 
         self.repos = repos
         self.ui = u
         encoding.encoding = self.ui.config('web', 'encoding',
                                            encoding.encoding)
         self.style = self.ui.config('web', 'style', 'paper')
         self.templatepath = self.ui.config('web', 'templates', None)
         self.stripecount = self.ui.config('web', 'stripes', 1)
         if self.stripecount:
             self.stripecount = int(self.stripecount)
         self._baseurl = self.ui.config('web', 'baseurl')
         prefix = self.ui.config('web', 'prefix', '')
         if prefix.startswith('/'):
             prefix = prefix[1:]
         if prefix.endswith('/'):
             prefix = prefix[:-1]
         self.prefix = prefix
         self.lastrefresh = time.time()
 
     def run(self):
         if not os.environ.get('GATEWAY_INTERFACE', '').startswith("CGI/1."):
             raise RuntimeError("This function is only intended to be "
                                "called while running as a CGI script.")
         wsgicgi.launch(self)
 
     def __call__(self, env, respond):
         req = wsgirequest(env, respond)
         return self.run_wsgi(req)
 
     def read_allowed(self, 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.env.get('REMOTE_USER')
 
         deny_read = ui.configlist('web', 'deny_read', untrusted=True)
         if deny_read and (not user or ismember(ui, user, deny_read)):
             return False
 
         allow_read = ui.configlist('web', '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 run_wsgi(self, req):
         try:
             self.refresh()
 
             virtual = req.env.get("PATH_INFO", "").strip('/')
             tmpl = self.templater(req)
             ctype = tmpl('mimetype', encoding=encoding.encoding)
             ctype = templater.stringify(ctype)
 
             # a static file
             if virtual.startswith('static/') or 'static' in req.form:
                 if virtual.startswith('static/'):
                     fname = virtual[7:]
                 else:
                     fname = req.form['static'][0]
                 static = self.ui.config("web", "static", None,
                                         untrusted=False)
                 if not static:
                     tp = self.templatepath or templater.templatepaths()
                     if isinstance(tp, str):
                         tp = [tp]
                     static = [os.path.join(p, 'static') for p in tp]
                 staticfile(static, fname, req)
                 return []
 
             # top-level index
             elif not virtual:
                 req.respond(HTTP_OK, ctype)
                 return self.makeindex(req, tmpl)
 
             # nested indexes and hgwebs
 
             repos = dict(self.repos)
             virtualrepo = virtual
             while virtualrepo:
                 real = repos.get(virtualrepo)
                 if real:
                     req.env['REPO_NAME'] = virtualrepo
                     try:
                         # ensure caller gets private copy of ui
                         repo = hg.repository(self.ui.copy(), real)
                         return hgweb_mod.hgweb(repo).run_wsgi(req)
                     except IOError as inst:
                         msg = inst.strerror
                         raise ErrorResponse(HTTP_SERVER_ERROR, msg)
                     except error.RepoError as inst:
                         raise ErrorResponse(HTTP_SERVER_ERROR, str(inst))
 
                 up = virtualrepo.rfind('/')
                 if up < 0:
                     break
                 virtualrepo = virtualrepo[:up]
 
             # browse subdirectories
             subdir = virtual + '/'
             if [r for r in repos if r.startswith(subdir)]:
                 req.respond(HTTP_OK, ctype)
                 return self.makeindex(req, tmpl, subdir)
 
             # prefixes not found
             req.respond(HTTP_NOT_FOUND, ctype)
             return tmpl("notfound", repo=virtual)
 
         except ErrorResponse as err:
             req.respond(err, ctype)
             return tmpl('error', error=err.message or '')
         finally:
             tmpl = None
 
     def makeindex(self, req, tmpl, subdir=""):
 
         def archivelist(ui, nodeid, url):
             allowed = ui.configlist("web", "allow_archive", untrusted=True)
             archives = []
             for i in [('zip', '.zip'), ('gz', '.tar.gz'), ('bz2', '.tar.bz2')]:
                 if i[0] in allowed or ui.configbool("web", "allow" + i[0],
                                                     untrusted=True):
                     archives.append({"type" : i[0], "extension": i[1],
                                      "node": nodeid, "url": url})
             return archives
 
         def rawentries(subdir="", **map):
 
             descend = self.ui.configbool('web', 'descend', True)
             collapse = self.ui.configbool('web', 'collapse', False)
             seenrepos = set()
             seendirs = set()
             for name, path in self.repos:
 
                 if not name.startswith(subdir):
                     continue
                 name = name[len(subdir):]
                 directory = False
 
                 if '/' in name:
                     if not descend:
                         continue
 
                     nameparts = name.split('/')
                     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 = '/'.join(nameparts[1:])
 
                         # remove name parts plus accompanying slash
                         path = path[:-len(discarded) - 1]
 
                         try:
                             r = hg.repository(self.ui, path)
                             directory = False
                         except (IOError, error.RepoError):
                             pass
 
                 parts = [name]
                 if 'PATH_INFO' in req.env:
                     parts.insert(0, req.env['PATH_INFO'].rstrip('/'))
                 if req.env['SCRIPT_NAME']:
                     parts.insert(0, req.env['SCRIPT_NAME'])
                 url = re.sub(r'/+', '/', '/'.join(parts) + '/')
 
                 # show either a directory entry or a repository
                 if directory:
                     # get the directory's time information
                     try:
                         d = (get_mtime(path), util.makedate()[1])
                     except OSError:
                         continue
 
                     # add '/' to the name to make it obvious that
                     # the entry is a directory, not a regular repository
                     row = {'contact': "",
                            'contact_sort': "",
                            'name': name + '/',
                            'name_sort': name,
                            'url': url,
                            'description': "",
                            'description_sort': "",
                            'lastchange': d,
                            'lastchange_sort': d[1]-d[0],
                            'archives': [],
                            'isdirectory': True}
 
                     seendirs.add(name)
                     yield row
                     continue
 
                 u = self.ui.copy()
                 try:
                     u.readconfig(os.path.join(path, '.hg', 'hgrc'))
                 except Exception as e:
                     u.warn(_('error reading %s/.hg/hgrc: %s\n') % (path, e))
                     continue
                 def get(section, name, default=None):
                     return u.config(section, name, default, untrusted=True)
 
                 if u.configbool("web", "hidden", untrusted=True):
                     continue
 
                 if not self.read_allowed(u, req):
                     continue
 
                 # update time with local timezone
                 try:
                     r = hg.repository(self.ui, path)
                 except IOError:
                     u.warn(_('error accessing repository at %s\n') % path)
                     continue
                 except error.RepoError:
                     u.warn(_('error accessing repository at %s\n') % path)
                     continue
                 try:
                     d = (get_mtime(r.spath), util.makedate()[1])
                 except OSError:
                     continue
 
                 contact = get_contact(get)
                 description = get("web", "description", "")
                 seenrepos.add(name)
                 name = get("web", "name", name)
                 row = {'contact': contact or "unknown",
                        'contact_sort': contact.upper() or "unknown",
                        'name': name,
                        'name_sort': name,
                        'url': url,
                        'description': description or "unknown",
                        'description_sort': description.upper() or "unknown",
                        'lastchange': d,
                        'lastchange_sort': d[1]-d[0],
                        'archives': archivelist(u, "tip", url),
                        'isdirectory': None,
                        }
 
                 yield row
 
         sortdefault = None, False
         def entries(sortcolumn="", descending=False, subdir="", **map):
             rows = rawentries(subdir=subdir, **map)
 
             if sortcolumn and sortdefault != (sortcolumn, descending):
                 sortkey = '%s_sort' % sortcolumn
                 rows = sorted(rows, key=lambda x: x[sortkey],
                               reverse=descending)
             for row, parity in zip(rows, paritygen(self.stripecount)):
                 row['parity'] = parity
                 yield row
 
         self.refresh()
         sortable = ["name", "description", "contact", "lastchange"]
         sortcolumn, descending = sortdefault
         if 'sort' in req.form:
             sortcolumn = req.form['sort'][0]
             descending = sortcolumn.startswith('-')
             if descending:
                 sortcolumn = sortcolumn[1:]
             if sortcolumn not in sortable:
                 sortcolumn = ""
 
         sort = [("sort_%s" % column,
                  "%s%s" % ((not descending and column == sortcolumn)
                             and "-" or "", column))
                 for column in sortable]
 
         self.refresh()
         self.updatereqenv(req.env)
 
         return tmpl("index", entries=entries, subdir=subdir,
                     pathdef=hgweb_mod.makebreadcrumb('/' + subdir, self.prefix),
                     sortcolumn=sortcolumn, descending=descending,
                     **dict(sort))
 
     def templater(self, req):
 
         def motd(**map):
             if self.motd is not None:
                 yield self.motd
             else:
                 yield config('web', 'motd', '')
 
         def config(section, name, default=None, untrusted=True):
             return self.ui.config(section, name, default, untrusted)
 
         self.updatereqenv(req.env)
 
         url = req.env.get('SCRIPT_NAME', '')
         if not url.endswith('/'):
             url += '/'
 
         vars = {}
         styles = (
             req.form.get('style', [None])[0],
             config('web', 'style'),
             'paper'
         )
         style, mapfile = templater.stylemap(styles, self.templatepath)
         if style == styles[0]:
             vars['style'] = style
 
         start = url[-1] == '?' and '&' or '?'
         sessionvars = webutil.sessionvars(vars, start)
         logourl = config('web', 'logourl', 'https://mercurial-scm.org/')
         logoimg = config('web', 'logoimg', 'hglogo.png')
         staticurl = config('web', 'staticurl') or url + 'static/'
         if not staticurl.endswith('/'):
             staticurl += '/'
 
         tmpl = templater.templater(mapfile,
                                    defaults={"encoding": encoding.encoding,
                                              "motd": motd,
                                              "url": url,
                                              "logourl": logourl,
                                              "logoimg": logoimg,
                                              "staticurl": staticurl,
                                              "sessionvars": sessionvars,
                                              "style": style,
                                              })
         return tmpl
 
     def updatereqenv(self, env):
         if self._baseurl is not None:
             name, port, path = geturlcgivars(self._baseurl, env['SERVER_PORT'])
             env['SERVER_NAME'] = name
             env['SERVER_PORT'] = port
             env['SCRIPT_NAME'] = path

mercurial/hgweb/protocol.py

@@ -1,98 +1,110 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.
 
-import cgi, cStringIO, zlib, urllib
-from mercurial import util, wireproto
-from common import HTTP_OK
+from __future__ import absolute_import
+
+import cStringIO
+import cgi
+import urllib
+import zlib
+
+from .common import (
+    HTTP_OK,
+)
+
+from .. import (
+    util,
+    wireproto,
+)
 
 HGTYPE = 'application/mercurial-0.1'
 HGERRTYPE = 'application/hg-error'
 
 class webproto(wireproto.abstractserverproto):
     def __init__(self, req, ui):
         self.req = req
         self.response = ''
         self.ui = ui
     def getargs(self, args):
         knownargs = self._args()
         data = {}
         keys = args.split()
         for k in keys:
             if k == '*':
                 star = {}
                 for key in knownargs.keys():
                     if key != 'cmd' and key not in keys:
                         star[key] = knownargs[key][0]
                 data['*'] = star
             else:
                 data[k] = knownargs[k][0]
         return [data[k] for k in keys]
     def _args(self):
         args = self.req.form.copy()
         chunks = []
         i = 1
         while True:
             h = self.req.env.get('HTTP_X_HGARG_' + str(i))
             if h is None:
                 break
             chunks += [h]
             i += 1
         args.update(cgi.parse_qs(''.join(chunks), keep_blank_values=True))
         return args
     def getfile(self, fp):
         length = int(self.req.env['CONTENT_LENGTH'])
         for s in util.filechunkiter(self.req, limit=length):
             fp.write(s)
     def redirect(self):
         self.oldio = self.ui.fout, self.ui.ferr
         self.ui.ferr = self.ui.fout = cStringIO.StringIO()
     def restore(self):
         val = self.ui.fout.getvalue()
         self.ui.ferr, self.ui.fout = self.oldio
         return val
     def groupchunks(self, cg):
         z = zlib.compressobj()
         while True:
             chunk = cg.read(4096)
             if not chunk:
                 break
             yield z.compress(chunk)
         yield z.flush()
     def _client(self):
         return 'remote:%s:%s:%s' % (
             self.req.env.get('wsgi.url_scheme') or 'http',
             urllib.quote(self.req.env.get('REMOTE_HOST', '')),
             urllib.quote(self.req.env.get('REMOTE_USER', '')))
 
 def iscmd(cmd):
     return cmd in wireproto.commands
 
 def call(repo, req, cmd):
     p = webproto(req, repo.ui)
     rsp = wireproto.dispatch(repo, p, cmd)
     if isinstance(rsp, str):
         req.respond(HTTP_OK, HGTYPE, body=rsp)
         return []
     elif isinstance(rsp, wireproto.streamres):
         req.respond(HTTP_OK, HGTYPE)
         return rsp.gen
     elif isinstance(rsp, wireproto.pushres):
         val = p.restore()
         rsp = '%d\n%s' % (rsp.res, val)
         req.respond(HTTP_OK, HGTYPE, body=rsp)
         return []
     elif isinstance(rsp, wireproto.pusherr):
         # drain the incoming bundle
         req.drain()
         p.restore()
         rsp = '0\n%s\n' % rsp.res
         req.respond(HTTP_OK, HGTYPE, body=rsp)
         return []
     elif isinstance(rsp, wireproto.ooberror):
         rsp = rsp.message
         req.respond(HTTP_OK, HGERRTYPE, body=rsp)
         return []

mercurial/hgweb/request.py

@@ -1,140 +1,152 b''
 # hgweb/request.py - An http request from either CGI or the standalone server.
 #
 # 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.
 
-import socket, cgi, errno
-from mercurial import util
-from common import ErrorResponse, statusmessage, HTTP_NOT_MODIFIED
+from __future__ import absolute_import
+
+import cgi
+import errno
+import socket
+
+from .common import (
+    ErrorResponse,
+    HTTP_NOT_MODIFIED,
+    statusmessage,
+)
+
+from .. import (
+    util,
+)
 
 shortcuts = {
     'cl': [('cmd', ['changelog']), ('rev', None)],
     'sl': [('cmd', ['shortlog']), ('rev', None)],
     'cs': [('cmd', ['changeset']), ('node', None)],
     'f': [('cmd', ['file']), ('filenode', None)],
     'fl': [('cmd', ['filelog']), ('filenode', None)],
     'fd': [('cmd', ['filediff']), ('node', None)],
     'fa': [('cmd', ['annotate']), ('filenode', None)],
     'mf': [('cmd', ['manifest']), ('manifest', None)],
     'ca': [('cmd', ['archive']), ('node', None)],
     'tags': [('cmd', ['tags'])],
     'tip': [('cmd', ['changeset']), ('node', ['tip'])],
     'static': [('cmd', ['static']), ('file', None)]
 }
 
 def normalize(form):
     # first expand the shortcuts
     for k in shortcuts.iterkeys():
         if k in form:
             for name, value in shortcuts[k]:
                 if value is None:
                     value = form[k]
                 form[name] = value
             del form[k]
     # And strip the values
     for k, v in form.iteritems():
         form[k] = [i.strip() for i in v]
     return form
 
 class wsgirequest(object):
     """Higher-level API for a WSGI request.
 
     WSGI applications are invoked with 2 arguments. They are used to
     instantiate instances of this class, which provides higher-level APIs
     for obtaining request parameters, writing HTTP output, etc.
     """
     def __init__(self, wsgienv, start_response):
         version = wsgienv['wsgi.version']
         if (version < (1, 0)) or (version >= (2, 0)):
             raise RuntimeError("Unknown and unsupported WSGI version %d.%d"
                                % version)
         self.inp = wsgienv['wsgi.input']
         self.err = wsgienv['wsgi.errors']
         self.threaded = wsgienv['wsgi.multithread']
         self.multiprocess = wsgienv['wsgi.multiprocess']
         self.run_once = wsgienv['wsgi.run_once']
         self.env = wsgienv
         self.form = normalize(cgi.parse(self.inp,
                                         self.env,
                                         keep_blank_values=1))
         self._start_response = start_response
         self.server_write = None
         self.headers = []
 
     def __iter__(self):
         return iter([])
 
     def read(self, count=-1):
         return self.inp.read(count)
 
     def drain(self):
         '''need to read all data from request, httplib is half-duplex'''
         length = int(self.env.get('CONTENT_LENGTH') or 0)
         for s in util.filechunkiter(self.inp, limit=length):
             pass
 
     def respond(self, status, type, filename=None, body=None):
         if self._start_response is not None:
             self.headers.append(('Content-Type', type))
             if filename:
                 filename = (filename.rpartition('/')[-1]
                             .replace('\\', '\\\\').replace('"', '\\"'))
                 self.headers.append(('Content-Disposition',
                                      'inline; filename="%s"' % filename))
             if body is not None:
                 self.headers.append(('Content-Length', str(len(body))))
 
             for k, v in self.headers:
                 if not isinstance(v, str):
                     raise TypeError('header value must be string: %r' % (v,))
 
             if isinstance(status, ErrorResponse):
                 self.headers.extend(status.headers)
                 if status.code == HTTP_NOT_MODIFIED:
                     # RFC 2616 Section 10.3.5: 304 Not Modified has cases where
                     # it MUST NOT include any headers other than these and no
                     # body
                     self.headers = [(k, v) for (k, v) in self.headers if
                                     k in ('Date', 'ETag', 'Expires',
                                           'Cache-Control', 'Vary')]
                 status = statusmessage(status.code, str(status))
             elif status == 200:
                 status = '200 Script output follows'
             elif isinstance(status, int):
                 status = statusmessage(status)
 
             self.server_write = self._start_response(status, self.headers)
             self._start_response = None
             self.headers = []
         if body is not None:
             self.write(body)
             self.server_write = None
 
     def write(self, thing):
         if thing:
             try:
                 self.server_write(thing)
             except socket.error as inst:
                 if inst[0] != errno.ECONNRESET:
                     raise
 
     def writelines(self, lines):
         for line in lines:
             self.write(line)
 
     def flush(self):
         return None
 
     def close(self):
         return None
 
 def wsgiapplication(app_maker):
     '''For compatibility with old CGI scripts. A plain hgweb() or hgwebdir()
     can and should now be used as a WSGI application.'''
     application = app_maker()
     def run_wsgi(env, respond):
         return application(env, respond)
     return run_wsgi

mercurial/hgweb/server.py

@@ -1,305 +1,322 b''
 # hgweb/server.py - The standalone hg web server.
 #
 # 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.
 
-import os, sys, errno, urllib, BaseHTTPServer, socket, SocketServer, traceback
-from mercurial import util, error
-from mercurial.hgweb import common
-from mercurial.i18n import _
+from __future__ import absolute_import
+
+import BaseHTTPServer
+import SocketServer
+import errno
+import os
+import socket
+import sys
+import traceback
+import urllib
+
+from ..i18n import _
+
+from .. import (
+    error,
+    util,
+)
+
+from . import (
+    common,
+)
 
 def _splitURI(uri):
     """Return path and query that has been split from uri
 
     Just like CGI environment, the path is unquoted, the query is
     not.
     """
     if '?' in uri:
         path, query = uri.split('?', 1)
     else:
         path, query = uri, ''
     return urllib.unquote(path), query
 
 class _error_logger(object):
     def __init__(self, handler):
         self.handler = handler
     def flush(self):
         pass
     def write(self, str):
         self.writelines(str.split('\n'))
     def writelines(self, seq):
         for msg in seq:
             self.handler.log_error("HG error:  %s", msg)
 
 class _httprequesthandler(BaseHTTPServer.BaseHTTPRequestHandler):
 
     url_scheme = 'http'
 
     @staticmethod
     def preparehttpserver(httpserver, ssl_cert):
         """Prepare .socket of new HTTPServer instance"""
         pass
 
     def __init__(self, *args, **kargs):
         self.protocol_version = 'HTTP/1.1'
         BaseHTTPServer.BaseHTTPRequestHandler.__init__(self, *args, **kargs)
 
     def _log_any(self, fp, format, *args):
         fp.write("%s - - [%s] %s\n" % (self.client_address[0],
                                        self.log_date_time_string(),
                                        format % args))
         fp.flush()
 
     def log_error(self, format, *args):
         self._log_any(self.server.errorlog, format, *args)
 
     def log_message(self, format, *args):
         self._log_any(self.server.accesslog, format, *args)
 
     def log_request(self, code='-', size='-'):
         xheaders = []
         if util.safehasattr(self, 'headers'):
             xheaders = [h for h in self.headers.items()
                         if h[0].startswith('x-')]
         self.log_message('"%s" %s %s%s',
                          self.requestline, str(code), str(size),
                          ''.join([' %s:%s' % h for h in sorted(xheaders)]))
 
     def do_write(self):
         try:
             self.do_hgweb()
         except socket.error as inst:
             if inst[0] != errno.EPIPE:
                 raise
 
     def do_POST(self):
         try:
             self.do_write()
         except Exception:
             self._start_response("500 Internal Server Error", [])
             self._write("Internal Server Error")
             self._done()
             tb = "".join(traceback.format_exception(*sys.exc_info()))
             self.log_error("Exception happened during processing "
                            "request '%s':\n%s", self.path, tb)
 
     def do_GET(self):
         self.do_POST()
 
     def do_hgweb(self):
         path, query = _splitURI(self.path)
 
         env = {}
         env['GATEWAY_INTERFACE'] = 'CGI/1.1'
         env['REQUEST_METHOD'] = self.command
         env['SERVER_NAME'] = self.server.server_name
         env['SERVER_PORT'] = str(self.server.server_port)
         env['REQUEST_URI'] = self.path
         env['SCRIPT_NAME'] = self.server.prefix
         env['PATH_INFO'] = path[len(self.server.prefix):]
         env['REMOTE_HOST'] = self.client_address[0]
         env['REMOTE_ADDR'] = self.client_address[0]
         if query:
             env['QUERY_STRING'] = query
 
         if self.headers.typeheader is None:
             env['CONTENT_TYPE'] = self.headers.type
         else:
             env['CONTENT_TYPE'] = self.headers.typeheader
         length = self.headers.getheader('content-length')
         if length:
             env['CONTENT_LENGTH'] = length
         for header in [h for h in self.headers.keys()
                        if h not in ('content-type', 'content-length')]:
             hkey = 'HTTP_' + header.replace('-', '_').upper()
             hval = self.headers.getheader(header)
             hval = hval.replace('\n', '').strip()
             if hval:
                 env[hkey] = hval
         env['SERVER_PROTOCOL'] = self.request_version
         env['wsgi.version'] = (1, 0)
         env['wsgi.url_scheme'] = self.url_scheme
         if env.get('HTTP_EXPECT', '').lower() == '100-continue':
             self.rfile = common.continuereader(self.rfile, self.wfile.write)
 
         env['wsgi.input'] = self.rfile
         env['wsgi.errors'] = _error_logger(self)
         env['wsgi.multithread'] = isinstance(self.server,
                                              SocketServer.ThreadingMixIn)
         env['wsgi.multiprocess'] = isinstance(self.server,
                                               SocketServer.ForkingMixIn)
         env['wsgi.run_once'] = 0
 
         self.saved_status = None
         self.saved_headers = []
         self.sent_headers = False
         self.length = None
         self._chunked = None
         for chunk in self.server.application(env, self._start_response):
             self._write(chunk)
         if not self.sent_headers:
             self.send_headers()
         self._done()
 
     def send_headers(self):
         if not self.saved_status:
             raise AssertionError("Sending headers before "
                                  "start_response() called")
         saved_status = self.saved_status.split(None, 1)
         saved_status[0] = int(saved_status[0])
         self.send_response(*saved_status)
         self.length = None
         self._chunked = False
         for h in self.saved_headers:
             self.send_header(*h)
             if h[0].lower() == 'content-length':
                 self.length = int(h[1])
         if (self.length is None and
             saved_status[0] != common.HTTP_NOT_MODIFIED):
             self._chunked = (not self.close_connection and
                              self.request_version == "HTTP/1.1")
             if self._chunked:
                 self.send_header('Transfer-Encoding', 'chunked')
             else:
                 self.send_header('Connection', 'close')
         self.end_headers()
         self.sent_headers = True
 
     def _start_response(self, http_status, headers, exc_info=None):
         code, msg = http_status.split(None, 1)
         code = int(code)
         self.saved_status = http_status
         bad_headers = ('connection', 'transfer-encoding')
         self.saved_headers = [h for h in headers
                               if h[0].lower() not in bad_headers]
         return self._write
 
     def _write(self, data):
         if not self.saved_status:
             raise AssertionError("data written before start_response() called")
         elif not self.sent_headers:
             self.send_headers()
         if self.length is not None:
             if len(data) > self.length:
                 raise AssertionError("Content-length header sent, but more "
                                      "bytes than specified are being written.")
             self.length = self.length - len(data)
         elif self._chunked and data:
             data = '%x\r\n%s\r\n' % (len(data), data)
         self.wfile.write(data)
         self.wfile.flush()
 
     def _done(self):
         if self._chunked:
             self.wfile.write('0\r\n\r\n')
             self.wfile.flush()
 
 class _httprequesthandlerssl(_httprequesthandler):
     """HTTPS handler based on Python's ssl module"""
 
     url_scheme = 'https'
 
     @staticmethod
     def preparehttpserver(httpserver, ssl_cert):
         try:
             import ssl
             ssl.wrap_socket
         except ImportError:
             raise error.Abort(_("SSL support is unavailable"))
         httpserver.socket = ssl.wrap_socket(
             httpserver.socket, server_side=True,
             certfile=ssl_cert, ssl_version=ssl.PROTOCOL_TLSv1)
 
     def setup(self):
         self.connection = self.request
         self.rfile = socket._fileobject(self.request, "rb", self.rbufsize)
         self.wfile = socket._fileobject(self.request, "wb", self.wbufsize)
 
 try:
-    from threading import activeCount
-    activeCount() # silence pyflakes
+    import threading
+    threading.activeCount() # silence pyflakes and bypass demandimport
     _mixin = SocketServer.ThreadingMixIn
 except ImportError:
     if util.safehasattr(os, "fork"):
         _mixin = SocketServer.ForkingMixIn
     else:
         class _mixin(object):
             pass
 
 def openlog(opt, default):
     if opt and opt != '-':
         return open(opt, 'a')
     return default
 
 class MercurialHTTPServer(object, _mixin, BaseHTTPServer.HTTPServer):
 
     # SO_REUSEADDR has broken semantics on windows
     if os.name == 'nt':
         allow_reuse_address = 0
 
     def __init__(self, ui, app, addr, handler, **kwargs):
         BaseHTTPServer.HTTPServer.__init__(self, addr, handler, **kwargs)
         self.daemon_threads = True
         self.application = app
 
         handler.preparehttpserver(self, ui.config('web', 'certificate'))
 
         prefix = ui.config('web', 'prefix', '')
         if prefix:
             prefix = '/' + prefix.strip('/')
         self.prefix = prefix
 
         alog = openlog(ui.config('web', 'accesslog', '-'), sys.stdout)
         elog = openlog(ui.config('web', 'errorlog', '-'), sys.stderr)
         self.accesslog = alog
         self.errorlog = elog
 
         self.addr, self.port = self.socket.getsockname()[0:2]
         self.fqaddr = socket.getfqdn(addr[0])
 
 class IPv6HTTPServer(MercurialHTTPServer):
     address_family = getattr(socket, 'AF_INET6', None)
     def __init__(self, *args, **kwargs):
         if self.address_family is None:
             raise error.RepoError(_('IPv6 is not available on this system'))
         super(IPv6HTTPServer, self).__init__(*args, **kwargs)
 
 def create_server(ui, app):
 
     if ui.config('web', 'certificate'):
         handler = _httprequesthandlerssl
     else:
         handler = _httprequesthandler
 
     if ui.configbool('web', 'ipv6'):
         cls = IPv6HTTPServer
     else:
         cls = MercurialHTTPServer
 
     # ugly hack due to python issue5853 (for threaded use)
     try:
         import mimetypes
         mimetypes.init()
     except UnicodeDecodeError:
         # Python 2.x's mimetypes module attempts to decode strings
         # from Windows' ANSI APIs as ascii (fail), then re-encode them
         # as ascii (clown fail), because the default Python Unicode
         # codec is hardcoded as ascii.
 
         sys.argv # unwrap demand-loader so that reload() works
         reload(sys) # resurrect sys.setdefaultencoding()
         oldenc = sys.getdefaultencoding()
         sys.setdefaultencoding("latin1") # or any full 8-bit encoding
         mimetypes.init()
         sys.setdefaultencoding(oldenc)
 
     address = ui.config('web', 'address', '')
     port = util.getport(ui.config('web', 'port', 8000))
     try:
         return cls(ui, app, (address, port), handler)
     except socket.error as inst:
         raise error.Abort(_("cannot start server at '%s:%d': %s")
                          % (address, port, inst.args[1]))

mercurial/hgweb/webcommands.py

@@ -1,1315 +1,1340 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.
 
-import os, mimetypes, re, cgi, copy
-import webutil
-from mercurial import error, encoding, archival, templater, templatefilters
-from mercurial.node import short, hex
-from mercurial import util
-from common import paritygen, staticfile, get_contact, ErrorResponse
-from common import HTTP_OK, HTTP_FORBIDDEN, HTTP_NOT_FOUND
-from mercurial import graphmod, patch
-from mercurial import scmutil
-from mercurial.i18n import _
-from mercurial import revset
+from __future__ import absolute_import
+
+import cgi
+import copy
+import mimetypes
+import os
+import re
+
+from ..i18n import _
+from ..node import hex, short
+
+from .common import (
+    ErrorResponse,
+    HTTP_FORBIDDEN,
+    HTTP_NOT_FOUND,
+    HTTP_OK,
+    get_contact,
+    paritygen,
+    staticfile,
+)
+
+from .. import (
+    archival,
+    encoding,
+    error,
+    graphmod,
+    patch,
+    revset,
+    scmutil,
+    templatefilters,
+    templater,
+    util,
+)
+
+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.
 
     Usage:
 
     @webcommand('mycommand')
     def mycommand(web, req, tmpl):
         pass
     """
 
     def __init__(self, name):
         self.name = name
 
     def __call__(self, func):
         __all__.append(self.name)
         commands[self.name] = func
         return func
 
 @webcommand('log')
 def log(web, req, tmpl):
     """
     /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 'file' in req.form and req.form['file'][0]:
         return filelog(web, req, tmpl)
     else:
         return changelog(web, req, tmpl)
 
 @webcommand('rawfile')
 def rawfile(web, req, tmpl):
     guessmime = web.configbool('web', 'guessmime', False)
 
     path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0])
     if not path:
         content = manifest(web, req, tmpl)
         req.respond(HTTP_OK, web.ctype)
         return content
 
     try:
         fctx = webutil.filectx(web.repo, req)
     except error.LookupError as inst:
         try:
             content = manifest(web, req, tmpl)
             req.respond(HTTP_OK, web.ctype)
             return content
         except ErrorResponse:
             raise inst
 
     path = fctx.path()
     text = fctx.data()
     mt = 'application/binary'
     if guessmime:
         mt = mimetypes.guess_type(path)[0]
         if mt is None:
             if util.binary(text):
                 mt = 'application/binary'
             else:
                 mt = 'text/plain'
     if mt.startswith('text/'):
         mt += '; charset="%s"' % encoding.encoding
 
     req.respond(HTTP_OK, mt, path, body=text)
     return []
 
 def _filerevision(web, req, tmpl, fctx):
     f = fctx.path()
     text = fctx.data()
     parity = paritygen(web.stripecount)
 
     if util.binary(text):
         mt = mimetypes.guess_type(f)[0] or 'application/octet-stream'
         text = '(binary:%s)' % mt
 
     def lines():
         for lineno, t in enumerate(text.splitlines(True)):
             yield {"line": t,
                    "lineid": "l%d" % (lineno + 1),
                    "linenumber": "% 6d" % (lineno + 1),
                    "parity": parity.next()}
 
     return tmpl("filerevision",
                 file=f,
                 path=webutil.up(f),
                 text=lines(),
                 rev=fctx.rev(),
                 symrev=webutil.symrevorshortnode(req, fctx),
                 node=fctx.hex(),
                 author=fctx.user(),
                 date=fctx.date(),
                 desc=fctx.description(),
                 extra=fctx.extra(),
                 branch=webutil.nodebranchnodefault(fctx),
                 parent=webutil.parents(fctx),
                 child=webutil.children(fctx),
                 rename=webutil.renamelink(fctx),
                 tags=webutil.nodetagsdict(web.repo, fctx.node()),
                 bookmarks=webutil.nodebookmarksdict(web.repo, fctx.node()),
                 permissions=fctx.manifest().flags(f))
 
 @webcommand('file')
 def file(web, req, tmpl):
     """
     /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.
     """
     path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0])
     if not path:
         return manifest(web, req, tmpl)
     try:
         return _filerevision(web, req, tmpl, webutil.filectx(web.repo, req))
     except error.LookupError as inst:
         try:
             return manifest(web, req, tmpl)
         except ErrorResponse:
             raise inst
 
 def _search(web, req, tmpl):
     MODE_REVISION = 'rev'
     MODE_KEYWORD = 'keyword'
     MODE_REVSET = '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 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(" ".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, 'exact revision search'),
         MODE_KEYWORD: (keywordsearch, 'literal keyword search'),
         MODE_REVSET: (revsetsearch, 'revset expression search'),
     }
 
     def getsearchmode(query):
         try:
             ctx = 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 = 'reverse(%s)' % query
         try:
             tree = revset.parse(revdef)
         except error.ParseError:
             # can't parse to a revset tree
             return MODE_KEYWORD, query
 
         if revset.depth(tree) <= 2:
             # no revset syntax used
             return MODE_KEYWORD, query
 
         if any((token, (value or '')[:3]) == ('string', 're:')
                     for token, value, pos in revset.tokenize(revdef)):
             return MODE_KEYWORD, query
 
         funcsused = revset.funcsused(tree)
         if not funcsused.issubset(revset.safesymbols):
             return MODE_KEYWORD, query
 
         mfunc = revset.match(web.repo.ui, revdef)
         try:
             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(**map):
         count = 0
 
         for ctx in searchfunc[0](funcarg):
             count += 1
             n = ctx.node()
             showtags = webutil.showtag(web.repo, tmpl, 'changelogtag', n)
             files = webutil.listfilediffs(tmpl, ctx.files(), n, web.maxfiles)
 
             yield tmpl('searchentry',
                        parity=parity.next(),
                        author=ctx.user(),
                        parent=lambda **x: webutil.parents(ctx),
                        child=lambda **x: webutil.children(ctx),
                        changelogtag=showtags,
                        desc=ctx.description(),
                        extra=ctx.extra(),
                        date=ctx.date(),
                        files=files,
                        rev=ctx.rev(),
                        node=hex(n),
                        tags=webutil.nodetagsdict(web.repo, n),
                        bookmarks=webutil.nodebookmarksdict(web.repo, n),
                        inbranch=webutil.nodeinbranch(web.repo, ctx),
                        branches=webutil.nodebranchdict(web.repo, ctx))
 
             if count >= revcount:
                 break
 
     query = req.form['rev'][0]
     revcount = web.maxchanges
     if 'revcount' in req.form:
         try:
             revcount = int(req.form.get('revcount', [revcount])[0])
             revcount = max(revcount, 1)
             tmpl.defaults['sessionvars']['revcount'] = revcount
         except ValueError:
             pass
 
     lessvars = copy.copy(tmpl.defaults['sessionvars'])
     lessvars['revcount'] = max(revcount / 2, 1)
     lessvars['rev'] = query
     morevars = copy.copy(tmpl.defaults['sessionvars'])
     morevars['revcount'] = revcount * 2
     morevars['rev'] = query
 
     mode, funcarg = getsearchmode(query)
 
     if 'forcekw' in req.form:
         showforcekw = ''
         showunforcekw = searchfuncs[mode][1]
         mode = MODE_KEYWORD
         funcarg = query
     else:
         if mode != MODE_KEYWORD:
             showforcekw = searchfuncs[MODE_KEYWORD][1]
         else:
             showforcekw = ''
         showunforcekw = ''
 
     searchfunc = searchfuncs[mode]
 
     tip = web.repo['tip']
     parity = paritygen(web.stripecount)
 
     return tmpl('search', query=query, node=tip.hex(), symrev='tip',
                 entries=changelist, archives=web.archivelist("tip"),
                 morevars=morevars, lessvars=lessvars,
                 modedesc=searchfunc[1],
                 showforcekw=showforcekw, showunforcekw=showunforcekw)
 
 @webcommand('changelog')
 def changelog(web, req, tmpl, 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 = ''
     if 'node' in req.form:
         ctx = webutil.changectx(web.repo, req)
         symrev = webutil.symrevorshortnode(req, ctx)
     elif 'rev' in req.form:
         return _search(web, req, tmpl)
     else:
         ctx = web.repo['tip']
         symrev = 'tip'
 
     def changelist():
         revs = []
         if pos != -1:
             revs = web.repo.changelog.revs(pos, 0)
         curcount = 0
         for rev in revs:
             curcount += 1
             if curcount > revcount + 1:
                 break
 
             entry = webutil.changelistentry(web, web.repo[rev], tmpl)
             entry['parity'] = parity.next()
             yield entry
 
     if shortlog:
         revcount = web.maxshortchanges
     else:
         revcount = web.maxchanges
 
     if 'revcount' in req.form:
         try:
             revcount = int(req.form.get('revcount', [revcount])[0])
             revcount = max(revcount, 1)
             tmpl.defaults['sessionvars']['revcount'] = revcount
         except ValueError:
             pass
 
     lessvars = copy.copy(tmpl.defaults['sessionvars'])
     lessvars['revcount'] = max(revcount / 2, 1)
     morevars = copy.copy(tmpl.defaults['sessionvars'])
     morevars['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())
     latestentry = entries[:1]
     if len(entries) > revcount:
         nextentry = entries[-1:]
         entries = entries[:-1]
     else:
         nextentry = []
 
     return tmpl(shortlog and 'shortlog' or 'changelog', changenav=changenav,
                 node=ctx.hex(), rev=pos, symrev=symrev, changesets=count,
                 entries=entries,
                 latestentry=latestentry, nextentry=nextentry,
                 archives=web.archivelist("tip"), revcount=revcount,
                 morevars=morevars, lessvars=lessvars, query=query)
 
 @webcommand('shortlog')
 def shortlog(web, req, tmpl):
     """
     /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, req, tmpl, shortlog=True)
 
 @webcommand('changeset')
 def changeset(web, req, tmpl):
     """
     /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, req)
 
     return tmpl('changeset', **webutil.changesetentry(web, req, tmpl, ctx))
 
 rev = webcommand('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('manifest')
 def manifest(web, req, tmpl):
     """
     /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 'node' in req.form:
         ctx = webutil.changectx(web.repo, req)
         symrev = webutil.symrevorshortnode(req, ctx)
     else:
         ctx = web.repo['tip']
         symrev = 'tip'
     path = webutil.cleanpath(web.repo, req.form.get('file', [''])[0])
     mf = ctx.manifest()
     node = ctx.node()
 
     files = {}
     dirs = {}
     parity = paritygen(web.stripecount)
 
     if path and path[-1] != "/":
         path += "/"
     l = len(path)
     abspath = "/" + path
 
     for full, n in mf.iteritems():
         # 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('/')
         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, 'path not found: ' + path)
 
     def filelist(**map):
         for f in sorted(files):
             full = files[f]
 
             fctx = ctx.filectx(full)
             yield {"file": full,
                    "parity": parity.next(),
                    "basename": f,
                    "date": fctx.date(),
                    "size": fctx.size(),
                    "permissions": mf.flags(full)}
 
     def dirlist(**map):
         for d in sorted(dirs):
 
             emptydirs = []
             h = dirs[d]
             while isinstance(h, dict) and len(h) == 1:
                 k, v = h.items()[0]
                 if v:
                     emptydirs.append(k)
                 h = v
 
             path = "%s%s" % (abspath, d)
             yield {"parity": parity.next(),
                    "path": path,
                    "emptydirs": "/".join(emptydirs),
                    "basename": d}
 
     return tmpl("manifest",
                 rev=ctx.rev(),
                 symrev=symrev,
                 node=hex(node),
                 path=abspath,
                 up=webutil.up(abspath),
                 upparity=parity.next(),
                 fentries=filelist,
                 dentries=dirlist,
                 archives=web.archivelist(hex(node)),
                 tags=webutil.nodetagsdict(web.repo, node),
                 bookmarks=webutil.nodebookmarksdict(web.repo, node),
                 branch=webutil.nodebranchnodefault(ctx),
                 inbranch=webutil.nodeinbranch(web.repo, ctx),
                 branches=webutil.nodebranchdict(web.repo, ctx))
 
 @webcommand('tags')
 def tags(web, req, tmpl):
     """
     /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(notip, latestonly, **map):
         t = i
         if notip:
             t = [(k, n) for k, n in i if k != "tip"]
         if latestonly:
             t = t[:1]
         for k, n in t:
             yield {"parity": parity.next(),
                    "tag": k,
                    "date": web.repo[n].date(),
                    "node": hex(n)}
 
     return tmpl("tags",
                 node=hex(web.repo.changelog.tip()),
                 entries=lambda **x: entries(False, False, **x),
                 entriesnotip=lambda **x: entries(True, False, **x),
                 latestentry=lambda **x: entries(True, True, **x))
 
 @webcommand('bookmarks')
 def bookmarks(web, req, tmpl):
     """
     /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]
     parity = paritygen(web.stripecount)
 
     def entries(latestonly, **map):
         if latestonly:
             t = [min(i)]
         else:
             t = sorted(i)
         for k, n in t:
             yield {"parity": parity.next(),
                    "bookmark": k,
                    "date": web.repo[n].date(),
                    "node": hex(n)}
 
     return tmpl("bookmarks",
                 node=hex(web.repo.changelog.tip()),
                 entries=lambda **x: entries(latestonly=False, **x),
                 latestentry=lambda **x: entries(latestonly=True, **x))
 
 @webcommand('branches')
 def branches(web, req, tmpl):
     """
     /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 tmpl('branches', node=hex(web.repo.changelog.tip()),
                 entries=entries, latestentry=latestentry)
 
 @webcommand('summary')
 def summary(web, req, tmpl):
     """
     /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(**map):
         parity = paritygen(web.stripecount)
         count = 0
         for k, n in i:
             if k == "tip": # skip tip
                 continue
 
             count += 1
             if count > 10: # limit to 10 tags
                 break
 
             yield tmpl("tagentry",
                        parity=parity.next(),
                        tag=k,
                        node=hex(n),
                        date=web.repo[n].date())
 
     def bookmarks(**map):
         parity = paritygen(web.stripecount)
         marks = [b for b in web.repo._bookmarks.items() if b[1] in web.repo]
         for k, n in sorted(marks)[:10]:  # limit to 10 bookmarks
             yield {'parity': parity.next(),
                    'bookmark': k,
                    'date': web.repo[n].date(),
                    'node': hex(n)}
 
     def changelist(**map):
         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]
             n = ctx.node()
             hn = hex(n)
 
             l.append(tmpl(
                'shortlogentry',
                 parity=parity.next(),
                 author=ctx.user(),
                 desc=ctx.description(),
                 extra=ctx.extra(),
                 date=ctx.date(),
                 rev=i,
                 node=hn,
                 tags=webutil.nodetagsdict(web.repo, n),
                 bookmarks=webutil.nodebookmarksdict(web.repo, n),
                 inbranch=webutil.nodeinbranch(web.repo, ctx),
                 branches=webutil.nodebranchdict(web.repo, ctx)))
 
         l.reverse()
         yield l
 
     tip = web.repo['tip']
     count = len(web.repo)
     start = max(0, count - web.maxchanges)
     end = min(count, start + web.maxchanges)
 
     return tmpl("summary",
                 desc=web.config("web", "description", "unknown"),
                 owner=get_contact(web.config) or "unknown",
                 lastchange=tip.date(),
                 tags=tagentries,
                 bookmarks=bookmarks,
                 branches=webutil.branchentries(web.repo, web.stripecount, 10),
                 shortlog=changelist,
                 node=tip.hex(),
                 symrev='tip',
                 archives=web.archivelist("tip"))
 
 @webcommand('filediff')
 def filediff(web, req, tmpl):
     """
     /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, req)
     except LookupError:
         ctx = webutil.changectx(web.repo, req)
         path = webutil.cleanpath(web.repo, req.form['file'][0])
         if path not in ctx.files():
             raise
 
     if fctx is not None:
         n = fctx.node()
         path = fctx.path()
         ctx = fctx.changectx()
     else:
         n = ctx.node()
         # path already defined in except clause
 
     parity = paritygen(web.stripecount)
     style = web.config('web', 'style', 'paper')
     if 'style' in req.form:
         style = req.form['style'][0]
 
     diffs = webutil.diffs(web.repo, tmpl, ctx, None, [path], parity, style)
     if fctx:
         rename = webutil.renamelink(fctx)
         ctx = fctx
     else:
         rename = []
         ctx = ctx
     return tmpl("filediff",
                 file=path,
                 node=hex(n),
                 rev=ctx.rev(),
                 symrev=webutil.symrevorshortnode(req, ctx),
                 date=ctx.date(),
                 desc=ctx.description(),
                 extra=ctx.extra(),
                 author=ctx.user(),
                 rename=rename,
                 branch=webutil.nodebranchnodefault(ctx),
                 parent=webutil.parents(ctx),
                 child=webutil.children(ctx),
                 tags=webutil.nodetagsdict(web.repo, n),
                 bookmarks=webutil.nodebookmarksdict(web.repo, n),
                 diff=diffs)
 
 diff = webcommand('diff')(filediff)
 
 @webcommand('comparison')
 def comparison(web, req, tmpl):
     """
     /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, req)
     if 'file' not in req.form:
         raise ErrorResponse(HTTP_NOT_FOUND, 'file not given')
     path = webutil.cleanpath(web.repo, req.form['file'][0])
     rename = path in ctx and webutil.renamelink(ctx[path]) or []
 
     parsecontext = lambda v: v == 'full' and -1 or int(v)
     if 'context' in req.form:
         context = parsecontext(req.form['context'][0])
     else:
         context = parsecontext(web.config('web', 'comparisoncontext', '5'))
 
     def filelines(f):
         if util.binary(f.data()):
             mt = mimetypes.guess_type(f.path())[0]
             if not mt:
                 mt = 'application/octet-stream'
             return [_('(binary file %s, hash: %s)') % (mt, hex(f.filenode()))]
         return f.data().splitlines()
 
     parent = ctx.p1()
     leftrev = parent.rev()
     leftnode = parent.node()
     rightrev = ctx.rev()
     rightnode = ctx.node()
     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 = ()
         fctx = ctx.parents()[0][path]
         leftlines = filelines(fctx)
 
     comparison = webutil.compare(tmpl, context, leftlines, rightlines)
     return tmpl('filecomparison',
                 file=path,
                 node=hex(ctx.node()),
                 rev=ctx.rev(),
                 symrev=webutil.symrevorshortnode(req, ctx),
                 date=ctx.date(),
                 desc=ctx.description(),
                 extra=ctx.extra(),
                 author=ctx.user(),
                 rename=rename,
                 branch=webutil.nodebranchnodefault(ctx),
                 parent=webutil.parents(fctx),
                 child=webutil.children(fctx),
                 tags=webutil.nodetagsdict(web.repo, ctx.node()),
                 bookmarks=webutil.nodebookmarksdict(web.repo, ctx.node()),
                 leftrev=leftrev,
                 leftnode=hex(leftnode),
                 rightrev=rightrev,
                 rightnode=hex(rightnode),
                 comparison=comparison)
 
 @webcommand('annotate')
 def annotate(web, req, tmpl):
     """
     /annotate/{revision}/{path}
     ---------------------------
 
     Show changeset information for each line in a file.
 
     The ``fileannotate`` template is rendered.
     """
     fctx = webutil.filectx(web.repo, req)
     f = fctx.path()
     parity = paritygen(web.stripecount)
     diffopts = patch.difffeatureopts(web.repo.ui, untrusted=True,
                                      section='annotate', whitespace=True)
 
     def annotate(**map):
         last = None
         if util.binary(fctx.data()):
             mt = (mimetypes.guess_type(fctx.path())[0]
                   or 'application/octet-stream')
             lines = enumerate([((fctx.filectx(fctx.filerev()), 1),
                                 '(binary:%s)' % mt)])
         else:
             lines = enumerate(fctx.annotate(follow=True, linenumber=True,
                                             diffopts=diffopts))
         for lineno, ((f, targetline), l) in lines:
             fnode = f.filenode()
 
             if last != fnode:
                 last = fnode
 
             yield {"parity": parity.next(),
                    "node": f.hex(),
                    "rev": f.rev(),
                    "author": f.user(),
                    "desc": f.description(),
                    "extra": f.extra(),
                    "file": f.path(),
                    "targetline": targetline,
                    "line": l,
                    "lineno": lineno + 1,
                    "lineid": "l%d" % (lineno + 1),
                    "linenumber": "% 6d" % (lineno + 1),
                    "revdate": f.date()}
 
     return tmpl("fileannotate",
                 file=f,
                 annotate=annotate,
                 path=webutil.up(f),
                 rev=fctx.rev(),
                 symrev=webutil.symrevorshortnode(req, fctx),
                 node=fctx.hex(),
                 author=fctx.user(),
                 date=fctx.date(),
                 desc=fctx.description(),
                 extra=fctx.extra(),
                 rename=webutil.renamelink(fctx),
                 branch=webutil.nodebranchnodefault(fctx),
                 parent=webutil.parents(fctx),
                 child=webutil.children(fctx),
                 tags=webutil.nodetagsdict(web.repo, fctx.node()),
                 bookmarks=webutil.nodebookmarksdict(web.repo, fctx.node()),
                 permissions=fctx.manifest().flags(f))
 
 @webcommand('filelog')
 def filelog(web, req, tmpl):
     """
     /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, req)
         f = fctx.path()
         fl = fctx.filelog()
     except error.LookupError:
         f = webutil.cleanpath(web.repo, req.form['file'][0])
         fl = web.repo.file(f)
         numrevs = len(fl)
         if not numrevs: # file doesn't exist at all
             raise
         rev = webutil.changectx(web.repo, 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 'revcount' in req.form:
         try:
             revcount = int(req.form.get('revcount', [revcount])[0])
             revcount = max(revcount, 1)
             tmpl.defaults['sessionvars']['revcount'] = revcount
         except ValueError:
             pass
 
     lessvars = copy.copy(tmpl.defaults['sessionvars'])
     lessvars['revcount'] = max(revcount / 2, 1)
     morevars = copy.copy(tmpl.defaults['sessionvars'])
     morevars['revcount'] = revcount * 2
 
     count = fctx.filerev() + 1
     start = max(0, fctx.filerev() - revcount + 1) # first rev on this page
     end = min(count, start + revcount) # last rev on this page
     parity = paritygen(web.stripecount, offset=start - end)
 
     def entries():
         l = []
 
         repo = web.repo
         revs = fctx.filelog().revs(start, end - 1)
         for i in revs:
             iterfctx = fctx.filectx(i)
 
             l.append({"parity": parity.next(),
                       "filerev": i,
                       "file": f,
                       "node": iterfctx.hex(),
                       "author": iterfctx.user(),
                       "date": iterfctx.date(),
                       "rename": webutil.renamelink(iterfctx),
                       "parent": lambda **x: webutil.parents(iterfctx),
                       "child": lambda **x: webutil.children(iterfctx),
                       "desc": iterfctx.description(),
                       "extra": iterfctx.extra(),
                       "tags": webutil.nodetagsdict(repo, iterfctx.node()),
                       "bookmarks": webutil.nodebookmarksdict(
                           repo, iterfctx.node()),
                       "branch": webutil.nodebranchnodefault(iterfctx),
                       "inbranch": webutil.nodeinbranch(repo, iterfctx),
                       "branches": webutil.nodebranchdict(repo, iterfctx)})
         for e in reversed(l):
             yield e
 
     entries = list(entries())
     latestentry = entries[:1]
 
     revnav = webutil.filerevnav(web.repo, fctx.path())
     nav = revnav.gen(end - 1, revcount, count)
     return tmpl("filelog", file=f, node=fctx.hex(), nav=nav,
                 symrev=webutil.symrevorshortnode(req, fctx),
                 entries=entries,
                 latestentry=latestentry,
                 revcount=revcount, morevars=morevars, lessvars=lessvars)
 
 @webcommand('archive')
 def archive(web, req, tmpl):
     """
     /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_ = req.form.get('type', [None])[0]
     allowed = web.configlist("web", "allow_archive")
     key = req.form['node'][0]
 
     if type_ not in web.archives:
         msg = 'Unsupported archive type: %s' % type_
         raise ErrorResponse(HTTP_NOT_FOUND, msg)
 
     if not ((type_ in allowed or
         web.configbool("web", "allow" + type_, False))):
         msg = 'Archive type not allowed: %s' % type_
         raise ErrorResponse(HTTP_FORBIDDEN, msg)
 
     reponame = re.sub(r"\W+", "-", os.path.basename(web.reponame))
     cnode = web.repo.lookup(key)
     arch_version = key
     if cnode == key or key == 'tip':
         arch_version = short(cnode)
     name = "%s-%s" % (reponame, arch_version)
 
     ctx = webutil.changectx(web.repo, req)
     pats = []
     matchfn = scmutil.match(ctx, [])
     file = req.form.get('file', None)
     if file:
         pats = ['path:' + file[0]]
         matchfn = scmutil.match(ctx, pats, default='path')
         if pats:
             files = [f for f in ctx.manifest().keys() if matchfn(f)]
             if not files:
                 raise ErrorResponse(HTTP_NOT_FOUND,
                     'file(s) not found: %s' % file[0])
 
     mimetype, artype, extension, encoding = web.archivespecs[type_]
     headers = [
         ('Content-Disposition', 'attachment; filename=%s%s' % (name, extension))
         ]
     if encoding:
         headers.append(('Content-Encoding', encoding))
     req.headers.extend(headers)
     req.respond(HTTP_OK, mimetype)
 
     archival.archive(web.repo, req, cnode, artype, prefix=name,
                      matchfn=matchfn,
                      subrepos=web.configbool("web", "archivesubrepos"))
     return []
 
 
 @webcommand('static')
 def static(web, req, tmpl):
     fname = req.form['file'][0]
     # 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("web", "static", None, untrusted=False)
     if not static:
         tp = web.templatepath or templater.templatepaths()
         if isinstance(tp, str):
             tp = [tp]
         static = [os.path.join(p, 'static') for p in tp]
     staticfile(static, fname, req)
     return []
 
 @webcommand('graph')
 def graph(web, req, tmpl):
     """
     /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.
 
     The ``revcount`` query string argument can define the number of changesets
     to show information for.
 
     This handler will render the ``graph`` template.
     """
 
     if 'node' in req.form:
         ctx = webutil.changectx(web.repo, req)
         symrev = webutil.symrevorshortnode(req, ctx)
     else:
         ctx = web.repo['tip']
         symrev = 'tip'
     rev = ctx.rev()
 
     bg_height = 39
     revcount = web.maxshortchanges
     if 'revcount' in req.form:
         try:
             revcount = int(req.form.get('revcount', [revcount])[0])
             revcount = max(revcount, 1)
             tmpl.defaults['sessionvars']['revcount'] = revcount
         except ValueError:
             pass
 
     lessvars = copy.copy(tmpl.defaults['sessionvars'])
     lessvars['revcount'] = max(revcount / 2, 1)
     morevars = copy.copy(tmpl.defaults['sessionvars'])
     morevars['revcount'] = revcount * 2
 
     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 = []
     if pos != -1:
         allrevs = web.repo.changelog.revs(pos, 0)
         revs = []
         for i in allrevs:
             revs.append(i)
             if len(revs) >= revcount:
                 break
 
         # 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, revset.baseset(revs))
         # As we said one line above... not lazy.
         tree = list(graphmod.colored(dag, web.repo))
 
     def getcolumns(tree):
         cols = 0
         for (id, type, ctx, vtx, edges) in tree:
             if type != graphmod.CHANGESET:
                 continue
             cols = max(cols, max([edge[0] for edge in edges] or [0]),
                              max([edge[1] for edge in edges] or [0]))
         return cols
 
     def graphdata(usetuples, **map):
         data = []
 
         row = 0
         for (id, type, ctx, vtx, edges) in tree:
             if type != graphmod.CHANGESET:
                 continue
             node = str(ctx)
             age = templatefilters.age(ctx.date())
             desc = templatefilters.firstline(ctx.description())
             desc = cgi.escape(templatefilters.nonempty(desc))
             user = cgi.escape(templatefilters.person(ctx.user()))
             branch = cgi.escape(ctx.branch())
             try:
                 branchnode = web.repo.branchtip(branch)
             except error.RepoLookupError:
                 branchnode = None
             branch = branch, branchnode == ctx.node()
 
             if usetuples:
                 data.append((node, vtx, edges, desc, user, age, branch,
                              [cgi.escape(x) for x in ctx.tags()],
                              [cgi.escape(x) for x in ctx.bookmarks()]))
             else:
                 edgedata = [{'col': edge[0], 'nextcol': edge[1],
                              'color': (edge[2] - 1) % 6 + 1,
                              'width': edge[3], 'bcolor': edge[4]}
                             for edge in edges]
 
                 data.append(
                     {'node': node,
                      'col': vtx[0],
                      'color': (vtx[1] - 1) % 6 + 1,
                      'edges': edgedata,
                      'row': row,
                      'nextrow': row + 1,
                      'desc': desc,
                      'user': user,
                      'age': age,
                      'bookmarks': webutil.nodebookmarksdict(
                          web.repo, ctx.node()),
                      'branches': webutil.nodebranchdict(web.repo, ctx),
                      'inbranch': webutil.nodeinbranch(web.repo, ctx),
                      'tags': webutil.nodetagsdict(web.repo, ctx.node())})
 
             row += 1
 
         return data
 
     cols = getcolumns(tree)
     rows = len(tree)
     canvasheight = (rows + 1) * bg_height - 27
 
     return tmpl('graph', rev=rev, symrev=symrev, revcount=revcount,
                 uprev=uprev,
                 lessvars=lessvars, morevars=morevars, downrev=downrev,
                 cols=cols, rows=rows,
                 canvaswidth=(cols + 1) * bg_height,
                 truecanvasheight=rows * bg_height,
                 canvasheight=canvasheight, bg_height=bg_height,
                 jsdata=lambda **x: graphdata(True, **x),
                 nodes=lambda **x: graphdata(False, **x),
                 node=ctx.hex(), changenav=changenav)
 
 def _getdoc(e):
     doc = e[0].__doc__
     if doc:
         doc = _(doc).partition('\n')[0]
     else:
         doc = _('(no help text available)')
     return doc
 
 @webcommand('help')
 def help(web, req, tmpl):
     """
     /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 mercurial import commands # avoid cycle
-    from mercurial import help as helpmod # avoid cycle
+    from .. import commands, help as helpmod  # avoid cycle
 
     topicname = req.form.get('node', [None])[0]
     if not topicname:
         def topics(**map):
             for entries, summary, _doc in helpmod.helptable:
                 yield {'topic': entries[0], 'summary': summary}
 
         early, other = [], []
         primary = lambda s: s.partition('|')[0]
         for c, e in commands.table.iteritems():
             doc = _getdoc(e)
             if 'DEPRECATED' in doc or c.startswith('debug'):
                 continue
             cmd = primary(c)
             if cmd.startswith('^'):
                 early.append((cmd[1:], doc))
             else:
                 other.append((cmd, doc))
 
         early.sort()
         other.sort()
 
         def earlycommands(**map):
             for c, doc in early:
                 yield {'topic': c, 'summary': doc}
 
         def othercommands(**map):
             for c, doc in other:
                 yield {'topic': c, 'summary': doc}
 
         return tmpl('helptopics', topics=topics, earlycommands=earlycommands,
                     othercommands=othercommands, title='Index')
 
     u = webutil.wsgiui()
     u.verbose = True
     try:
         doc = helpmod.help_(u, topicname)
     except error.UnknownCommand:
         raise ErrorResponse(HTTP_NOT_FOUND)
     return tmpl('help', topic=topicname, doc=doc)
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = commands.values()

mercurial/hgweb/webutil.py

@@ -1,593 +1,609 b''
 # hgweb/webutil.py - utility library for the web interface.
 #
 # 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.
 
-import os, copy
+from __future__ import absolute_import
+
+import copy
+import difflib
+import os
 import re
-from mercurial import match, patch, error, util, pathutil, context
-from mercurial import ui as uimod
-from mercurial.i18n import _
-from mercurial.node import hex, nullid, short
-from mercurial import templatefilters
-from common import ErrorResponse, paritygen
-from common import HTTP_NOT_FOUND
-import difflib
+
+from ..i18n import _
+from ..node import hex, nullid, short
+
+from .common import (
+    ErrorResponse,
+    HTTP_NOT_FOUND,
+    paritygen,
+)
+
+from .. import (
+    context,
+    error,
+    match,
+    patch,
+    pathutil,
+    templatefilters,
+    ui as uimod,
+    util,
+)
 
 def up(p):
     if p[0] != "/":
         p = "/" + p
     if p[-1] == "/":
         p = p[:-1]
     up = os.path.dirname(p)
     if up == "/":
         return "/"
     return up + "/"
 
 def _navseq(step, firststep=None):
     if firststep:
         yield firststep
         if firststep >= 20 and firststep <= 40:
             firststep = 50
             yield firststep
         assert step > 0
         assert firststep > 0
         while step <= firststep:
             step *= 10
     while True:
         yield 1 * step
         yield 3 * step
         step *= 10
 
 class revnav(object):
 
     def __init__(self, repo):
         """Navigation generation object
 
         :repo: repo object we generate nav for
         """
         # used for hex generation
         self._revlog = repo.changelog
 
     def __nonzero__(self):
         """return True if any revision to navigate over"""
         return self._first() is not None
 
     def _first(self):
         """return the minimum non-filtered changeset or None"""
         try:
             return iter(self._revlog).next()
         except StopIteration:
             return None
 
     def hex(self, rev):
         return hex(self._revlog.node(rev))
 
     def gen(self, pos, pagelen, limit):
         """computes label and revision id for navigation link
 
         :pos: is the revision relative to which we generate navigation.
         :pagelen: the size of each navigation page
         :limit: how far shall we link
 
         The return is:
             - a single element tuple
             - containing a dictionary with a `before` and `after` key
             - values are generator functions taking arbitrary number of kwargs
             - yield items are dictionaries with `label` and `node` keys
         """
         if not self:
             # empty repo
             return ({'before': (), 'after': ()},)
 
         targets = []
         for f in _navseq(1, pagelen):
             if f > limit:
                 break
             targets.append(pos + f)
             targets.append(pos - f)
         targets.sort()
 
         first = self._first()
         navbefore = [("(%i)" % first, self.hex(first))]
         navafter = []
         for rev in targets:
             if rev not in self._revlog:
                 continue
             if pos < rev < limit:
                 navafter.append(("+%d" % abs(rev - pos), self.hex(rev)))
             if 0 < rev < pos:
                 navbefore.append(("-%d" % abs(rev - pos), self.hex(rev)))
 
 
         navafter.append(("tip", "tip"))
 
         data = lambda i: {"label": i[0], "node": i[1]}
         return ({'before': lambda **map: (data(i) for i in navbefore),
                  'after':  lambda **map: (data(i) for i in navafter)},)
 
 class filerevnav(revnav):
 
     def __init__(self, repo, path):
         """Navigation generation object
 
         :repo: repo object we generate nav for
         :path: path of the file we generate nav for
         """
         # used for iteration
         self._changelog = repo.unfiltered().changelog
         # used for hex generation
         self._revlog = repo.file(path)
 
     def hex(self, rev):
         return hex(self._changelog.node(self._revlog.linkrev(rev)))
 
 class _siblings(object):
     def __init__(self, siblings=[], hiderev=None):
         self.siblings = [s for s in siblings if s.node() != nullid]
         if len(self.siblings) == 1 and self.siblings[0].rev() == hiderev:
             self.siblings = []
 
     def __iter__(self):
         for s in self.siblings:
             d = {
                 'node': s.hex(),
                 'rev': s.rev(),
                 'user': s.user(),
                 'date': s.date(),
                 'description': s.description(),
                 'branch': s.branch(),
             }
             if util.safehasattr(s, 'path'):
                 d['file'] = s.path()
             yield d
 
     def __len__(self):
         return len(self.siblings)
 
 def parents(ctx, hide=None):
     if isinstance(ctx, context.basefilectx):
         introrev = ctx.introrev()
         if ctx.changectx().rev() != introrev:
             return _siblings([ctx.repo()[introrev]], hide)
     return _siblings(ctx.parents(), hide)
 
 def children(ctx, hide=None):
     return _siblings(ctx.children(), hide)
 
 def renamelink(fctx):
     r = fctx.renamed()
     if r:
         return [{'file': r[0], 'node': hex(r[1])}]
     return []
 
 def nodetagsdict(repo, node):
     return [{"name": i} for i in repo.nodetags(node)]
 
 def nodebookmarksdict(repo, node):
     return [{"name": i} for i in repo.nodebookmarks(node)]
 
 def nodebranchdict(repo, ctx):
     branches = []
     branch = ctx.branch()
     # If this is an empty repo, ctx.node() == nullid,
     # ctx.branch() == 'default'.
     try:
         branchnode = repo.branchtip(branch)
     except error.RepoLookupError:
         branchnode = None
     if branchnode == ctx.node():
         branches.append({"name": branch})
     return branches
 
 def nodeinbranch(repo, ctx):
     branches = []
     branch = ctx.branch()
     try:
         branchnode = repo.branchtip(branch)
     except error.RepoLookupError:
         branchnode = None
     if branch != 'default' and branchnode != ctx.node():
         branches.append({"name": branch})
     return branches
 
 def nodebranchnodefault(ctx):
     branches = []
     branch = ctx.branch()
     if branch != 'default':
         branches.append({"name": branch})
     return branches
 
 def showtag(repo, tmpl, t1, node=nullid, **args):
     for t in repo.nodetags(node):
         yield tmpl(t1, tag=t, **args)
 
 def showbookmark(repo, tmpl, t1, node=nullid, **args):
     for t in repo.nodebookmarks(node):
         yield tmpl(t1, bookmark=t, **args)
 
 def branchentries(repo, stripecount, limit=0):
     tips = []
     heads = repo.heads()
     parity = paritygen(stripecount)
     sortkey = lambda item: (not item[1], item[0].rev())
 
     def entries(**map):
         count = 0
         if not tips:
             for tag, hs, tip, closed in repo.branchmap().iterbranches():
                 tips.append((repo[tip], closed))
         for ctx, closed in sorted(tips, key=sortkey, reverse=True):
             if limit > 0 and count >= limit:
                 return
             count += 1
             if closed:
                 status = 'closed'
             elif ctx.node() not in heads:
                 status = 'inactive'
             else:
                 status = 'open'
             yield {
                 'parity': parity.next(),
                 'branch': ctx.branch(),
                 'status': status,
                 'node': ctx.hex(),
                 'date': ctx.date()
             }
 
     return entries
 
 def cleanpath(repo, path):
     path = path.lstrip('/')
     return pathutil.canonpath(repo.root, '', path)
 
 def changeidctx(repo, changeid):
     try:
         ctx = repo[changeid]
     except error.RepoError:
         man = repo.manifest
         ctx = repo[man.linkrev(man.rev(man.lookup(changeid)))]
 
     return ctx
 
 def changectx(repo, req):
     changeid = "tip"
     if 'node' in req.form:
         changeid = req.form['node'][0]
         ipos = changeid.find(':')
         if ipos != -1:
             changeid = changeid[(ipos + 1):]
     elif 'manifest' in req.form:
         changeid = req.form['manifest'][0]
 
     return changeidctx(repo, changeid)
 
 def basechangectx(repo, req):
     if 'node' in req.form:
         changeid = req.form['node'][0]
         ipos = changeid.find(':')
         if ipos != -1:
             changeid = changeid[:ipos]
             return changeidctx(repo, changeid)
 
     return None
 
 def filectx(repo, req):
     if 'file' not in req.form:
         raise ErrorResponse(HTTP_NOT_FOUND, 'file not given')
     path = cleanpath(repo, req.form['file'][0])
     if 'node' in req.form:
         changeid = req.form['node'][0]
     elif 'filenode' in req.form:
         changeid = req.form['filenode'][0]
     else:
         raise ErrorResponse(HTTP_NOT_FOUND, 'node or filenode not given')
     try:
         fctx = repo[changeid][path]
     except error.RepoError:
         fctx = repo.filectx(path, fileid=changeid)
 
     return fctx
 
 def changelistentry(web, ctx, tmpl):
     '''Obtain a dictionary to be used for entries in a changelist.
 
     This function is called when producing items for the "entries" list passed
     to the "shortlog" and "changelog" templates.
     '''
     repo = web.repo
     rev = ctx.rev()
     n = ctx.node()
     showtags = showtag(repo, tmpl, 'changelogtag', n)
     files = listfilediffs(tmpl, ctx.files(), n, web.maxfiles)
 
     return {
         "author": ctx.user(),
         "parent": lambda **x: parents(ctx, rev - 1),
         "child": lambda **x: children(ctx, rev + 1),
         "changelogtag": showtags,
         "desc": ctx.description(),
         "extra": ctx.extra(),
         "date": ctx.date(),
         "files": files,
         "rev": rev,
         "node": hex(n),
         "tags": nodetagsdict(repo, n),
         "bookmarks": nodebookmarksdict(repo, n),
         "inbranch": nodeinbranch(repo, ctx),
         "branches": nodebranchdict(repo, ctx)
     }
 
 def symrevorshortnode(req, ctx):
     if 'node' in req.form:
         return templatefilters.revescape(req.form['node'][0])
     else:
         return short(ctx.node())
 
 def changesetentry(web, req, tmpl, ctx):
     '''Obtain a dictionary to be used to render the "changeset" template.'''
 
     showtags = showtag(web.repo, tmpl, 'changesettag', ctx.node())
     showbookmarks = showbookmark(web.repo, tmpl, 'changesetbookmark',
                                  ctx.node())
     showbranch = nodebranchnodefault(ctx)
 
     files = []
     parity = paritygen(web.stripecount)
     for blockno, f in enumerate(ctx.files()):
         template = f in ctx and 'filenodelink' or 'filenolink'
         files.append(tmpl(template,
                           node=ctx.hex(), file=f, blockno=blockno + 1,
                           parity=parity.next()))
 
     basectx = basechangectx(web.repo, req)
     if basectx is None:
         basectx = ctx.p1()
 
     style = web.config('web', 'style', 'paper')
     if 'style' in req.form:
         style = req.form['style'][0]
 
     parity = paritygen(web.stripecount)
     diff = diffs(web.repo, tmpl, ctx, basectx, None, parity, style)
 
     parity = paritygen(web.stripecount)
     diffstatsgen = diffstatgen(ctx, basectx)
     diffstats = diffstat(tmpl, ctx, diffstatsgen, parity)
 
     return dict(
         diff=diff,
         rev=ctx.rev(),
         node=ctx.hex(),
         symrev=symrevorshortnode(req, ctx),
         parent=parents(ctx),
         child=children(ctx),
         basenode=basectx.hex(),
         changesettag=showtags,
         changesetbookmark=showbookmarks,
         changesetbranch=showbranch,
         author=ctx.user(),
         desc=ctx.description(),
         extra=ctx.extra(),
         date=ctx.date(),
         phase=ctx.phasestr(),
         files=files,
         diffsummary=lambda **x: diffsummary(diffstatsgen),
         diffstat=diffstats,
         archives=web.archivelist(ctx.hex()),
         tags=nodetagsdict(web.repo, ctx.node()),
         bookmarks=nodebookmarksdict(web.repo, ctx.node()),
         branch=showbranch,
         inbranch=nodeinbranch(web.repo, ctx),
         branches=nodebranchdict(web.repo, ctx))
 
 def listfilediffs(tmpl, files, node, max):
     for f in files[:max]:
         yield tmpl('filedifflink', node=hex(node), file=f)
     if len(files) > max:
         yield tmpl('fileellipses')
 
 def diffs(repo, tmpl, ctx, basectx, files, parity, style):
 
     def countgen():
         start = 1
         while True:
             yield start
             start += 1
 
     blockcount = countgen()
     def prettyprintlines(diff, blockno):
         for lineno, l in enumerate(diff.splitlines(True)):
             difflineno = "%d.%d" % (blockno, lineno + 1)
             if l.startswith('+'):
                 ltype = "difflineplus"
             elif l.startswith('-'):
                 ltype = "difflineminus"
             elif l.startswith('@'):
                 ltype = "difflineat"
             else:
                 ltype = "diffline"
             yield tmpl(ltype,
                        line=l,
                        lineno=lineno + 1,
                        lineid="l%s" % difflineno,
                        linenumber="% 8s" % difflineno)
 
     if files:
         m = match.exact(repo.root, repo.getcwd(), files)
     else:
         m = match.always(repo.root, repo.getcwd())
 
     diffopts = patch.diffopts(repo.ui, untrusted=True)
     if basectx is None:
         parents = ctx.parents()
         if parents:
             node1 = parents[0].node()
         else:
             node1 = nullid
     else:
         node1 = basectx.node()
     node2 = ctx.node()
 
     block = []
     for chunk in patch.diff(repo, node1, node2, m, opts=diffopts):
         if chunk.startswith('diff') and block:
             blockno = blockcount.next()
             yield tmpl('diffblock', parity=parity.next(), blockno=blockno,
                        lines=prettyprintlines(''.join(block), blockno))
             block = []
         if chunk.startswith('diff') and style != 'raw':
             chunk = ''.join(chunk.splitlines(True)[1:])
         block.append(chunk)
     blockno = blockcount.next()
     yield tmpl('diffblock', parity=parity.next(), blockno=blockno,
                lines=prettyprintlines(''.join(block), blockno))
 
 def compare(tmpl, context, leftlines, rightlines):
     '''Generator function that provides side-by-side comparison data.'''
 
     def compline(type, leftlineno, leftline, rightlineno, rightline):
         lineid = leftlineno and ("l%s" % leftlineno) or ''
         lineid += rightlineno and ("r%s" % rightlineno) or ''
         return tmpl('comparisonline',
                     type=type,
                     lineid=lineid,
                     leftlineno=leftlineno,
                     leftlinenumber="% 6s" % (leftlineno or ''),
                     leftline=leftline or '',
                     rightlineno=rightlineno,
                     rightlinenumber="% 6s" % (rightlineno or ''),
                     rightline=rightline or '')
 
     def getblock(opcodes):
         for type, llo, lhi, rlo, rhi in opcodes:
             len1 = lhi - llo
             len2 = rhi - rlo
             count = min(len1, len2)
             for i in xrange(count):
                 yield compline(type=type,
                                leftlineno=llo + i + 1,
                                leftline=leftlines[llo + i],
                                rightlineno=rlo + i + 1,
                                rightline=rightlines[rlo + i])
             if len1 > len2:
                 for i in xrange(llo + count, lhi):
                     yield compline(type=type,
                                    leftlineno=i + 1,
                                    leftline=leftlines[i],
                                    rightlineno=None,
                                    rightline=None)
             elif len2 > len1:
                 for i in xrange(rlo + count, rhi):
                     yield compline(type=type,
                                    leftlineno=None,
                                    leftline=None,
                                    rightlineno=i + 1,
                                    rightline=rightlines[i])
 
     s = difflib.SequenceMatcher(None, leftlines, rightlines)
     if context < 0:
         yield tmpl('comparisonblock', lines=getblock(s.get_opcodes()))
     else:
         for oc in s.get_grouped_opcodes(n=context):
             yield tmpl('comparisonblock', lines=getblock(oc))
 
 def diffstatgen(ctx, basectx):
     '''Generator function that provides the diffstat data.'''
 
     stats = patch.diffstatdata(util.iterlines(ctx.diff(basectx)))
     maxname, maxtotal, addtotal, removetotal, binary = patch.diffstatsum(stats)
     while True:
         yield stats, maxname, maxtotal, addtotal, removetotal, binary
 
 def diffsummary(statgen):
     '''Return a short summary of the diff.'''
 
     stats, maxname, maxtotal, addtotal, removetotal, binary = statgen.next()
     return _(' %d files changed, %d insertions(+), %d deletions(-)\n') % (
              len(stats), addtotal, removetotal)
 
 def diffstat(tmpl, ctx, statgen, parity):
     '''Return a diffstat template for each file in the diff.'''
 
     stats, maxname, maxtotal, addtotal, removetotal, binary = statgen.next()
     files = ctx.files()
 
     def pct(i):
         if maxtotal == 0:
             return 0
         return (float(i) / maxtotal) * 100
 
     fileno = 0
     for filename, adds, removes, isbinary in stats:
         template = filename in files and 'diffstatlink' or 'diffstatnolink'
         total = adds + removes
         fileno += 1
         yield tmpl(template, node=ctx.hex(), file=filename, fileno=fileno,
                    total=total, addpct=pct(adds), removepct=pct(removes),
                    parity=parity.next())
 
 class sessionvars(object):
     def __init__(self, vars, start='?'):
         self.start = start
         self.vars = vars
     def __getitem__(self, key):
         return self.vars[key]
     def __setitem__(self, key, value):
         self.vars[key] = value
     def __copy__(self):
         return sessionvars(copy.copy(self.vars), self.start)
     def __iter__(self):
         separator = self.start
         for key, value in sorted(self.vars.iteritems()):
             yield {'name': key, 'value': str(value), 'separator': separator}
             separator = '&'
 
 class wsgiui(uimod.ui):
     # default termwidth breaks under mod_wsgi
     def termwidth(self):
         return 80
 
 def getwebsubs(repo):
     websubtable = []
     websubdefs = repo.ui.configitems('websub')
     # we must maintain interhg backwards compatibility
     websubdefs += repo.ui.configitems('interhg')
     for key, pattern in websubdefs:
         # grab the delimiter from the character after the "s"
         unesc = pattern[1]
         delim = re.escape(unesc)
 
         # identify portions of the pattern, taking care to avoid escaped
         # delimiters. the replace format and flags are optional, but
         # delimiters are required.
         match = re.match(
             r'^s%s(.+)(?:(?<=\\\\)|(?<!\\))%s(.*)%s([ilmsux])*$'
             % (delim, delim, delim), pattern)
         if not match:
             repo.ui.warn(_("websub: invalid pattern for %s: %s\n")
                               % (key, pattern))
             continue
 
         # we need to unescape the delimiter for regexp and format
         delim_re = re.compile(r'(?<!\\)\\%s' % delim)
         regexp = delim_re.sub(unesc, match.group(1))
         format = delim_re.sub(unesc, match.group(2))
 
         # the pattern allows for 6 regexp flags, so set them if necessary
         flagin = match.group(3)
         flags = 0
         if flagin:
             for flag in flagin.upper():
                 flags |= re.__dict__[flag]
 
         try:
             regexp = re.compile(regexp, flags)
             websubtable.append((regexp, format))
         except re.error:
             repo.ui.warn(_("websub: invalid regexp for %s: %s\n")
                          % (key, regexp))
     return websubtable

mercurial/hgweb/wsgicgi.py

@@ -1,83 +1,92 b''
 # hgweb/wsgicgi.py - CGI->WSGI translator
 #
 # Copyright 2006 Eric Hopper <[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.
 #
 # This was originally copied from the public domain code at
 # http://www.python.org/dev/peps/pep-0333/#the-server-gateway-side
 
-import os, sys
-from mercurial import util
-from mercurial.hgweb import common
+from __future__ import absolute_import
+
+import os
+import sys
+
+from .. import (
+    util,
+)
+
+from . import (
+    common,
+)
 
 def launch(application):
     util.setbinary(sys.stdin)
     util.setbinary(sys.stdout)
 
     environ = dict(os.environ.iteritems())
     environ.setdefault('PATH_INFO', '')
     if environ.get('SERVER_SOFTWARE', '').startswith('Microsoft-IIS'):
         # IIS includes script_name in PATH_INFO
         scriptname = environ['SCRIPT_NAME']
         if environ['PATH_INFO'].startswith(scriptname):
             environ['PATH_INFO'] = environ['PATH_INFO'][len(scriptname):]
 
     stdin = sys.stdin
     if environ.get('HTTP_EXPECT', '').lower() == '100-continue':
         stdin = common.continuereader(stdin, sys.stdout.write)
 
     environ['wsgi.input'] = stdin
     environ['wsgi.errors'] = sys.stderr
     environ['wsgi.version'] = (1, 0)
     environ['wsgi.multithread'] = False
     environ['wsgi.multiprocess'] = True
     environ['wsgi.run_once'] = True
 
     if environ.get('HTTPS', 'off').lower() in ('on', '1', 'yes'):
         environ['wsgi.url_scheme'] = 'https'
     else:
         environ['wsgi.url_scheme'] = 'http'
 
     headers_set = []
     headers_sent = []
     out = sys.stdout
 
     def write(data):
         if not headers_set:
             raise AssertionError("write() before start_response()")
 
         elif not headers_sent:
             # Before the first output, send the stored headers
             status, response_headers = headers_sent[:] = headers_set
             out.write('Status: %s\r\n' % status)
             for header in response_headers:
                 out.write('%s: %s\r\n' % header)
             out.write('\r\n')
 
         out.write(data)
         out.flush()
 
     def start_response(status, response_headers, exc_info=None):
         if exc_info:
             try:
                 if headers_sent:
                     # Re-raise original exception if headers sent
                     raise exc_info[0](exc_info[1], exc_info[2])
             finally:
                 exc_info = None     # avoid dangling circular ref
         elif headers_set:
             raise AssertionError("Headers already set!")
 
         headers_set[:] = [status, response_headers]
         return write
 
     content = application(environ, start_response)
     try:
         for chunk in content:
             write(chunk)
         if not headers_sent:
             write('')   # send headers now if body was empty
     finally:
         getattr(content, 'close', lambda : None)()