This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2822

hgweb: support constructing URLs from an alternate base URL
ClosedPublic

Authored by indygreg on Mar 12 2018, 5:16 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG219b23359f4c: hgweb: support constructing URLs from an alternate base URL
Summary

The web.baseurl config option allows server operators to define a
custom URL for hosted content.

The way it works today is that hgwebdir parses this config
option into URL components then updates the appropriate
WSGI environment variables so the request "lies" about its
details. For example, SERVER_NAME is updated to reflect the
alternate base URL's hostname.

The WSGI environment should not be modified because WSGI
applications may want to know the original request details (for
debugging, etc).

This commit teaches our request parser about the existence of
an alternate base URL. If defined, the advertised URL and other
self-reflected paths will take the alternate base URL into account.

The hgweb WSGI application didn't use web.baseurl. But hgwebdir
did. We update hgwebdir to alter the environment parsing
accordingly. The old code around environment manipulation
has been removed.

With this change, parserequestfromenv() has grown to a bit
unwieldy. Now that practically everyone is using it, it is
obvious that there is some unused features that can be trimmed.
So look for this in follow-up commits.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Mar 12 2018, 5:16 PM
durin42 accepted this revision.Mar 12 2018, 5:30 PM
This revision is now accepted and ready to land.Mar 12 2018, 5:30 PM
Closed by commit rHG219b23359f4c: hgweb: support constructing URLs from an alternate base URL (authored by indygreg). · Explain WhyMar 12 2018, 5:38 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 6888

