def recv(self, wsgi=False):
try:
stream = HttpStream(self.reader, kind=HTTP_REQUEST, parser_class=HttpParser, decompress=True)
if bool(wsgi):
environ = stream.wsgi_environ()
environ['wsgi.url_scheme'] = guess_scheme(environ)
environ['wsgi.input'] = stream.body_file()
environ['wsgi.socket'] = self.socket
return environ
# BUG:
# http-parser has an issue here, if we call 'method' before 'headers'
# and invalid method name is returned...
fields = stream.headers()
method = stream.method()
url = stream.url()
version = stream.version()
content = stream.body_file()
url = urlparse(url)
path = url.path
query = parse_qs(url.query, keep_blank_values=True)
fragment = url.fragment
for k, v in six.iteritems(dict(query)):
query[k] = parse_query_value(v)
self.version = 'HTTP/%s.%s' % version
return method, path, query, fragment, fields, content
except NoMoreData:
pass
def __init__(self, environ, start_response):
self.__environ = environ
self.__start_response = start_response
self.__response_sent_p = False
self.__buffer = ''
self.__low_level_headers = []
self.__headers = table(self.__low_level_headers)
self.__headers.add = self.__headers.add_header
self.__status = "200 OK"
self.__filename = None
self.__disposition_type = None
self.__bytes_sent = 0
self.__allowed_methods = []
self.__cleanups = []
self.headers_out = self.__headers
## See: <http://www.python.org/dev/peps/pep-0333/#the-write-callable>
self.__write = None
self.__write_error = False
self.__errors = environ['wsgi.errors']
self.__headers_in = table([])
self.__tainted = False
self.__is_https = int(guess_scheme(self.__environ) == 'https')
self.__replace_https = False
self.track_writings = False
self.__what_was_written = ""
for key, value in environ.iteritems():
if key.startswith('HTTP_'):
self.__headers_in[key[len('HTTP_'):].replace('_', '-')] = value
if environ.get('CONTENT_LENGTH'):
self.__headers_in['content-length'] = environ['CONTENT_LENGTH']
if environ.get('CONTENT_TYPE'):
self.__headers_in['content-type'] = environ['CONTENT_TYPE']
def main(argv=sys.argv):
"""
Run the WSGI application using :mod:`wsgiref`.
"""
args = docopt.docopt(__doc__, argv[1:], version=__version__)
if args['--print-template']:
six.print_(DEFAULT_FRONTPAGE)
return 0
host = args['--host']
port = int(args['--port'])
store = os.path.realpath(os.path.expanduser(args['--store']))
template = args['--template']
if 0 > port > 65535:
six.print_('Bad port: {0}'.format(port), file=sys.stderr)
return 1
try:
app = create_application(None, store=store, template=template)
except BadPath as exc:
six.print_(exc.message, file=sys.stderr)
return 1
logging.basicConfig(level=logging.INFO, stream=sys.stderr)
from wsgiref.util import guess_scheme
scheme = guess_scheme(os.environ)
six.print_("Serving on {0}://{1}:{2}/".format(scheme, host, port),
file=sys.stderr)
from wsgiref.simple_server import make_server
make_server(host, port, app).serve_forever()
return 0
def _getURL(env, local, full=False):
url = urlparse.urljoin(env['SCRIPT_NAME'], local)
if full:
url = urlparse.urljoin("%s://%s" % (guess_scheme(env), env['HTTP_HOST']), url)
return url
def wrapped(environ, start_response):
domain = os.environ.get('DOMAIN')
if domain and environ['HTTP_HOST'] != domain:
path = environ.get('PATH_INFO', '')
protocol = guess_scheme(environ)
start_response('301 Redirect', [('Location', '%s://%s%s' % (protocol, domain, path)),])
return []
return fn(environ, start_response)
def get_path(environ):
"""
Get the path
"""
from wsgiref import util
request_uri = environ.get('REQUEST_URI', environ.get('RAW_URI', ''))
if request_uri == '':
uri = util.request_uri(environ)
host = environ.get('HTTP_HOST', '')
scheme = util.guess_scheme(environ)
prefix = "{scheme}://{host}".format(scheme=scheme, host=host)
request_uri = uri.replace(prefix, '')
return request_uri
def _metadata(self):
environ = self.filtered_environ
data = {}
data['HTTP_SCHEME'] = guess_scheme(environ)
cgi_vars = data['CGI Variables'] = {}
wsgi_vars = data['WSGI Variables'] = {}
hide_vars = ['wsgi.errors', 'wsgi.input',
'wsgi.multithread', 'wsgi.multiprocess',
'wsgi.run_once', 'wsgi.version',
'wsgi.url_scheme', 'webob._parsed_cookies']
for name, value in environ.items():
if name.upper() == name:
if name in os.environ: # Skip OS environ variables
continue
if value:
cgi_vars[name] = value
elif name not in hide_vars:
wsgi_vars[name] = value
proc_desc = tuple([int(bool(environ[key]))
for key in ('wsgi.multiprocess',
'wsgi.multithread',
'wsgi.run_once')])
wsgi_vars['wsgi process'] = self.process_combos[proc_desc]
return {'fields': data, 'filter_sensitive': self._filter_sensitive}
def is_https(self):
scheme = self.__environ.get('wsgi.url_scheme', guess_scheme(self.__environ))
return int(scheme == 'https')
def get_scheme(self):
"""Return the URL scheme being used"""
return guess_scheme(self.environ)
def testGuessScheme(self):
self.assertEqual(util.guess_scheme({}), "http")
self.assertEqual(util.guess_scheme({'HTTPS': "foo"}), "http")
self.assertEqual(util.guess_scheme({'HTTPS': "on"}), "https")
self.assertEqual(util.guess_scheme({'HTTPS': "yes"}), "https")
self.assertEqual(util.guess_scheme({'HTTPS': "1"}), "https")
def is_https(self):
scheme = self.__environ.get("wsgi.url_scheme", guess_scheme(self.__environ))
return int(scheme == "https")
def is_https(self):
scheme = self.__environ.get('wsgi.url_scheme',
guess_scheme(self.__environ))
return int(scheme == 'https')
def scheme(self):
return (self.environ["wsgi.url_scheme"] if "wsgi.url_scheme"
in self.environ else wsgiutil.guess_scheme(self.environ))
def scheme(self):
"""Return HTTP Request Scheme (http|https)."""
return wsgiutil.guess_scheme(self.environ)
def is_https(self):
return int(guess_scheme(self.__environ) == "https")
def get_scheme(self):
"""Return the URL scheme being used"""
return guess_scheme(self.environ)
def testGuessScheme(self):
self.assertEqual(util.guess_scheme({}), "http")
self.assertEqual(util.guess_scheme({'HTTPS':"foo"}), "http")
self.assertEqual(util.guess_scheme({'HTTPS':"on"}), "https")
self.assertEqual(util.guess_scheme({'HTTPS':"yes"}), "https")
self.assertEqual(util.guess_scheme({'HTTPS':"1"}), "https")
def main(argv=sys.argv):
"""
Run the WSGI application using :mod:`wsgiref`.
"""
parser = argparse.ArgumentParser(description="A PyPI-style documentation server.")
parser.add_argument(
"--host",
help="hostname or address to bind server to",
default="localhost",
)
parser.add_argument(
"--port",
help="port to run server on",
type=int,
default=8080,
)
parser.add_argument(
"--store",
help="path to bundle store directory",
default="~/docstore",
)
parser.add_argument(
"--template",
help="path to frontpage template",
type=str,
)
parser.add_argument(
"--print-template",
action="store_true",
)
args = parser.parse_args()
if args.print_template:
print(DEFAULT_FRONTPAGE)
return 0
print(args)
store = os.path.realpath(os.path.expanduser(args.store))
if 0 > args.port > 65535:
print("Bad port:", args.port, file=sys.stderr)
return 1
try:
app = create_application(None, store=store, template=args.template)
except BadPath as exc:
print(exc, file=sys.stderr)
return 1
logging.basicConfig(level=logging.INFO, stream=sys.stderr)
from wsgiref.util import guess_scheme
scheme = guess_scheme(os.environ)
print(
"Serving on {}://{}:{}/".format(scheme, args.host, args.port),
file=sys.stderr,
)
from wsgiref.simple_server import make_server
make_server(args.host, args.port, app).serve_forever()
return 0
