This is an archive of the discontinued Mercurial Phabricator instance.

Differential D967

hgweb: when constructing or adding to a wsgi environ dict, use native strs
ClosedPublic

Authored by durin42 on Oct 5 2017, 5:32 PM.

Details

Reviewers
quark
indygreg
Group Reviewers
hg-reviewers
Commits
rHG482d6f6dba91: hgweb: when constructing or adding to a wsgi environ dict, use native strs
rHG3ccd7495facc: hgweb: when constructing or adding to a wsgi environ dict, use native strs
rHG147665d36088: hgweb: when constructing or adding to a wsgi environ dict, use native strs
Summary

That's what's required of us to work with the WSGI API on Python 3.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

durin42 created this revision.Oct 5 2017, 5:32 PM
quark accepted this revision.Oct 5 2017, 9:59 PM
indygreg accepted this revision.Oct 6 2017, 9:45 AM
indygreg added a subscriber: indygreg.

Dear Python: why are things this close to the wire not bytes? *sigh*

This revision is now accepted and ready to land.Oct 6 2017, 9:45 AM
Closed by commit rHG147665d36088: hgweb: when constructing or adding to a wsgi environ dict, use native strs (authored by durin42). · Explain WhyOct 8 2017, 4:37 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 2529

mercurial/hgweb/request.py

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):
version = wsgienv['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)
self.inp = wsgienv['wsgi.input'] self.inp = wsgienv[r'wsgi.input']
self.err = wsgienv['wsgi.errors'] self.err = wsgienv[r'wsgi.errors']
self.threaded = wsgienv['wsgi.multithread'] self.threaded = wsgienv[r'wsgi.multithread']
self.multiprocess = wsgienv['wsgi.multiprocess'] self.multiprocess = wsgienv[r'wsgi.multiprocess']
self.run_once = wsgienv['wsgi.run_once'] self.run_once = wsgienv[r'wsgi.run_once']
self.env = wsgienv self.env = wsgienv
self.form = normalize(cgi.parse(self.inp, self.form = normalize(cgi.parse(self.inp,
self.env, self.env,
keep_blank_values=1)) keep_blank_values=1))
self._start_response = start_response self._start_response = start_response
self.server_write = None self.server_write = None
self.headers = [] self.headers = []

mercurial/hgweb/server.py

url_scheme = 'http' url_scheme = 'http'
@staticmethod @staticmethod
def preparehttpserver(httpserver, ui): def preparehttpserver(httpserver, ui):
"""Prepare .socket of new HTTPServer instance""" """Prepare .socket of new HTTPServer instance"""
def __init__(self, *args, **kargs): def __init__(self, *args, **kargs):
self.protocol_version = 'HTTP/1.1' self.protocol_version = r'HTTP/1.1'
httpservermod.basehttprequesthandler.__init__(self, *args, **kargs) httpservermod.basehttprequesthandler.__init__(self, *args, **kargs)
def _log_any(self, fp, format, *args): def _log_any(self, fp, format, *args):
fp.write("%s - - [%s] %s\n" % (self.client_address[0], fp.write("%s - - [%s] %s\n" % (self.client_address[0],
self.log_date_time_string(), self.log_date_time_string(),
format % args)) format % args))
fp.flush() fp.flush()
def do_GET(self): def do_GET(self):
self.do_POST() self.do_POST()
def do_hgweb(self): def do_hgweb(self):
path, query = _splitURI(self.path) path, query = _splitURI(self.path)
env = {} env = {}
env['GATEWAY_INTERFACE'] = 'CGI/1.1' env[r'GATEWAY_INTERFACE'] = r'CGI/1.1'
env['REQUEST_METHOD'] = self.command env[r'REQUEST_METHOD'] = self.command
env['SERVER_NAME'] = self.server.server_name env[r'SERVER_NAME'] = self.server.server_name
env['SERVER_PORT'] = str(self.server.server_port) env[r'SERVER_PORT'] = str(self.server.server_port)
env['REQUEST_URI'] = self.path env[r'REQUEST_URI'] = self.path
env['SCRIPT_NAME'] = self.server.prefix env[r'SCRIPT_NAME'] = self.server.prefix
env['PATH_INFO'] = path[len(self.server.prefix):] env[r'PATH_INFO'] = path[len(self.server.prefix):]
env['REMOTE_HOST'] = self.client_address[0] env[r'REMOTE_HOST'] = self.client_address[0]
env['REMOTE_ADDR'] = self.client_address[0] env[r'REMOTE_ADDR'] = self.client_address[0]
if query: if query:
env['QUERY_STRING'] = query env[r'QUERY_STRING'] = query
if self.headers.typeheader is None: if self.headers.typeheader is None:
env['CONTENT_TYPE'] = self.headers.type env[r'CONTENT_TYPE'] = self.headers.type
else: else:
env['CONTENT_TYPE'] = self.headers.typeheader env[r'CONTENT_TYPE'] = self.headers.typeheader
length = self.headers.getheader('content-length') length = self.headers.getheader('content-length')
if length: if length:
env['CONTENT_LENGTH'] = length env[r'CONTENT_LENGTH'] = length
for header in [h for h in self.headers.keys() for header in [h for h in self.headers.keys()
if h not in ('content-type', 'content-length')]: if h not in ('content-type', 'content-length')]:
hkey = 'HTTP_' + header.replace('-', '_').upper() hkey = r'HTTP_' + header.replace(r'-', r'_').upper()
hval = self.headers.getheader(header) hval = self.headers.get(header)
hval = hval.replace('\n', '').strip() hval = hval.replace(r'\n', r'').strip()
if hval: if hval:
env[hkey] = hval env[hkey] = hval
env['SERVER_PROTOCOL'] = self.request_version env[r'SERVER_PROTOCOL'] = self.request_version
env['wsgi.version'] = (1, 0) env[r'wsgi.version'] = (1, 0)
env['wsgi.url_scheme'] = self.url_scheme env[r'wsgi.url_scheme'] = self.url_scheme
if env.get('HTTP_EXPECT', '').lower() == '100-continue': if env.get(r'HTTP_EXPECT', '').lower() == '100-continue':
self.rfile = common.continuereader(self.rfile, self.wfile.write) self.rfile = common.continuereader(self.rfile, self.wfile.write)
env['wsgi.input'] = self.rfile env[r'wsgi.input'] = self.rfile
env['wsgi.errors'] = _error_logger(self) env[r'wsgi.errors'] = _error_logger(self)
env['wsgi.multithread'] = isinstance(self.server, env[r'wsgi.multithread'] = isinstance(self.server,
socketserver.ThreadingMixIn) socketserver.ThreadingMixIn)
env['wsgi.multiprocess'] = isinstance(self.server, env[r'wsgi.multiprocess'] = isinstance(self.server,
socketserver.ForkingMixIn) socketserver.ForkingMixIn)
env['wsgi.run_once'] = 0 env[r'wsgi.run_once'] = 0
self.saved_status = None self.saved_status = None
self.saved_headers = [] self.saved_headers = []
self.sent_headers = False self.sent_headers = False
self.length = None self.length = None
self._chunked = None self._chunked = None
for chunk in self.server.application(env, self._start_response): for chunk in self.server.application(env, self._start_response):
self._write(chunk) self._write(chunk)

mercurial/hgweb/wsgicgi.py

common, common,
) )
def launch(application): def launch(application):
util.setbinary(util.stdin) util.setbinary(util.stdin)
util.setbinary(util.stdout) util.setbinary(util.stdout)
environ = dict(encoding.environ.iteritems()) environ = dict(encoding.environ.iteritems())
environ.setdefault('PATH_INFO', '') environ.setdefault(r'PATH_INFO', '')
if environ.get('SERVER_SOFTWARE', '').startswith('Microsoft-IIS'): if environ.get(r'SERVER_SOFTWARE', r'').startswith(r'Microsoft-IIS'):
# IIS includes script_name in PATH_INFO # IIS includes script_name in PATH_INFO
scriptname = environ['SCRIPT_NAME'] scriptname = environ[r'SCRIPT_NAME']
if environ['PATH_INFO'].startswith(scriptname): if environ[r'PATH_INFO'].startswith(scriptname):
environ['PATH_INFO'] = environ['PATH_INFO'][len(scriptname):] environ[r'PATH_INFO'] = environ[r'PATH_INFO'][len(scriptname):]
stdin = util.stdin stdin = util.stdin
if environ.get('HTTP_EXPECT', '').lower() == '100-continue': if environ.get(r'HTTP_EXPECT', r'').lower() == r'100-continue':
stdin = common.continuereader(stdin, util.stdout.write) stdin = common.continuereader(stdin, util.stdout.write)
environ['wsgi.input'] = stdin environ[r'wsgi.input'] = stdin
environ['wsgi.errors'] = util.stderr environ[r'wsgi.errors'] = util.stderr
environ['wsgi.version'] = (1, 0) environ[r'wsgi.version'] = (1, 0)
environ['wsgi.multithread'] = False environ[r'wsgi.multithread'] = False
environ['wsgi.multiprocess'] = True environ[r'wsgi.multiprocess'] = True
environ['wsgi.run_once'] = True environ[r'wsgi.run_once'] = True
if environ.get('HTTPS', 'off').lower() in ('on', '1', 'yes'): if environ.get(r'HTTPS', r'off').lower() in (r'on', r'1', r'yes'):
environ['wsgi.url_scheme'] = 'https' environ[r'wsgi.url_scheme'] = r'https'
else: else:
environ['wsgi.url_scheme'] = 'http' environ[r'wsgi.url_scheme'] = r'http'
headers_set = [] headers_set = []
headers_sent = [] headers_sent = []
out = util.stdout out = util.stdout
def write(data): def write(data):
if not headers_set: if not headers_set:
raise AssertionError("write() before start_response()") raise AssertionError("write() before start_response()")