mercurial/hgweb/hgwebdir_mod.py

) )
from .. import ( from .. import (
configitems, configitems,
encoding, encoding,
error, error,
hg, hg,
profiling, profiling,
pycompat,
scmutil, scmutil,
templater, templater,
ui as uimod, ui as uimod,
util, util,
) )
from . import ( from . import (
hgweb_mod, hgweb_mod,
>>> conv(urlrepos(b'', b'/opt', [b'/opt/r', b'/opt/r/r', b'/opt'])) >>> conv(urlrepos(b'', b'/opt', [b'/opt/r', b'/opt/r/r', b'/opt']))
[('r', '/opt/r'), ('r/r', '/opt/r/r'), ('', '/opt')] [('r', '/opt/r'), ('r/r', '/opt/r/r'), ('', '/opt')]
""" """
for path in paths: for path in paths:
path = os.path.normpath(path) path = os.path.normpath(path)
yield (prefix + '/' + yield (prefix + '/' +
util.pconvert(path[len(roothead):]).lstrip('/')).strip('/'), path util.pconvert(path[len(roothead):]).lstrip('/')).strip('/'), path
def geturlcgivars(baseurl, port):
"""
Extract CGI variables from baseurl
>>> geturlcgivars(b"http://host.org/base", b"80")
('host.org', '80', '/base')
>>> geturlcgivars(b"http://host.org:8000/base", b"80")
('host.org', '8000', '/base')
>>> geturlcgivars(b'/base', 8000)
('', '8000', '/base')
>>> geturlcgivars(b"base", b'8000')
('', '8000', '/base')
>>> geturlcgivars(b"http://host", b'8000')
('host', '8000', '/')
>>> geturlcgivars(b"http://host/", b'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, pycompat.bytestr(port), path
def readallowed(ui, req): def readallowed(ui, req):
"""Check allow_read and deny_read config options of a repo's ui object """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 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 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 can be denied read access: (1) deny_read is not empty, and the
user is unauthenticated or deny_read contains user (or *), and (2) 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 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.""" if user is allowed to read the repo, else return False."""
self.repos = repos self.repos = repos
self.ui = u self.ui = u
encoding.encoding = self.ui.config('web', 'encoding') encoding.encoding = self.ui.config('web', 'encoding')
self.style = self.ui.config('web', 'style') self.style = self.ui.config('web', 'style')
self.templatepath = self.ui.config('web', 'templates', untrusted=False) self.templatepath = self.ui.config('web', 'templates', untrusted=False)
self.stripecount = self.ui.config('web', 'stripes') self.stripecount = self.ui.config('web', 'stripes')
if self.stripecount: if self.stripecount:
self.stripecount = int(self.stripecount) self.stripecount = int(self.stripecount)
self._baseurl = self.ui.config('web', 'baseurl')
prefix = self.ui.config('web', 'prefix') prefix = self.ui.config('web', 'prefix')
if prefix.startswith('/'): if prefix.startswith('/'):
prefix = prefix[1:] prefix = prefix[1:]
if prefix.endswith('/'): if prefix.endswith('/'):
prefix = prefix[:-1] prefix = prefix[:-1]
self.prefix = prefix self.prefix = prefix
self.lastrefresh = time.time() self.lastrefresh = time.time()
def run(self): def run(self):
if not encoding.environ.get('GATEWAY_INTERFACE', if not encoding.environ.get('GATEWAY_INTERFACE',
'').startswith("CGI/1."): '').startswith("CGI/1."):
raise RuntimeError("This function is only intended to be " raise RuntimeError("This function is only intended to be "
"called while running as a CGI script.") "called while running as a CGI script.")
wsgicgi.launch(self) wsgicgi.launch(self)
def __call__(self, env, respond): def __call__(self, env, respond):
wsgireq = requestmod.wsgirequest(env, respond) baseurl = self.ui.config('web', 'baseurl')
wsgireq = requestmod.wsgirequest(env, respond, altbaseurl=baseurl)
return self.run_wsgi(wsgireq) return self.run_wsgi(wsgireq)
def run_wsgi(self, wsgireq): def run_wsgi(self, wsgireq):
profile = self.ui.configbool('profiling', 'enabled') profile = self.ui.configbool('profiling', 'enabled')
with profiling.profile(self.ui, enabled=profile): with profiling.profile(self.ui, enabled=profile):
for r in self._runwsgi(wsgireq): for r in self._runwsgi(wsgireq):
yield r yield r
yield '' yield ''
for virtualrepo in _virtualdirs(): for virtualrepo in _virtualdirs():
real = repos.get(virtualrepo) real = repos.get(virtualrepo)
if real: if real:
# Re-parse the WSGI environment to take into account our # Re-parse the WSGI environment to take into account our
# repository path component. # repository path component.
wsgireq.req = requestmod.parserequestfromenv( wsgireq.req = requestmod.parserequestfromenv(
wsgireq.env, wsgireq.req.bodyfh, reponame=virtualrepo) wsgireq.env, wsgireq.req.bodyfh, reponame=virtualrepo,
altbaseurl=self.ui.config('web', 'baseurl'))
try: try:
# ensure caller gets private copy of ui # ensure caller gets private copy of ui
repo = hg.repository(self.ui.copy(), real) repo = hg.repository(self.ui.copy(), real)
return hgweb_mod.hgweb(repo).run_wsgi(wsgireq) return hgweb_mod.hgweb(repo).run_wsgi(wsgireq)
except IOError as inst: except IOError as inst:
msg = encoding.strtolocal(inst.strerror) msg = encoding.strtolocal(inst.strerror)
raise ErrorResponse(HTTP_SERVER_ERROR, msg) raise ErrorResponse(HTTP_SERVER_ERROR, msg)
except error.RepoError as inst: except error.RepoError as inst:
sortcolumn = "" sortcolumn = ""
sort = [("sort_%s" % column, sort = [("sort_%s" % column,
"%s%s" % ((not descending and column == sortcolumn) "%s%s" % ((not descending and column == sortcolumn)
and "-" or "", column)) and "-" or "", column))
for column in sortable] for column in sortable]
self.refresh() self.refresh()
self.updatereqenv(wsgireq.env)
entries = indexentries(self.ui, self.repos, wsgireq, req, entries = indexentries(self.ui, self.repos, wsgireq, req,
self.stripecount, sortcolumn=sortcolumn, self.stripecount, sortcolumn=sortcolumn,
descending=descending, subdir=subdir) descending=descending, subdir=subdir)
return tmpl("index", entries=entries, subdir=subdir, return tmpl("index", entries=entries, subdir=subdir,
pathdef=hgweb_mod.makebreadcrumb('/' + subdir, self.prefix), pathdef=hgweb_mod.makebreadcrumb('/' + subdir, self.prefix),
sortcolumn=sortcolumn, descending=descending, sortcolumn=sortcolumn, descending=descending,
**dict(sort)) **dict(sort))
def templater(self, wsgireq, nonce): def templater(self, wsgireq, nonce):
def motd(**map): def motd(**map):
if self.motd is not None: if self.motd is not None:
yield self.motd yield self.motd
else: else:
yield config('web', 'motd') yield config('web', 'motd')
def config(section, name, default=uimod._unset, untrusted=True): def config(section, name, default=uimod._unset, untrusted=True):
return self.ui.config(section, name, default, untrusted) return self.ui.config(section, name, default, untrusted)
self.updatereqenv(wsgireq.env)
url = wsgireq.env.get('SCRIPT_NAME', '') url = wsgireq.env.get('SCRIPT_NAME', '')
if not url.endswith('/'): if not url.endswith('/'):
url += '/' url += '/'
vars = {} vars = {}
styles, (style, mapfile) = hgweb_mod.getstyle(wsgireq.req, config, styles, (style, mapfile) = hgweb_mod.getstyle(wsgireq.req, config,
self.templatepath) self.templatepath)
if style == styles[0]: if style == styles[0]:
"logoimg": logoimg, "logoimg": logoimg,
"staticurl": staticurl, "staticurl": staticurl,
"sessionvars": sessionvars, "sessionvars": sessionvars,
"style": style, "style": style,
"nonce": nonce, "nonce": nonce,
} }
tmpl = templater.templater.frommapfile(mapfile, defaults=defaults) tmpl = templater.templater.frommapfile(mapfile, defaults=defaults)
return tmpl return tmpl
def updatereqenv(self, env):
if self._baseurl is not None:
name, port, path = geturlcgivars(self._baseurl, env['SERVER_PORT'])
env['SERVER_NAME'] = name
env['SERVER_PORT'] = port
env['SCRIPT_NAME'] = path

