hgwebdir: allow a repository to be hosted at "/"

This can be useful in general, but will also be useful for hosting subrepos,
with the main repo at /.

mercurial/hgweb/hgweb_mod.py

@@ -1,483 +1,483 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 .common import (
     ErrorResponse,
     HTTP_BAD_REQUEST,
     HTTP_NOT_FOUND,
     HTTP_NOT_MODIFIED,
     HTTP_OK,
     HTTP_SERVER_ERROR,
     caching,
     cspvalues,
     permhooks,
 )
 from .request import wsgirequest
 
 from .. import (
     encoding,
     error,
     hg,
     hook,
     profiling,
     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',
 }
 
 archivespecs = util.sortdict((
     ('zip', ('application/zip', 'zip', '.zip', None)),
     ('gz', ('application/x-gzip', 'tgz', '.tar.gz', None)),
     ('bz2', ('application/x-bzip2', 'tbz2', '.tar.bz2', None)),
 ))
 
 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.archivespecs = archivespecs
 
         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
 
         self.csp, self.nonce = cspvalues(self.repo.ui)
 
     # 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)
 
     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
 
         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,
             'nonce': self.nonce,
         }
         tmpl = templater.templater.frommapfile(mapfile,
                                                filters={'websub': websubfilter},
                                                defaults=defaults)
         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.load()
             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 encoding.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:
             with profiling.maybeprofile(repo.ui):
                 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
 
         if rctx.csp:
             # hgwebdir may have added CSP header. Since we generate our own,
             # replace it.
             req.headers = [h for h in req.headers
                            if h[0] != 'Content-Security-Policy']
             req.headers.append(('Content-Security-Policy', rctx.csp))
 
         # 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:
+        if req.env.get('REPO_NAME'):
             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]
 
             # Don't enable caching if using a CSP nonce because then it wouldn't
             # be a nonce.
             if rctx.configbool('web', 'cache', True) and not rctx.nonce:
                 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,535 +1,539 b''
 # hgweb/hgwebdir_mod.py - Web interface for a directory of repositories.
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import os
 import re
 import time
 
 from ..i18n import _
 
 from .common import (
     ErrorResponse,
     HTTP_NOT_FOUND,
     HTTP_OK,
     HTTP_SERVER_ERROR,
     cspvalues,
     get_contact,
     get_mtime,
     ismember,
     paritygen,
     staticfile,
 )
 from .request import wsgirequest
 
 from .. import (
     encoding,
     error,
     hg,
     profiling,
     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.load()
             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 encoding.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):
         with profiling.maybeprofile(self.ui):
             for r in self._runwsgi(req):
                 yield r
 
     def _runwsgi(self, req):
         try:
             self.refresh()
 
             csp, nonce = cspvalues(self.ui)
             if csp:
                 req.headers.append(('Content-Security-Policy', csp))
 
             virtual = req.env.get("PATH_INFO", "").strip('/')
             tmpl = self.templater(req, nonce)
             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
 
             repos = dict(self.repos)
 
-            if not virtual or (virtual == 'index' and virtual not in repos):
+            if (not virtual or virtual == 'index') and virtual not in repos:
                 req.respond(HTTP_OK, ctype)
                 return self.makeindex(req, tmpl)
 
             # nested indexes and hgwebs
 
             if virtual.endswith('/index') and virtual not in repos:
                 subdir = virtual[:-len('index')]
                 if any(r.startswith(subdir) for r in repos):
                     req.respond(HTTP_OK, ctype)
                     return self.makeindex(req, tmpl, subdir)
 
-            virtualrepo = virtual
-            while virtualrepo:
+            def _virtualdirs():
+                # Check the full virtual path, each parent, and the root ('')
+                if virtual != '':
+                    yield virtual
+
+                    for p in util.finddirs(virtual):
+                        yield p
+
+                yield ''
+
+            for virtualrepo in _virtualdirs():
                 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 typ, spec in hgweb_mod.archivespecs.iteritems():
                 if typ in allowed or ui.configbool("web", "allow" + typ,
                                                     untrusted=True):
                     archives.append({"type" : typ, "extension": spec[2],
                                      "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]
                 parts.insert(0, '/' + subdir.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,
                            'labels': [],
                            }
 
                     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,
                        'labels': u.configlist('web', 'labels', untrusted=True),
                        }
 
                 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, nonce):
 
         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 += '/'
 
         defaults = {
             "encoding": encoding.encoding,
             "motd": motd,
             "url": url,
             "logourl": logourl,
             "logoimg": logoimg,
             "staticurl": staticurl,
             "sessionvars": sessionvars,
             "style": style,
             "nonce": nonce,
         }
         tmpl = templater.templater.frommapfile(mapfile, defaults=defaults)
         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

tests/test-hgwebdir.t

