mercurial-scm/hg: comparison mercurial/hgweb/request.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 # 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 wsgiref.validate
+# import wsgiref.validate
-from ..thirdparty import (
+from ..thirdparty import attr
-attr,
-)
 from .. import (
 error,
 pycompat,
 util,
 )
 class multidict(object):
 """A dict like object that can store multiple values for a key.
 Used to store parsed request parameters.
 This is inspired by WebOb's class of the same name.
 """
 def __init__(self):
 self._items = {}
 def __getitem__(self, key):
 """Returns the last set value for a key."""
 return vals[0]
 def asdictoflists(self):
 return {k: list(v) for k, v in self._items.iteritems()}
 @attr.s(frozen=True)
 class parsedrequest(object):
 """Represents a parsed WSGI request.
 # Request body input stream.
 bodyfh = attr.ib()
 # WSGI environment dict, unmodified.
 rawenv = attr.ib()
 def parserequestfromenv(env, reponame=None, altbaseurl=None, bodyfh=None):
 """Parse URL components from environment variables.
 WSGI defines request attributes via environment variables. This function
 parses the environment variables into a data structure.
 # 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 only want to be dealing with spec-conforming WSGI implementations.
 # 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
 # (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
 # in Mercurial, so mass convert string keys and values to bytes.
 if pycompat.ispy3:
 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 = {
-for k, v in env.iteritems()}
+k: v.encode('latin-1') if isinstance(v, str) else v
+for k, v in env.iteritems()
+}
 # Some hosting solutions are emulating hgwebdir, and dispatching directly
 # to an hgweb instance using this environment variable.  This was always
 # checked prior to d7fd203e36cc; keep doing so to avoid breaking them.
 if not reponame:
 if not env.get('PATH_INFO'):
 raise error.ProgrammingError('reponame requires PATH_INFO')
 if not env['PATH_INFO'].startswith(repoprefix):
-raise error.ProgrammingError('PATH_INFO does not begin with repo '
+raise error.ProgrammingError(
-'name: %s (%s)' % (env['PATH_INFO'],
+'PATH_INFO does not begin with repo '
-reponame))
+'name: %s (%s)' % (env['PATH_INFO'], reponame)
+)
-dispatchpath = env['PATH_INFO'][len(repoprefix):]
+dispatchpath = env['PATH_INFO'][len(repoprefix) :]
 if dispatchpath and not dispatchpath.startswith('/'):
-raise error.ProgrammingError('reponame prefix of PATH_INFO does '
+raise error.ProgrammingError(
-'not end at path delimiter: %s (%s)' %
+'reponame prefix of PATH_INFO does '
-(env['PATH_INFO'], reponame))
+'not end at path delimiter: %s (%s)'
+% (env['PATH_INFO'], reponame)
+)
 apppath = apppath.rstrip('/') + repoprefix
 dispatchparts = dispatchpath.strip('/').split('/')
 dispatchpath = '/'.join(dispatchparts)
 # perform case normalization for us. We just rewrite underscore to dash
 # so keys match what likely went over the wire.
 headers = []
 for k, v in env.iteritems():
 if k.startswith('HTTP_'):
-headers.append((k[len('HTTP_'):].replace('_', '-'), v))
+headers.append((k[len('HTTP_') :].replace('_', '-'), v))
-from . import wsgiheaders # avoid cycle
+from . import wsgiheaders  # avoid cycle
 headers = wsgiheaders.Headers(headers)
 # This is kind of a lie because the HTTP header wasn't explicitly
 # sent. But for all intents and purposes it should be OK to lie about
 # this, since a consumer will either either value to determine how many
 headers['Content-Type'] = env['CONTENT_TYPE']
 if bodyfh is None:
 bodyfh = env['wsgi.input']
 if 'Content-Length' in headers:
-bodyfh = util.cappedreader(bodyfh,
+bodyfh = util.cappedreader(
-int(headers['Content-Length'] or '0'))
+bodyfh, int(headers['Content-Length'] or '0')
+)
-return parsedrequest(method=env['REQUEST_METHOD'],
-url=fullurl, baseurl=baseurl,
+return parsedrequest(
-advertisedurl=advertisedfullurl,
+method=env['REQUEST_METHOD'],
-advertisedbaseurl=advertisedbaseurl,
+url=fullurl,
-urlscheme=env['wsgi.url_scheme'],
+baseurl=baseurl,
-remoteuser=env.get('REMOTE_USER'),
+advertisedurl=advertisedfullurl,
-remotehost=env.get('REMOTE_HOST'),
+advertisedbaseurl=advertisedbaseurl,
-apppath=apppath,
+urlscheme=env['wsgi.url_scheme'],
-dispatchparts=dispatchparts, dispatchpath=dispatchpath,
+remoteuser=env.get('REMOTE_USER'),
-reponame=reponame,
+remotehost=env.get('REMOTE_HOST'),
-querystring=querystring,
+apppath=apppath,
-qsparams=qsparams,
+dispatchparts=dispatchparts,
-headers=headers,
+dispatchpath=dispatchpath,
-bodyfh=bodyfh,
+reponame=reponame,
-rawenv=env)
+querystring=querystring,
+qsparams=qsparams,
+headers=headers,
+bodyfh=bodyfh,
+rawenv=env,
+)
 class offsettrackingwriter(object):
 """A file object like object that is append only and tracks write count.
 Instances are bound to a callable. This callable is called with data
 The intent of this class is to wrap the ``write()`` function returned by
 a WSGI ``start_response()`` function. Since ``write()`` is a callable and
 not a file object, it doesn't implement other file object methods.
 """
 def __init__(self, writefn):
 self._write = writefn
 self._offset = 0
 def write(self, s):
 pass
 def tell(self):
 return self._offset
 class wsgiresponse(object):
 """Represents a response to a WSGI request.
 A response consists of a status line, headers, and a body.
 """
 self._req = req
 self._startresponse = startresponse
 self.status = None