mercurial/hgweb/request.py

# multidict of query string parameters. # multidict of query string parameters.
qsparams = attr.ib() qsparams = attr.ib()
# wsgiref.headers.Headers instance. Operates like a dict with case # wsgiref.headers.Headers instance. Operates like a dict with case
# insensitive keys. # insensitive keys.
headers = attr.ib() headers = attr.ib()
# Request body input stream. # Request body input stream.
bodyfh = attr.ib() bodyfh = attr.ib()
def parserequestfromenv(env, bodyfh, reponame=None): def parserequestfromenv(env, bodyfh, reponame=None, altbaseurl=None):
"""Parse URL components from environment variables. """Parse URL components from environment variables.
WSGI defines request attributes via environment variables. This function WSGI defines request attributes via environment variables. This function
parses the environment variables into a data structure. parses the environment variables into a data structure.
If ``reponame`` is defined, the leading path components matching that If ``reponame`` is defined, the leading path components matching that
string are effectively shifted from ``PATH_INFO`` to ``SCRIPT_NAME``. string are effectively shifted from ``PATH_INFO`` to ``SCRIPT_NAME``.
This simulates the world view of a WSGI application that processes This simulates the world view of a WSGI application that processes
requests from the base URL of a repo. requests from the base URL of a repo.
If ``altbaseurl`` (typically comes from ``web.baseurl`` config option)
is defined, it is used - instead of the WSGI environment variables - for
constructing URL components up to and including the WSGI application path.
For example, if the current WSGI application is at ``/repo`` and a request
is made to ``/rev/@`` with this argument set to
``http://myserver:9000/prefix``, the URL and path components will resolve as
if the request were to ``http://myserver:9000/prefix/rev/@``. In other
words, ``wsgi.url_scheme``, ``SERVER_NAME``, ``SERVER_PORT``, and
``SCRIPT_NAME`` are all effectively replaced by components from this URL.
""" """
# PEP-0333 defines the WSGI spec and is a useful reference for this code. # PEP 3333 defines the WSGI spec and is a useful reference for this code.
# We first validate that the incoming object conforms with the WSGI spec. # We first validate that the incoming object conforms with the WSGI spec.
# We only want to be dealing with spec-conforming WSGI implementations. # We only want to be dealing with spec-conforming WSGI implementations.
# TODO enable this once we fix internal violations. # TODO enable this once we fix internal violations.
#wsgiref.validate.check_environ(env) #wsgiref.validate.check_environ(env)
# PEP-0333 states that environment keys and values are native strings # PEP-0333 states that environment keys and values are native strings
# (bytes on Python 2 and str on Python 3). The code points for the Unicode # (bytes on Python 2 and str on Python 3). The code points for the Unicode
# strings on Python 3 must be between \00000-\000FF. We deal with bytes # strings on Python 3 must be between \00000-\000FF. We deal with bytes
# in Mercurial, so mass convert string keys and values to bytes. # in Mercurial, so mass convert string keys and values to bytes.
if pycompat.ispy3: if pycompat.ispy3:
env = {k.encode('latin-1'): v for k, v in env.iteritems()} env = {k.encode('latin-1'): v for k, v in env.iteritems()}
env = {k: v.encode('latin-1') if isinstance(v, str) else v env = {k: v.encode('latin-1') if isinstance(v, str) else v
for k, v in env.iteritems()} for k, v in env.iteritems()}
if altbaseurl:
altbaseurl = util.url(altbaseurl)
# https://www.python.org/dev/peps/pep-0333/#environ-variables defines # https://www.python.org/dev/peps/pep-0333/#environ-variables defines
# the environment variables. # the environment variables.
# https://www.python.org/dev/peps/pep-0333/#url-reconstruction defines # https://www.python.org/dev/peps/pep-0333/#url-reconstruction defines
# how URLs are reconstructed. # how URLs are reconstructed.
fullurl = env['wsgi.url_scheme'] + '://' fullurl = env['wsgi.url_scheme'] + '://'
if altbaseurl and altbaseurl.scheme:
advertisedfullurl = altbaseurl.scheme + '://'
else:
advertisedfullurl = fullurl advertisedfullurl = fullurl
def addport(s): def addport(s, port):
if env['wsgi.url_scheme'] == 'https': if s.startswith('https://'):
if env['SERVER_PORT'] != '443': if port != '443':
s += ':' + env['SERVER_PORT'] s += ':' + port
else: else:
if env['SERVER_PORT'] != '80': if port != '80':
s += ':' + env['SERVER_PORT'] s += ':' + port
return s return s
if env.get('HTTP_HOST'): if env.get('HTTP_HOST'):
fullurl += env['HTTP_HOST'] fullurl += env['HTTP_HOST']
else: else:
fullurl += env['SERVER_NAME'] fullurl += env['SERVER_NAME']
fullurl = addport(fullurl) fullurl = addport(fullurl, env['SERVER_PORT'])
if altbaseurl and altbaseurl.host:
advertisedfullurl += altbaseurl.host
if altbaseurl.port:
port = altbaseurl.port
elif altbaseurl.scheme == 'http' and not altbaseurl.port:
port = '80'
elif altbaseurl.scheme == 'https' and not altbaseurl.port:
port = '443'
else:
port = env['SERVER_PORT']
advertisedfullurl = addport(advertisedfullurl, port)
else:
advertisedfullurl += env['SERVER_NAME'] advertisedfullurl += env['SERVER_NAME']
advertisedfullurl = addport(advertisedfullurl) advertisedfullurl = addport(advertisedfullurl, env['SERVER_PORT'])
baseurl = fullurl baseurl = fullurl
advertisedbaseurl = advertisedfullurl advertisedbaseurl = advertisedfullurl
fullurl += util.urlreq.quote(env.get('SCRIPT_NAME', '')) fullurl += util.urlreq.quote(env.get('SCRIPT_NAME', ''))
advertisedfullurl += util.urlreq.quote(env.get('SCRIPT_NAME', ''))
fullurl += util.urlreq.quote(env.get('PATH_INFO', '')) fullurl += util.urlreq.quote(env.get('PATH_INFO', ''))
if altbaseurl:
path = altbaseurl.path or ''
if path and not path.startswith('/'):
path = '/' + path
advertisedfullurl += util.urlreq.quote(path)
else:
advertisedfullurl += util.urlreq.quote(env.get('SCRIPT_NAME', ''))
advertisedfullurl += util.urlreq.quote(env.get('PATH_INFO', '')) advertisedfullurl += util.urlreq.quote(env.get('PATH_INFO', ''))
if env.get('QUERY_STRING'): if env.get('QUERY_STRING'):
fullurl += '?' + env['QUERY_STRING'] fullurl += '?' + env['QUERY_STRING']
advertisedfullurl += '?' + env['QUERY_STRING'] advertisedfullurl += '?' + env['QUERY_STRING']
# If ``reponame`` is defined, that must be a prefix on PATH_INFO # If ``reponame`` is defined, that must be a prefix on PATH_INFO
# that represents the repository being dispatched to. When computing # that represents the repository being dispatched to. When computing
# the dispatch info, we ignore these leading path components. # the dispatch info, we ignore these leading path components.
if altbaseurl:
apppath = altbaseurl.path or ''
if apppath and not apppath.startswith('/'):
apppath = '/' + apppath
else:
apppath = env.get('SCRIPT_NAME', '') apppath = env.get('SCRIPT_NAME', '')
if reponame: if reponame:
repoprefix = '/' + reponame.strip('/') repoprefix = '/' + reponame.strip('/')
if not env.get('PATH_INFO'): if not env.get('PATH_INFO'):
raise error.ProgrammingError('reponame requires PATH_INFO') raise error.ProgrammingError('reponame requires PATH_INFO')
if not env['PATH_INFO'].startswith(repoprefix): if not env['PATH_INFO'].startswith(repoprefix):
class wsgirequest(object): class wsgirequest(object):
"""Higher-level API for a WSGI request. """Higher-level API for a WSGI request.
WSGI applications are invoked with 2 arguments. They are used to WSGI applications are invoked with 2 arguments. They are used to
instantiate instances of this class, which provides higher-level APIs instantiate instances of this class, which provides higher-level APIs
for obtaining request parameters, writing HTTP output, etc. for obtaining request parameters, writing HTTP output, etc.
""" """
def __init__(self, wsgienv, start_response): def __init__(self, wsgienv, start_response, altbaseurl=None):
version = wsgienv[r'wsgi.version'] version = wsgienv[r'wsgi.version']
if (version < (1, 0)) or (version >= (2, 0)): if (version < (1, 0)) or (version >= (2, 0)):
raise RuntimeError("Unknown and unsupported WSGI version %d.%d" raise RuntimeError("Unknown and unsupported WSGI version %d.%d"
% version) % version)
inp = wsgienv[r'wsgi.input'] inp = wsgienv[r'wsgi.input']
if r'HTTP_CONTENT_LENGTH' in wsgienv: if r'HTTP_CONTENT_LENGTH' in wsgienv:
inp = util.cappedreader(inp, int(wsgienv[r'HTTP_CONTENT_LENGTH'])) inp = util.cappedreader(inp, int(wsgienv[r'HTTP_CONTENT_LENGTH']))
elif r'CONTENT_LENGTH' in wsgienv: elif r'CONTENT_LENGTH' in wsgienv:
inp = util.cappedreader(inp, int(wsgienv[r'CONTENT_LENGTH'])) inp = util.cappedreader(inp, int(wsgienv[r'CONTENT_LENGTH']))
self.err = wsgienv[r'wsgi.errors'] self.err = wsgienv[r'wsgi.errors']
self.threaded = wsgienv[r'wsgi.multithread'] self.threaded = wsgienv[r'wsgi.multithread']
self.multiprocess = wsgienv[r'wsgi.multiprocess'] self.multiprocess = wsgienv[r'wsgi.multiprocess']
self.run_once = wsgienv[r'wsgi.run_once'] self.run_once = wsgienv[r'wsgi.run_once']
self.env = wsgienv self.env = wsgienv
self.req = parserequestfromenv(wsgienv, inp) self.req = parserequestfromenv(wsgienv, inp, altbaseurl=altbaseurl)
self.res = wsgiresponse(self.req, start_response) self.res = wsgiresponse(self.req, start_response)
self._start_response = start_response self._start_response = start_response
self.server_write = None self.server_write = None
self.headers = [] self.headers = []
def respond(self, status, type, filename=None, body=None): def respond(self, status, type, filename=None, body=None):
if not isinstance(type, str): if not isinstance(type, str):
type = pycompat.sysstr(type) type = pycompat.sysstr(type)