@@ -1,1729 +1,1745 b''
 #require serve
 
 hide outer repo and work in dir without '.hg'
   $ hg init
   $ mkdir dir
   $ cd dir
 
 Tests some basic hgwebdir functionality. Tests setting up paths and
 collection, different forms of 404s and the subdirectory support.
 
   $ mkdir webdir
   $ cd webdir
   $ hg init a
   $ echo a > a/a
   $ hg --cwd a ci -Ama -d'1 0'
   adding a
 
 create a mercurial queue repository
 
   $ hg --cwd a qinit --config extensions.hgext.mq= -c
   $ hg init b
   $ echo b > b/b
   $ hg --cwd b ci -Amb -d'2 0'
   adding b
 
 create a nested repository
 
   $ cd b
   $ hg init d
   $ echo d > d/d
   $ hg --cwd d ci -Amd -d'3 0'
   adding d
   $ cd ..
   $ hg init c
   $ echo c > c/c
   $ hg --cwd c ci -Amc -d'3 0'
   adding c
 
 create a subdirectory containing repositories and subrepositories
 
   $ mkdir notrepo
   $ cd notrepo
   $ hg init e
   $ echo e > e/e
   $ hg --cwd e ci -Ame -d'4 0'
   adding e
   $ hg init e/e2
   $ echo e2 > e/e2/e2
   $ hg --cwd e/e2 ci -Ame2 -d '4 0'
   adding e2
   $ hg init f
   $ echo f > f/f
   $ hg --cwd f ci -Amf -d'4 0'
   adding f
   $ hg init f/f2
   $ echo f2 > f/f2/f2
   $ hg --cwd f/f2 ci -Amf2 -d '4 0'
   adding f2
   $ echo 'f2 = f2' > f/.hgsub
   $ hg -R f ci -Am 'add subrepo' -d'4 0'
   adding .hgsub
   $ cat >> f/.hg/hgrc << EOF
   > [web]
   > name = fancy name for repo f
   > labels = foo, bar
   > EOF
   $ cd ..
 
 create repository without .hg/store
 
   $ hg init nostore
   $ rm -R nostore/.hg/store
   $ root=`pwd`
   $ cd ..
 
 serve
   $ cat > paths.conf <<EOF
   > [paths]
   > a=$root/a
   > b=$root/b
   > EOF
   $ hg serve -p $HGPORT -d --pid-file=hg.pid --webdir-conf paths.conf \
   >     -A access-paths.log -E error-paths-1.log
   $ cat hg.pid >> $DAEMON_PIDS
 
 should give a 404 - file does not exist
 
   $ get-with-headers.py localhost:$HGPORT 'a/file/tip/bork?style=raw'
   404 Not Found
   
   
   error: bork@8580ff50825a: not found in manifest
   [1]
 
 should succeed
 
   $ get-with-headers.py localhost:$HGPORT '?style=raw'
   200 Script output follows
   
   
   /a/
   /b/
   
   $ get-with-headers.py localhost:$HGPORT '?style=json'
   200 Script output follows
   
   {
   "entries": [{
   "name": "a",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "b",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }]
   } (no-eol)
 
   $ get-with-headers.py localhost:$HGPORT 'a/file/tip/a?style=raw'
   200 Script output follows
   
   a
   $ get-with-headers.py localhost:$HGPORT 'b/file/tip/b?style=raw'
   200 Script output follows
   
   b
 
 should give a 404 - repo is not published
 
   $ get-with-headers.py localhost:$HGPORT 'c/file/tip/c?style=raw'
   404 Not Found
   
   
   error: repository c/file/tip/c not found
   [1]
 
 atom-log without basedir
 
   $ get-with-headers.py localhost:$HGPORT 'a/atom-log' | grep '<link'
    <link rel="self" href="http://*:$HGPORT/a/atom-log"/> (glob)
    <link rel="alternate" href="http://*:$HGPORT/a/"/> (glob)
     <link href="http://*:$HGPORT/a/rev/8580ff50825a"/> (glob)
 
 rss-log without basedir
 
   $ get-with-headers.py localhost:$HGPORT 'a/rss-log' | grep '<guid'
       <guid isPermaLink="true">http://*:$HGPORT/a/rev/8580ff50825a</guid> (glob)
   $ cat > paths.conf <<EOF
   > [paths]
   > t/a/=$root/a
   > b=$root/b
   > coll=$root/*
   > rcoll=$root/**
   > star=*
   > starstar=**
   > astar=webdir/a/*
   > EOF
   $ hg serve -p $HGPORT1 -d --pid-file=hg.pid --webdir-conf paths.conf \
   >     -A access-paths.log -E error-paths-2.log
   $ cat hg.pid >> $DAEMON_PIDS
 
 should succeed, slashy names
 
   $ get-with-headers.py localhost:$HGPORT1 '?style=raw'
   200 Script output follows
   
   
   /t/a/
   /b/
   /coll/a/
   /coll/a/.hg/patches/
   /coll/b/
   /coll/c/
   /coll/notrepo/e/
   /coll/notrepo/f/
   /rcoll/a/
   /rcoll/a/.hg/patches/
   /rcoll/b/
   /rcoll/b/d/
   /rcoll/c/
   /rcoll/notrepo/e/
   /rcoll/notrepo/e/e2/
   /rcoll/notrepo/f/
   /rcoll/notrepo/f/f2/
   /star/webdir/a/
   /star/webdir/a/.hg/patches/
   /star/webdir/b/
   /star/webdir/c/
   /star/webdir/notrepo/e/
   /star/webdir/notrepo/f/
   /starstar/webdir/a/
   /starstar/webdir/a/.hg/patches/
   /starstar/webdir/b/
   /starstar/webdir/b/d/
   /starstar/webdir/c/
   /starstar/webdir/notrepo/e/
   /starstar/webdir/notrepo/e/e2/
   /starstar/webdir/notrepo/f/
   /starstar/webdir/notrepo/f/f2/
   /astar/
   /astar/.hg/patches/
   
 
   $ get-with-headers.py localhost:$HGPORT1 '?style=json'
   200 Script output follows
   
   {
   "entries": [{
   "name": "t/a",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "b",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "coll/a",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "coll/a/.hg/patches",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "coll/b",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "coll/c",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "coll/notrepo/e",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "fancy name for repo f",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": ["foo", "bar"]
   }, {
   "name": "rcoll/a",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "rcoll/a/.hg/patches",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "rcoll/b",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "rcoll/b/d",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "rcoll/c",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "rcoll/notrepo/e",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "rcoll/notrepo/e/e2",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "fancy name for repo f",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": ["foo", "bar"]
   }, {
   "name": "rcoll/notrepo/f/f2",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "star/webdir/a",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "star/webdir/a/.hg/patches",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "star/webdir/b",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "star/webdir/c",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "star/webdir/notrepo/e",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "fancy name for repo f",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": ["foo", "bar"]
   }, {
   "name": "starstar/webdir/a",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "starstar/webdir/a/.hg/patches",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "starstar/webdir/b",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "starstar/webdir/b/d",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "starstar/webdir/c",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "starstar/webdir/notrepo/e",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "starstar/webdir/notrepo/e/e2",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "fancy name for repo f",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": ["foo", "bar"]
   }, {
   "name": "starstar/webdir/notrepo/f/f2",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "astar",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }, {
   "name": "astar/.hg/patches",
   "description": "unknown",
   "contact": "Foo Bar \[e-mail]\u003e",
   "lastchange": [*, *], (glob)
   "labels": []
   }]
   } (no-eol)
 
   $ get-with-headers.py localhost:$HGPORT1 '?style=paper'
   200 Script output follows
   
   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
   <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
   <head>
   <link rel="icon" href="/static/hgicon.png" type="image/png" />
   <meta name="robots" content="index, nofollow" />
   <link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
   <script type="text/javascript" src="/static/mercurial.js"></script>
   
   <title>Mercurial repositories index</title>
   </head>
   <body>
   
   <div class="container">
   <div class="menu">
   <a href="https://mercurial-scm.org/">
   <img src="/static/hglogo.png" width=75 height=90 border=0 alt="mercurial" /></a>
   </div>
   <div class="main">
   <h2 class="breadcrumb"><a href="/">Mercurial</a> </h2>
   
   <table class="bigtable">
       <thead>
       <tr>
           <th><a href="?sort=name">Name</a></th>
           <th><a href="?sort=description">Description</a></th>
           <th><a href="?sort=contact">Contact</a></th>
           <th><a href="?sort=lastchange">Last modified</a></th>
           <th>&nbsp;</th>
           <th>&nbsp;</th>
       </tr>
       </thead>
       <tbody class="stripes2">
       
   <tr>
   <td><a href="/t/a/?style=paper">t/a</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/t/a/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/b/?style=paper">b</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/b/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/coll/a/?style=paper">coll/a</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/coll/a/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/coll/a/.hg/patches/?style=paper">coll/a/.hg/patches</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/coll/a/.hg/patches/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/coll/b/?style=paper">coll/b</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/coll/b/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/coll/c/?style=paper">coll/c</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/coll/c/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/coll/notrepo/e/?style=paper">coll/notrepo/e</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/coll/notrepo/e/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/coll/notrepo/f/?style=paper">fancy name for repo f</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/coll/notrepo/f/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/rcoll/a/?style=paper">rcoll/a</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/rcoll/a/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/rcoll/a/.hg/patches/?style=paper">rcoll/a/.hg/patches</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/rcoll/a/.hg/patches/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/rcoll/b/?style=paper">rcoll/b</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/rcoll/b/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/rcoll/b/d/?style=paper">rcoll/b/d</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/rcoll/b/d/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/rcoll/c/?style=paper">rcoll/c</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/rcoll/c/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/rcoll/notrepo/e/?style=paper">rcoll/notrepo/e</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/rcoll/notrepo/e/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/rcoll/notrepo/e/e2/?style=paper">rcoll/notrepo/e/e2</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/rcoll/notrepo/e/e2/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/rcoll/notrepo/f/?style=paper">fancy name for repo f</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/rcoll/notrepo/f/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/rcoll/notrepo/f/f2/?style=paper">rcoll/notrepo/f/f2</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/rcoll/notrepo/f/f2/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/star/webdir/a/?style=paper">star/webdir/a</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/star/webdir/a/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/star/webdir/a/.hg/patches/?style=paper">star/webdir/a/.hg/patches</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/star/webdir/a/.hg/patches/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/star/webdir/b/?style=paper">star/webdir/b</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/star/webdir/b/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/star/webdir/c/?style=paper">star/webdir/c</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/star/webdir/c/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/star/webdir/notrepo/e/?style=paper">star/webdir/notrepo/e</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/star/webdir/notrepo/e/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/star/webdir/notrepo/f/?style=paper">fancy name for repo f</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/star/webdir/notrepo/f/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/starstar/webdir/a/?style=paper">starstar/webdir/a</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/starstar/webdir/a/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/starstar/webdir/a/.hg/patches/?style=paper">starstar/webdir/a/.hg/patches</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/starstar/webdir/a/.hg/patches/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/starstar/webdir/b/?style=paper">starstar/webdir/b</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/starstar/webdir/b/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/starstar/webdir/b/d/?style=paper">starstar/webdir/b/d</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/starstar/webdir/b/d/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/starstar/webdir/c/?style=paper">starstar/webdir/c</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/starstar/webdir/c/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/starstar/webdir/notrepo/e/?style=paper">starstar/webdir/notrepo/e</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/starstar/webdir/notrepo/e/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/starstar/webdir/notrepo/e/e2/?style=paper">starstar/webdir/notrepo/e/e2</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/starstar/webdir/notrepo/e/e2/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/starstar/webdir/notrepo/f/?style=paper">fancy name for repo f</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/starstar/webdir/notrepo/f/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/starstar/webdir/notrepo/f/f2/?style=paper">starstar/webdir/notrepo/f/f2</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/starstar/webdir/notrepo/f/f2/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/astar/?style=paper">astar</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/astar/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
   <tr>
   <td><a href="/astar/.hg/patches/?style=paper">astar/.hg/patches</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/astar/.hg/patches/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
       </tbody>
   </table>
   </div>
   </div>
   
   
   </body>
   </html>
   
   $ get-with-headers.py localhost:$HGPORT1 't?style=raw'
   200 Script output follows
   
   
   /t/a/
   
   $ get-with-headers.py localhost:$HGPORT1 't/?style=raw'
   200 Script output follows
   
   
   /t/a/
   
   $ get-with-headers.py localhost:$HGPORT1 't/?style=paper'
   200 Script output follows
   
   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
   <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
   <head>
   <link rel="icon" href="/static/hgicon.png" type="image/png" />
   <meta name="robots" content="index, nofollow" />
   <link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
   <script type="text/javascript" src="/static/mercurial.js"></script>
   
   <title>Mercurial repositories index</title>
   </head>
   <body>
   
   <div class="container">
   <div class="menu">
   <a href="https://mercurial-scm.org/">
   <img src="/static/hglogo.png" width=75 height=90 border=0 alt="mercurial" /></a>
   </div>
   <div class="main">
   <h2 class="breadcrumb"><a href="/">Mercurial</a> &gt; <a href="/t">t</a> </h2>
   
   <table class="bigtable">
       <thead>
       <tr>
           <th><a href="?sort=name">Name</a></th>
           <th><a href="?sort=description">Description</a></th>
           <th><a href="?sort=contact">Contact</a></th>
           <th><a href="?sort=lastchange">Last modified</a></th>
           <th>&nbsp;</th>
           <th>&nbsp;</th>
       </tr>
       </thead>
       <tbody class="stripes2">
       
   <tr>
   <td><a href="/t/a/?style=paper">a</a></td>
   <td>unknown</td>
   <td>&#70;&#111;&#111;&#32;&#66;&#97;&#114;&#32;&#60;&#102;&#111;&#111;&#46;&#98;&#97;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;&#62;</td>
   <td class="age">*</td> (glob)
   <td class="indexlinks"></td>
   <td>
   <a href="/t/a/atom-log" title="subscribe to repository atom feed">
   <img class="atom-logo" src="/static/feed-icon-14x14.png" alt="subscribe to repository atom feed">
   </a>
   </td>
   </tr>
   
       </tbody>
   </table>
   </div>
   </div>
   
   
   </body>
   </html>
   
   $ get-with-headers.py localhost:$HGPORT1 't/a?style=atom'
   200 Script output follows
   
   <?xml version="1.0" encoding="ascii"?>
   <feed xmlns="http://www.w3.org/2005/Atom">
    <!-- Changelog -->
    <id>http://*:$HGPORT1/t/a/</id> (glob)
    <link rel="self" href="http://*:$HGPORT1/t/a/atom-log"/> (glob)
    <link rel="alternate" href="http://*:$HGPORT1/t/a/"/> (glob)
    <title>t/a Changelog</title>
    <updated>1970-01-01T00:00:01+00:00</updated>
   
    <entry>
     <title>[default] a</title>
     <id>http://*:$HGPORT1/t/a/#changeset-8580ff50825a50c8f716709acdf8de0deddcd6ab</id> (glob)
     <link href="http://*:$HGPORT1/t/a/rev/8580ff50825a"/> (glob)
     <author>
      <name>test</name>
      <email>&#116;&#101;&#115;&#116;</email>
     </author>
     <updated>1970-01-01T00:00:01+00:00</updated>
     <published>1970-01-01T00:00:01+00:00</published>
     <content type="xhtml">
      <table xmlns="http://www.w3.org/1999/xhtml">
       <tr>
        <th style="text-align:left;">changeset</th>
        <td>8580ff50825a</td>
       </tr>
       <tr>
        <th style="text-align:left;">branch</th>
        <td>default</td>
       </tr>
       <tr>
        <th style="text-align:left;">bookmark</th>
        <td></td>
       </tr>
       <tr>
        <th style="text-align:left;">tag</th>
        <td>tip</td>
       </tr>
       <tr>
        <th style="text-align:left;">user</th>
        <td>&#116;&#101;&#115;&#116;</td>
       </tr>
       <tr>
        <th style="text-align:left;vertical-align:top;">description</th>
        <td>a</td>
       </tr>
       <tr>
        <th style="text-align:left;vertical-align:top;">files</th>
        <td>a<br /></td>
       </tr>
      </table>
     </content>
    </entry>
   
   </feed>
   $ get-with-headers.py localhost:$HGPORT1 't/a/?style=atom'
   200 Script output follows
   
   <?xml version="1.0" encoding="ascii"?>
   <feed xmlns="http://www.w3.org/2005/Atom">
    <!-- Changelog -->
    <id>http://*:$HGPORT1/t/a/</id> (glob)
    <link rel="self" href="http://*:$HGPORT1/t/a/atom-log"/> (glob)
    <link rel="alternate" href="http://*:$HGPORT1/t/a/"/> (glob)
    <title>t/a Changelog</title>
    <updated>1970-01-01T00:00:01+00:00</updated>
   
    <entry>
     <title>[default] a</title>
     <id>http://*:$HGPORT1/t/a/#changeset-8580ff50825a50c8f716709acdf8de0deddcd6ab</id> (glob)
     <link href="http://*:$HGPORT1/t/a/rev/8580ff50825a"/> (glob)
     <author>
      <name>test</name>
      <email>&#116;&#101;&#115;&#116;</email>
     </author>
     <updated>1970-01-01T00:00:01+00:00</updated>
     <published>1970-01-01T00:00:01+00:00</published>
     <content type="xhtml">
      <table xmlns="http://www.w3.org/1999/xhtml">
       <tr>
        <th style="text-align:left;">changeset</th>
        <td>8580ff50825a</td>
       </tr>
       <tr>
        <th style="text-align:left;">branch</th>
        <td>default</td>
       </tr>
       <tr>
        <th style="text-align:left;">bookmark</th>
        <td></td>
       </tr>
       <tr>
        <th style="text-align:left;">tag</th>
        <td>tip</td>
       </tr>
       <tr>
        <th style="text-align:left;">user</th>
        <td>&#116;&#101;&#115;&#116;</td>
       </tr>
       <tr>
        <th style="text-align:left;vertical-align:top;">description</th>
        <td>a</td>
       </tr>
       <tr>
        <th style="text-align:left;vertical-align:top;">files</th>
        <td>a<br /></td>
       </tr>
      </table>
     </content>
    </entry>
   
   </feed>
   $ get-with-headers.py localhost:$HGPORT1 't/a/file/tip/a?style=raw'
   200 Script output follows
   
   a
 
 Test [paths] '*' extension
 
   $ get-with-headers.py localhost:$HGPORT1 'coll/?style=raw'
   200 Script output follows
   
   
   /coll/a/
   /coll/a/.hg/patches/
   /coll/b/
   /coll/c/
   /coll/notrepo/e/
   /coll/notrepo/f/
   
   $ get-with-headers.py localhost:$HGPORT1 'coll/a/file/tip/a?style=raw'
   200 Script output follows
   
   a
 
 Test [paths] '**' extension
 
   $ get-with-headers.py localhost:$HGPORT1 'rcoll/?style=raw'
   200 Script output follows
   
   
   /rcoll/a/
   /rcoll/a/.hg/patches/
   /rcoll/b/
   /rcoll/b/d/
   /rcoll/c/
   /rcoll/notrepo/e/
   /rcoll/notrepo/e/e2/
   /rcoll/notrepo/f/
   /rcoll/notrepo/f/f2/
   
   $ get-with-headers.py localhost:$HGPORT1 'rcoll/b/d/file/tip/d?style=raw'
   200 Script output follows
   
   d
 
 Test collapse = True
 
   $ killdaemons.py
   $ cat >> paths.conf <<EOF
   > [web]
   > collapse=true
   > descend = true
   > EOF
   $ hg serve -p $HGPORT1 -d --pid-file=hg.pid --webdir-conf paths.conf \
   >     -A access-paths.log -E error-paths-3.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ get-with-headers.py localhost:$HGPORT1 'coll/?style=raw'
   200 Script output follows
   
   
   /coll/a/
   /coll/a/.hg/patches/
   /coll/b/
   /coll/c/
   /coll/notrepo/
   
   $ get-with-headers.py localhost:$HGPORT1 'coll/a/file/tip/a?style=raw'
   200 Script output follows
   
   a
   $ get-with-headers.py localhost:$HGPORT1 'rcoll/?style=raw'
   200 Script output follows
   
   
   /rcoll/a/
   /rcoll/a/.hg/patches/
   /rcoll/b/
   /rcoll/b/d/
   /rcoll/c/
   /rcoll/notrepo/
   
   $ get-with-headers.py localhost:$HGPORT1 'rcoll/b/d/file/tip/d?style=raw'
   200 Script output follows
   
   d
 
 Test intermediate directories
 
 Hide the subrepo parent
 
   $ cp $root/notrepo/f/.hg/hgrc $root/notrepo/f/.hg/hgrc.bak
   $ cat >> $root/notrepo/f/.hg/hgrc << EOF
   > [web]
   > hidden = True
   > EOF
 
   $ get-with-headers.py localhost:$HGPORT1 'rcoll/notrepo/?style=raw'
   200 Script output follows
   
   
   /rcoll/notrepo/e/
   /rcoll/notrepo/e/e2/
   
 
 Subrepo parent not hidden
   $ mv $root/notrepo/f/.hg/hgrc.bak $root/notrepo/f/.hg/hgrc
 
   $ get-with-headers.py localhost:$HGPORT1 'rcoll/notrepo/?style=raw'
   200 Script output follows
   
   
   /rcoll/notrepo/e/
   /rcoll/notrepo/e/e2/
   /rcoll/notrepo/f/
   /rcoll/notrepo/f/f2/
   
 
 Test repositories inside intermediate directories
 
   $ get-with-headers.py localhost:$HGPORT1 'rcoll/notrepo/e/file/tip/e?style=raw'
   200 Script output follows
   
   e
 
 Test subrepositories inside intermediate directories
 
   $ get-with-headers.py localhost:$HGPORT1 'rcoll/notrepo/f/f2/file/tip/f2?style=raw'
   200 Script output follows
   
   f2
 
 Test descend = False
 
   $ killdaemons.py
   $ cat >> paths.conf <<EOF
   > descend=false
   > EOF
   $ hg serve -p $HGPORT1 -d --pid-file=hg.pid --webdir-conf paths.conf \
   >     -A access-paths.log -E error-paths-4.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ get-with-headers.py localhost:$HGPORT1 'coll/?style=raw'
   200 Script output follows
   
   
   /coll/a/
   /coll/b/
   /coll/c/
   
   $ get-with-headers.py localhost:$HGPORT1 'coll/a/file/tip/a?style=raw'
   200 Script output follows
   
   a
   $ get-with-headers.py localhost:$HGPORT1 'rcoll/?style=raw'
   200 Script output follows
   
   
   /rcoll/a/
   /rcoll/b/
   /rcoll/c/
   
   $ get-with-headers.py localhost:$HGPORT1 'rcoll/b/d/file/tip/d?style=raw'
   200 Script output follows
   
   d
 
 Test intermediate directories
 
   $ get-with-headers.py localhost:$HGPORT1 'rcoll/notrepo/?style=raw'
   200 Script output follows
   
   
   /rcoll/notrepo/e/
   /rcoll/notrepo/f/
   
 
 Test repositories inside intermediate directories
 
   $ get-with-headers.py localhost:$HGPORT1 'rcoll/notrepo/e/file/tip/e?style=raw'
   200 Script output follows
   
   e
 
 Test subrepositories inside intermediate directories
 
   $ get-with-headers.py localhost:$HGPORT1 'rcoll/notrepo/f/f2/file/tip/f2?style=raw'
   200 Script output follows
   
   f2
 
 Test [paths] '*' in a repo root
 
   $ hg id http://localhost:$HGPORT1/astar
   8580ff50825a
 
   $ killdaemons.py
   $ cat > paths.conf <<EOF
   > [paths]
   > t/a = $root/a
   > t/b = $root/b
   > c = $root/c
   > EOF
   $ hg serve -p $HGPORT1 -d --pid-file=hg.pid --webdir-conf paths.conf \
   >     -A access-paths.log -E error-paths-5.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ get-with-headers.py localhost:$HGPORT1 '?style=raw'
   200 Script output follows
   
   
   /t/a/
   /t/b/
   /c/
   
   $ get-with-headers.py localhost:$HGPORT1 't/?style=raw'
   200 Script output follows
   
   
   /t/a/
   /t/b/
   
 
 Test collapse = True
 
   $ killdaemons.py
   $ cat >> paths.conf <<EOF
   > [web]
   > collapse=true
   > EOF
   $ hg serve -p $HGPORT1 -d --pid-file=hg.pid --webdir-conf paths.conf \
   >     -A access-paths.log -E error-paths-6.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ get-with-headers.py localhost:$HGPORT1 '?style=raw'
   200 Script output follows
   
   
   /t/
   /c/
   
   $ get-with-headers.py localhost:$HGPORT1 't/?style=raw'
   200 Script output follows
   
   
   /t/a/
   /t/b/
   
 
 test descend = False
 
   $ killdaemons.py
   $ cat >> paths.conf <<EOF
   > descend=false
   > EOF
   $ hg serve -p $HGPORT1 -d --pid-file=hg.pid --webdir-conf paths.conf \
   >     -A access-paths.log -E error-paths-7.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ get-with-headers.py localhost:$HGPORT1 '?style=raw'
   200 Script output follows
   
   
   /c/
   
   $ get-with-headers.py localhost:$HGPORT1 't/?style=raw'
   200 Script output follows
   
   
   /t/a/
   /t/b/
   
   $ killdaemons.py
   $ cat > paths.conf <<EOF
   > [paths]
   > nostore = $root/nostore
   > inexistent = $root/inexistent
   > EOF
   $ hg serve -p $HGPORT1 -d --pid-file=hg.pid --webdir-conf paths.conf \
   >     -A access-paths.log -E error-paths-8.log
   $ cat hg.pid >> $DAEMON_PIDS
 
 test inexistent and inaccessible repo should be ignored silently
 
   $ get-with-headers.py localhost:$HGPORT1 ''
   200 Script output follows
   
   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
   <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
   <head>
   <link rel="icon" href="/static/hgicon.png" type="image/png" />
   <meta name="robots" content="index, nofollow" />
   <link rel="stylesheet" href="/static/style-paper.css" type="text/css" />
   <script type="text/javascript" src="/static/mercurial.js"></script>
   
   <title>Mercurial repositories index</title>
   </head>
   <body>
   
   <div class="container">
   <div class="menu">
   <a href="https://mercurial-scm.org/">
   <img src="/static/hglogo.png" width=75 height=90 border=0 alt="mercurial" /></a>
   </div>
   <div class="main">
   <h2 class="breadcrumb"><a href="/">Mercurial</a> </h2>
   
   <table class="bigtable">
       <thead>
       <tr>
           <th><a href="?sort=name">Name</a></th>
           <th><a href="?sort=description">Description</a></th>
           <th><a href="?sort=contact">Contact</a></th>
           <th><a href="?sort=lastchange">Last modified</a></th>
           <th>&nbsp;</th>
           <th>&nbsp;</th>
       </tr>
       </thead>
       <tbody class="stripes2">
       
       </tbody>
   </table>
   </div>
   </div>
   
   
   </body>
   </html>
   
 
 test listening address/port specified by web-conf (issue4699):
 
   $ killdaemons.py
   $ cat >> paths.conf <<EOF
   > [web]
   > address = localhost
   > port = $HGPORT1
   > EOF
   $ hg serve -d --pid-file=hg.pid --web-conf paths.conf \
   >     -A access-paths.log -E error-paths-9.log
   listening at http://*:$HGPORT1/ (bound to *$LOCALIP*:$HGPORT1) (glob) (?)
   $ cat hg.pid >> $DAEMON_PIDS
   $ get-with-headers.py localhost:$HGPORT1 '?style=raw'
   200 Script output follows
   
   
   
 test --port option overrides web.port:
 
   $ killdaemons.py
   $ hg serve -p $HGPORT2 -d -v --pid-file=hg.pid --web-conf paths.conf \
   >     -A access-paths.log -E error-paths-10.log
   listening at http://*:$HGPORT2/ (bound to *$LOCALIP*:$HGPORT2) (glob) (?)
   $ cat hg.pid >> $DAEMON_PIDS
   $ get-with-headers.py localhost:$HGPORT2 '?style=raw'
   200 Script output follows
   
   
   
 
   $ killdaemons.py
   $ cat > collections.conf <<EOF
   > [collections]
   > $root=$root
   > EOF
   $ hg serve --config web.baseurl=http://hg.example.com:8080/ -p $HGPORT2 -d \
   >     --pid-file=hg.pid --webdir-conf collections.conf \
   >     -A access-collections.log -E error-collections.log
   $ cat hg.pid >> $DAEMON_PIDS
 
 collections: should succeed
 
   $ get-with-headers.py localhost:$HGPORT2 '?style=raw'
   200 Script output follows
   
   
   /a/
   /a/.hg/patches/
   /b/
   /c/
   /notrepo/e/
   /notrepo/f/
   
   $ get-with-headers.py localhost:$HGPORT2 'a/file/tip/a?style=raw'
   200 Script output follows
   
   a
   $ get-with-headers.py localhost:$HGPORT2 'b/file/tip/b?style=raw'
   200 Script output follows
   
   b
   $ get-with-headers.py localhost:$HGPORT2 'c/file/tip/c?style=raw'
   200 Script output follows
   
   c
 
 atom-log with basedir /
 
   $ get-with-headers.py localhost:$HGPORT2 'a/atom-log' | grep '<link'
    <link rel="self" href="http://hg.example.com:8080/a/atom-log"/>
    <link rel="alternate" href="http://hg.example.com:8080/a/"/>
     <link href="http://hg.example.com:8080/a/rev/8580ff50825a"/>
 
 rss-log with basedir /
 
   $ get-with-headers.py localhost:$HGPORT2 'a/rss-log' | grep '<guid'
       <guid isPermaLink="true">http://hg.example.com:8080/a/rev/8580ff50825a</guid>
   $ killdaemons.py
   $ hg serve --config web.baseurl=http://hg.example.com:8080/foo/ -p $HGPORT2 -d \
   >     --pid-file=hg.pid --webdir-conf collections.conf \
   >     -A access-collections-2.log -E error-collections-2.log
   $ cat hg.pid >> $DAEMON_PIDS
 
 atom-log with basedir /foo/
 
   $ get-with-headers.py localhost:$HGPORT2 'a/atom-log' | grep '<link'
    <link rel="self" href="http://hg.example.com:8080/foo/a/atom-log"/>
    <link rel="alternate" href="http://hg.example.com:8080/foo/a/"/>
     <link href="http://hg.example.com:8080/foo/a/rev/8580ff50825a"/>
 
 rss-log with basedir /foo/
 
   $ get-with-headers.py localhost:$HGPORT2 'a/rss-log' | grep '<guid'
       <guid isPermaLink="true">http://hg.example.com:8080/foo/a/rev/8580ff50825a</guid>
 
 Path refreshing works as expected
 
   $ killdaemons.py
   $ mkdir $root/refreshtest
   $ hg init $root/refreshtest/a
   $ cat > paths.conf << EOF
   > [paths]
   > / = $root/refreshtest/*
   > EOF
   $ hg serve -p $HGPORT1 -d --pid-file hg.pid --webdir-conf paths.conf
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ get-with-headers.py localhost:$HGPORT1 '?style=raw'
   200 Script output follows
   
   
   /a/
   
 
 By default refreshing occurs every 20s and a new repo won't be listed
 immediately.
 
   $ hg init $root/refreshtest/b
   $ get-with-headers.py localhost:$HGPORT1 '?style=raw'
   200 Script output follows
   
   
   /a/
   
 
 Restart the server with no refresh interval. New repo should appear
 immediately.
 
   $ killdaemons.py
   $ cat > paths.conf << EOF
   > [web]
   > refreshinterval = -1
   > [paths]
   > / = $root/refreshtest/*
   > EOF
   $ hg serve -p $HGPORT1 -d --pid-file hg.pid --webdir-conf paths.conf
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ get-with-headers.py localhost:$HGPORT1 '?style=raw'
   200 Script output follows
   
   
   /a/
   /b/
   
 
   $ hg init $root/refreshtest/c
   $ get-with-headers.py localhost:$HGPORT1 '?style=raw'
   200 Script output follows
   
   
   /a/
   /b/
   /c/
   
   $ killdaemons.py
   $ cat > paths.conf << EOF
   > [paths]
   > /dir1/a_repo = $root/a
   > /dir1/a_repo/b_repo = $root/b
   > /dir1/dir2/index = $root/b
   > EOF
   $ hg serve -p $HGPORT1 -d --pid-file hg.pid --webdir-conf paths.conf
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ echo 'index file' > $root/a/index
   $ hg --cwd $root/a ci -Am 'add index file'
   adding index
 
   $ get-with-headers.py localhost:$HGPORT1 '' | grep 'a_repo'
   <td><a href="/dir1/a_repo/">dir1/a_repo</a></td>
   <a href="/dir1/a_repo/atom-log" title="subscribe to repository atom feed">
   <td><a href="/dir1/a_repo/b_repo/">dir1/a_repo/b_repo</a></td>
   <a href="/dir1/a_repo/b_repo/atom-log" title="subscribe to repository atom feed">
 
   $ get-with-headers.py localhost:$HGPORT1 'index' | grep 'a_repo'
   <td><a href="/dir1/a_repo/">dir1/a_repo</a></td>
   <a href="/dir1/a_repo/atom-log" title="subscribe to repository atom feed">
   <td><a href="/dir1/a_repo/b_repo/">dir1/a_repo/b_repo</a></td>
   <a href="/dir1/a_repo/b_repo/atom-log" title="subscribe to repository atom feed">
 
   $ get-with-headers.py localhost:$HGPORT1 'dir1' | grep 'a_repo'
   <td><a href="/dir1/a_repo/">a_repo</a></td>
   <a href="/dir1/a_repo/atom-log" title="subscribe to repository atom feed">
   <td><a href="/dir1/a_repo/b_repo/">a_repo/b_repo</a></td>
   <a href="/dir1/a_repo/b_repo/atom-log" title="subscribe to repository atom feed">
 
   $ get-with-headers.py localhost:$HGPORT1 'dir1/index' | grep 'a_repo'
   <td><a href="/dir1/a_repo/">a_repo</a></td>
   <a href="/dir1/a_repo/atom-log" title="subscribe to repository atom feed">
   <td><a href="/dir1/a_repo/b_repo/">a_repo/b_repo</a></td>
   <a href="/dir1/a_repo/b_repo/atom-log" title="subscribe to repository atom feed">
 
   $ get-with-headers.py localhost:$HGPORT1 'dir1/a_repo' | grep 'a_repo'
   <link rel="icon" href="/dir1/a_repo/static/hgicon.png" type="image/png" />
   <link rel="stylesheet" href="/dir1/a_repo/static/style-paper.css" type="text/css" />
   <script type="text/javascript" src="/dir1/a_repo/static/mercurial.js"></script>
   <title>dir1/a_repo: log</title>
      href="/dir1/a_repo/atom-log" title="Atom feed for dir1/a_repo" />
      href="/dir1/a_repo/rss-log" title="RSS feed for dir1/a_repo" />
   <img src="/dir1/a_repo/static/hglogo.png" alt="mercurial" /></a>
   <li><a href="/dir1/a_repo/graph/tip">graph</a></li>
   <li><a href="/dir1/a_repo/tags">tags</a></li>
   <li><a href="/dir1/a_repo/bookmarks">bookmarks</a></li>
   <li><a href="/dir1/a_repo/branches">branches</a></li>
   <li><a href="/dir1/a_repo/rev/tip">changeset</a></li>
   <li><a href="/dir1/a_repo/file/tip">browse</a></li>
    <li><a href="/dir1/a_repo/help">help</a></li>
   <a href="/dir1/a_repo/atom-log" title="subscribe to atom feed">
   <img class="atom-logo" src="/dir1/a_repo/static/feed-icon-14x14.png" alt="atom feed" />
   <h2 class="breadcrumb"><a href="/">Mercurial</a> &gt; <a href="/dir1">dir1</a> &gt; <a href="/dir1/a_repo">a_repo</a> </h2>
   <form class="search" action="/dir1/a_repo/log">
   number or hash, or <a href="/dir1/a_repo/help/revsets">revset expression</a>.</div>
   <a href="/dir1/a_repo/shortlog/tip?revcount=30">less</a>
   <a href="/dir1/a_repo/shortlog/tip?revcount=120">more</a>
   | rev 1: <a href="/dir1/a_repo/shortlog/8580ff50825a">(0)</a> <a href="/dir1/a_repo/shortlog/tip">tip</a> 
      <a href="/dir1/a_repo/rev/71a89161f014">add index file</a>
      <a href="/dir1/a_repo/rev/8580ff50825a">a</a>
   <a href="/dir1/a_repo/shortlog/tip?revcount=30">less</a>
   <a href="/dir1/a_repo/shortlog/tip?revcount=120">more</a>
   | rev 1: <a href="/dir1/a_repo/shortlog/8580ff50825a">(0)</a> <a href="/dir1/a_repo/shortlog/tip">tip</a> 
               '/dir1/a_repo/shortlog/%next%',
 
   $ get-with-headers.py localhost:$HGPORT1 'dir1/a_repo/index' | grep 'a_repo'
   <h2 class="breadcrumb"><a href="/">Mercurial</a> &gt; <a href="/dir1">dir1</a> &gt; <a href="/dir1/a_repo">a_repo</a> </h2>
   <td><a href="/dir1/a_repo/b_repo/">b_repo</a></td>
   <a href="/dir1/a_repo/b_repo/atom-log" title="subscribe to repository atom feed">
 
 Files named 'index' are not blocked
 
   $ get-with-headers.py localhost:$HGPORT1 'dir1/a_repo/raw-file/tip/index'
   200 Script output follows
   
   index file
 
 Repos named 'index' take precedence over the index file
 
   $ get-with-headers.py localhost:$HGPORT1 'dir1/dir2/index' | grep 'index'
   <link rel="icon" href="/dir1/dir2/index/static/hgicon.png" type="image/png" />
   <meta name="robots" content="index, nofollow" />
   <link rel="stylesheet" href="/dir1/dir2/index/static/style-paper.css" type="text/css" />
   <script type="text/javascript" src="/dir1/dir2/index/static/mercurial.js"></script>
   <title>dir1/dir2/index: log</title>
      href="/dir1/dir2/index/atom-log" title="Atom feed for dir1/dir2/index" />
      href="/dir1/dir2/index/rss-log" title="RSS feed for dir1/dir2/index" />
   <img src="/dir1/dir2/index/static/hglogo.png" alt="mercurial" /></a>
   <li><a href="/dir1/dir2/index/graph/tip">graph</a></li>
   <li><a href="/dir1/dir2/index/tags">tags</a></li>
   <li><a href="/dir1/dir2/index/bookmarks">bookmarks</a></li>
   <li><a href="/dir1/dir2/index/branches">branches</a></li>
   <li><a href="/dir1/dir2/index/rev/tip">changeset</a></li>
   <li><a href="/dir1/dir2/index/file/tip">browse</a></li>
    <li><a href="/dir1/dir2/index/help">help</a></li>
   <a href="/dir1/dir2/index/atom-log" title="subscribe to atom feed">
   <img class="atom-logo" src="/dir1/dir2/index/static/feed-icon-14x14.png" alt="atom feed" />
   <h2 class="breadcrumb"><a href="/">Mercurial</a> &gt; <a href="/dir1">dir1</a> &gt; <a href="/dir1/dir2">dir2</a> &gt; <a href="/dir1/dir2/index">index</a> </h2>
   <form class="search" action="/dir1/dir2/index/log">
   number or hash, or <a href="/dir1/dir2/index/help/revsets">revset expression</a>.</div>
   <a href="/dir1/dir2/index/shortlog/tip?revcount=30">less</a>
   <a href="/dir1/dir2/index/shortlog/tip?revcount=120">more</a>
   | rev 0: <a href="/dir1/dir2/index/shortlog/39505516671b">(0)</a> <a href="/dir1/dir2/index/shortlog/tip">tip</a> 
      <a href="/dir1/dir2/index/rev/39505516671b">b</a>
   <a href="/dir1/dir2/index/shortlog/tip?revcount=30">less</a>
   <a href="/dir1/dir2/index/shortlog/tip?revcount=120">more</a>
   | rev 0: <a href="/dir1/dir2/index/shortlog/39505516671b">(0)</a> <a href="/dir1/dir2/index/shortlog/tip">tip</a> 
               '/dir1/dir2/index/shortlog/%next%',
 
   $ killdaemons.py
 
+  $ cat > paths.conf << EOF
+  > [paths]
+  > / = $root/a
+  > EOF
+  $ hg serve -p $HGPORT1 -d --pid-file hg.pid --webdir-conf paths.conf
+  $ cat hg.pid >> $DAEMON_PIDS
+
+  $ hg id http://localhost:$HGPORT1
+  71a89161f014
+
+  $ get-with-headers.py localhost:$HGPORT1 '' | grep 'index'
+  <meta name="robots" content="index, nofollow" />
+     <a href="/rev/71a89161f014">add index file</a>
+
+  $ killdaemons.py
+
 paths errors 1
 
   $ cat error-paths-1.log
 
 paths errors 2
 
   $ cat error-paths-2.log
 
 paths errors 3
 
   $ cat error-paths-3.log
 
 paths errors 4
 
   $ cat error-paths-4.log
 
 paths errors 5
 
   $ cat error-paths-5.log
 
 paths errors 6
 
   $ cat error-paths-6.log
 
 paths errors 7
 
   $ cat error-paths-7.log
 
 paths errors 8
 
   $ cat error-paths-8.log
 
 paths errors 9
 
   $ cat error-paths-9.log
 
 paths errors 10
 
   $ cat error-paths-10.log
 
 collections errors
 
   $ cat error-collections.log
 
 collections errors 2
 
   $ cat error-collections-2.log