-from . import wsgiheaders # avoid cycle
+from . import wsgiheaders  # avoid cycle
 self.headers = wsgiheaders.Headers([])
 self._bodybytes = None
 self._bodygen = None
 self._bodywillwrite = False
 self._started = False
 self._bodywritefn = None
 def _verifybody(self):
-if (self._bodybytes is not None or self._bodygen is not None
+if (
-or self._bodywillwrite):
+self._bodybytes is not None
+or self._bodygen is not None
+or self._bodywillwrite
+):
 raise error.ProgrammingError('cannot define body multiple times')
 def setbodybytes(self, b):
 """Define the response body as static bytes.
 self._started = True
 if not self.status:
 raise error.ProgrammingError('status line not defined')
-if (self._bodybytes is None and self._bodygen is None
+if (
-and not self._bodywillwrite):
+self._bodybytes is None
+and self._bodygen is None
+and not self._bodywillwrite
+):
 raise error.ProgrammingError('response body not defined')
 # RFC 7232 Section 4.1 states that a 304 MUST generate one of
 # {Cache-Control, Content-Location, Date, ETag, Expires, Vary}
 # and SHOULD NOT generate other headers unless they could be used
 if self.headers.get('Content-Length') == '0':
 del self.headers['Content-Length']
 # Strictly speaking, this is too strict. But until it causes
 # problems, let's be strict.
-badheaders = {k for k in self.headers.keys()
+badheaders = {
-if k.lower() not in ('date', 'etag', 'expires',
+k
-'cache-control',
+for k in self.headers.keys()
-'content-location',
+if k.lower()
-'content-security-policy',
+not in (
-'vary')}
+'date',
+'etag',
+'expires',
+'cache-control',
+'content-location',
+'content-security-policy',
+'vary',
+)
+}
 if badheaders:
 raise error.ProgrammingError(
-'illegal header on 304 response: %s' %
+'illegal header on 304 response: %s'
-', '.join(sorted(badheaders)))
+% ', '.join(sorted(badheaders))
+)
 if self._bodygen is not None or self._bodywillwrite:
-raise error.ProgrammingError("must use setbodybytes('') with "
+raise error.ProgrammingError(
-"304 responses")
+"must use setbodybytes('') with " "304 responses"
+)
 # Various HTTP clients (notably httplib) won't read the HTTP response
 # until the HTTP request has been sent in full. If servers (us) send a
 # response before the HTTP request has been fully sent, the connection
 # may deadlock because neither end is reading.
 while True:
 chunk = self._req.bodyfh.read(32768)
 if not chunk:
 break
-strheaders = [(pycompat.strurl(k), pycompat.strurl(v)) for
+strheaders = [
-k, v in self.headers.items()]
+(pycompat.strurl(k), pycompat.strurl(v))
-write = self._startresponse(pycompat.sysstr(self.status),
+for k, v in self.headers.items()
-strheaders)
+]
+write = self._startresponse(pycompat.sysstr(self.status), strheaders)
 if self._bodybytes:
 yield self._bodybytes
 elif self._bodygen:
 for chunk in self._bodygen:
 """
 if not self._bodywillwrite:
 raise error.ProgrammingError('must call setbodywillwrite() first')
 if not self._started:
-raise error.ProgrammingError('must call sendresponse() first; did '
+raise error.ProgrammingError(
-'you remember to consume it since it '
+'must call sendresponse() first; did '
-'is a generator?')
+'you remember to consume it since it '
+'is a generator?'
+)
 assert self._bodywritefn
 return offsettrackingwriter(self._bodywritefn)
 def wsgiapplication(app_maker):
 '''For compatibility with old CGI scripts. A plain hgweb() or hgwebdir()
 can and should now be used as a WSGI application.'''
 application = app_maker()
 def run_wsgi(env, respond):
 return application(env, respond)
 return run_wsgi

changeset 43076	2372284d9457
parent 40545	6107d4549fcc
child 43077	687b865b95ad