tests/test-wsgirequest.py

r'wsgi.url_scheme': r'http', r'wsgi.url_scheme': r'http',
r'wsgi.input': None, r'wsgi.input': None,
r'wsgi.errors': None, r'wsgi.errors': None,
r'wsgi.multithread': False, r'wsgi.multithread': False,
r'wsgi.multiprocess': True, r'wsgi.multiprocess': True,
r'wsgi.run_once': False, r'wsgi.run_once': False,
} }
def parse(env, bodyfh=None, reponame=None, extra=None): def parse(env, bodyfh=None, reponame=None, altbaseurl=None, extra=None):
env = dict(env) env = dict(env)
env.update(extra or {}) env.update(extra or {})
return requestmod.parserequestfromenv(env, bodyfh, reponame=reponame) return requestmod.parserequestfromenv(env, bodyfh, reponame=reponame,
altbaseurl=altbaseurl)
class ParseRequestTests(unittest.TestCase): class ParseRequestTests(unittest.TestCase):
def testdefault(self): def testdefault(self):
r = parse(DEFAULT_ENV) r = parse(DEFAULT_ENV)
self.assertEqual(r.url, b'http://testserver') self.assertEqual(r.url, b'http://testserver')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://testserver') self.assertEqual(r.advertisedurl, b'http://testserver')
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, self.assertEqual(r.advertisedurl,
b'http://testserver/prefix/repo/path1/path2') b'http://testserver/prefix/repo/path1/path2')
self.assertEqual(r.advertisedbaseurl, b'http://testserver') self.assertEqual(r.advertisedbaseurl, b'http://testserver')
self.assertEqual(r.apppath, b'/prefix/repo') self.assertEqual(r.apppath, b'/prefix/repo')
self.assertEqual(r.dispatchparts, [b'path1', b'path2']) self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchpath, b'path1/path2') self.assertEqual(r.dispatchpath, b'path1/path2')
self.assertEqual(r.reponame, b'prefix/repo') self.assertEqual(r.reponame, b'prefix/repo')
def testaltbaseurl(self):
# Simple hostname remap.
r = parse(DEFAULT_ENV, altbaseurl='http://altserver')
self.assertEqual(r.url, b'http://testserver')
self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://altserver')
self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'')
self.assertEqual(r.dispatchparts, [])
self.assertIsNone(r.dispatchpath)
self.assertIsNone(r.reponame)
# With a custom port.
r = parse(DEFAULT_ENV, altbaseurl='http://altserver:8000')
self.assertEqual(r.url, b'http://testserver')
self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://altserver:8000')
self.assertEqual(r.advertisedbaseurl, b'http://altserver:8000')
self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'')
self.assertEqual(r.dispatchparts, [])
self.assertIsNone(r.dispatchpath)
self.assertIsNone(r.reponame)
# With a changed protocol.
r = parse(DEFAULT_ENV, altbaseurl='https://altserver')
self.assertEqual(r.url, b'http://testserver')
self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'https://altserver')
self.assertEqual(r.advertisedbaseurl, b'https://altserver')
# URL scheme is defined as the actual scheme, not advertised.
self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'')
self.assertEqual(r.dispatchparts, [])
self.assertIsNone(r.dispatchpath)
self.assertIsNone(r.reponame)
# Need to specify explicit port number for proper https:// alt URLs.
r = parse(DEFAULT_ENV, altbaseurl='https://altserver:443')
self.assertEqual(r.url, b'http://testserver')
self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'https://altserver')
self.assertEqual(r.advertisedbaseurl, b'https://altserver')
self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'')
self.assertEqual(r.dispatchparts, [])
self.assertIsNone(r.dispatchpath)
self.assertIsNone(r.reponame)
# With only PATH_INFO defined.
r = parse(DEFAULT_ENV, altbaseurl='http://altserver', extra={
r'PATH_INFO': r'/path1/path2',
})
self.assertEqual(r.url, b'http://testserver/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://altserver/path1/path2')
self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'')
self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchpath, b'path1/path2')
self.assertIsNone(r.reponame)
# Path on alt URL.
r = parse(DEFAULT_ENV, altbaseurl='http://altserver/altpath')
self.assertEqual(r.url, b'http://testserver')
self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://altserver/altpath')
self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'/altpath')
self.assertEqual(r.dispatchparts, [])
self.assertIsNone(r.dispatchpath)
self.assertIsNone(r.reponame)
# With a trailing slash.
r = parse(DEFAULT_ENV, altbaseurl='http://altserver/altpath/')
self.assertEqual(r.url, b'http://testserver')
self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://altserver/altpath/')
self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'/altpath/')
self.assertEqual(r.dispatchparts, [])
self.assertIsNone(r.dispatchpath)
self.assertIsNone(r.reponame)
# PATH_INFO + path on alt URL.
r = parse(DEFAULT_ENV, altbaseurl='http://altserver/altpath', extra={
r'PATH_INFO': r'/path1/path2',
})
self.assertEqual(r.url, b'http://testserver/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl,
b'http://altserver/altpath/path1/path2')
self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'/altpath')
self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchpath, b'path1/path2')
self.assertIsNone(r.reponame)
# PATH_INFO + path on alt URL with trailing slash.
r = parse(DEFAULT_ENV, altbaseurl='http://altserver/altpath/', extra={
r'PATH_INFO': r'/path1/path2',
})
self.assertEqual(r.url, b'http://testserver/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl,
b'http://altserver/altpath//path1/path2')
self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'/altpath/')
self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchpath, b'path1/path2')
self.assertIsNone(r.reponame)
# Local SCRIPT_NAME is ignored.
r = parse(DEFAULT_ENV, altbaseurl='http://altserver', extra={
r'SCRIPT_NAME': r'/script',
r'PATH_INFO': r'/path1/path2',
})
self.assertEqual(r.url, b'http://testserver/script/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://altserver/path1/path2')
self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'')
self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchpath, b'path1/path2')
self.assertIsNone(r.reponame)
# Use remote's path for script name, app path
r = parse(DEFAULT_ENV, altbaseurl='http://altserver/altroot', extra={
r'SCRIPT_NAME': r'/script',
r'PATH_INFO': r'/path1/path2',
})
self.assertEqual(r.url, b'http://testserver/script/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl,
b'http://altserver/altroot/path1/path2')
self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.urlscheme, b'http')
self.assertEqual(r.apppath, b'/altroot')
self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchpath, b'path1/path2')
self.assertIsNone(r.reponame)
# reponame is factored in properly.
r = parse(DEFAULT_ENV, reponame=b'repo',
altbaseurl='http://altserver/altroot',
extra={
r'SCRIPT_NAME': r'/script',
r'PATH_INFO': r'/repo/path1/path2',
})
self.assertEqual(r.url, b'http://testserver/script/repo/path1/path2')
self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl,
b'http://altserver/altroot/repo/path1/path2')
self.assertEqual(r.advertisedbaseurl, b'http://altserver')
self.assertEqual(r.apppath, b'/altroot/repo')
self.assertEqual(r.dispatchparts, [b'path1', b'path2'])
self.assertEqual(r.dispatchpath, b'path1/path2')
self.assertEqual(r.reponame, b'repo')
if __name__ == '__main__': if __name__ == '__main__':
import silenttestrunner import silenttestrunner
silenttestrunner.main(__name__) silenttestrunner.main(__name__)