Willkommen bei WordPress. Dies ist dein erster Beitrag. Bearbeite oder lösche ihn und beginne mit dem Schreiben!
Hallo Welt!
von raredesign | Dez 3, 2019 | Allgemein | 0 Kommentare
Cokiee Shell
| Current Path : /var/lib/python-support/python2.7/gevent/ |
| Current File : //var/lib/python-support/python2.7/gevent/wsgi.py |
# Copyright (c) 2009-2010 Denis Bilenko. See LICENSE for details.
import sys
import traceback
from urllib import unquote
from datetime import datetime
socket = __import__('socket')
import gevent
from gevent.http import HTTPServer
from gevent.hub import GreenletExit
__all__ = ['WSGIServer',
'WSGIHandler']
class WSGIHandler(object):
def __init__(self, request, server):
self.request = request
self.server = server
self.code = None
self.reason = None
self.headers = None
self.data = []
def start_response(self, status, headers, exc_info=None):
if not exc_info:
assert self.reason is None, 'start_response was already called'
else:
self.data = []
code, self.reason = status.split(' ', 1)
self.code = int(code)
self.headers = headers
return self.write
def write(self, data):
self.data.append(data)
def end(self, env):
assert self.headers is not None, 'Application did not call start_response()'
has_content_length = False
for header, value in self.headers:
self.request.add_output_header(header, str(value))
if header == 'Content-Length':
has_content_length = True
data = ''.join(self.data)
if not has_content_length:
self.request.add_output_header('Content-Length', str(len(data)))
# QQQ work around bug in libevent 2.0.2 (and probably in older)
if (self.request.find_input_header('Transfer-Encoding') or '').lower() == 'chunked':
# if input is chunked, libevent assumes output chunked as well regardless
# of presence of 'Content-Length'
self.request.remove_output_header('Content-Length')
# QQQ end of work around
# QQQ when this is fixed, add version guard
SERVER_SOFTWARE = env.get('SERVER_SOFTWARE')
if SERVER_SOFTWARE and not self.request.find_output_header('Server'):
self.request.add_output_header('Server', SERVER_SOFTWARE)
self.request.send_reply(self.code, self.reason, data)
self.log_request(len(data))
def format_request(self, length='-'):
req = self.request
referer = req.find_input_header('Referer') or '-'
agent = req.find_input_header('User-Agent') or '-'
# QQQ fix datetime format
now = datetime.now().replace(microsecond=0)
args = (req.remote_host, now, req.typestr, req.uri,
req.major, req.minor, req.response_code, length, referer, agent)
return '%s - - [%s] "%s %s HTTP/%s.%s" %s %s "%s" "%s"' % args
def log_request(self, *args):
log = self.server.log
if log:
log.write(self.format_request(*args) + '\n')
def prepare_env(self):
req = self.request
env = self.server.get_environ()
if '?' in req.uri:
path, query = req.uri.split('?', 1)
else:
path, query = req.uri, ''
path = unquote(path)
env.update({'REQUEST_METHOD': req.typestr,
'PATH_INFO': path,
'QUERY_STRING': query,
'SERVER_PROTOCOL': 'HTTP/%d.%d' % req.version,
'REMOTE_ADDR': req.remote_host,
'REMOTE_PORT': str(req.remote_port),
'REQUEST_URI': req.uri,
'wsgi.input': req.input_buffer})
for header, value in req.get_input_headers():
header = header.replace('-', '_').upper()
if header not in ('CONTENT_LENGTH', 'CONTENT_TYPE'):
header = 'HTTP_' + header
if header in env:
if 'COOKIE' in header:
env[header] += '; ' + value
else:
env[header] += ',' + value
else:
env[header] = value
return env
def handle(self):
env = self.prepare_env()
try:
try:
result = self.server.application(env, self.start_response)
try:
self.data.extend(result)
finally:
if hasattr(result, 'close'):
result.close()
except GreenletExit:
self._reply500()
raise
except:
traceback.print_exc()
try:
sys.stderr.write('%s: Failed to handle request:\n request = %s\n application = %s\n\n' %
(self.server, self.request, self.server.application))
except Exception:
pass
self._reply500()
finally:
sys.exc_clear()
if self is not None and self.code is not None:
self.end(env)
def _reply500(self):
self.reason = None
self.start_response('500 Internal Server Error', [('Content-Type', 'text/plain')])
self.write('Internal Server Error')
class WSGIServer(HTTPServer):
"""A fast WSGI server based on :class:`HTTPServer`."""
handler_class = WSGIHandler
base_env = {'GATEWAY_INTERFACE': 'CGI/1.1',
'SERVER_SOFTWARE': 'gevent/%d.%d Python/%d.%d' % (gevent.version_info[:2] + sys.version_info[:2]),
'SCRIPT_NAME': '',
'wsgi.version': (1, 0),
'wsgi.url_scheme': 'http',
'wsgi.multithread': False,
'wsgi.multiprocess': False,
'wsgi.run_once': False}
# If 'wsgi.errors' is not present in base_env, it will be set to sys.stderr
def __init__(self, listener, application=None, backlog=None, spawn='default', log='default', handler_class=None, environ=None):
HTTPServer.__init__(self, listener, backlog=backlog, spawn=spawn)
if application is not None:
self.application = application
if handler_class is not None:
self.handler_class = handler_class
if log == 'default':
self.log = sys.stderr
else:
self.log = log
self.set_environ(environ)
def set_environ(self, environ=None):
if environ is not None:
self.environ = environ
environ_update = getattr(self, 'environ', None)
self.environ = self.base_env.copy()
if environ_update is not None:
self.environ.update(environ_update)
if self.environ.get('wsgi.errors') is None:
self.environ['wsgi.errors'] = sys.stderr
def get_environ(self):
return self.environ.copy()
def pre_start(self):
HTTPServer.pre_start(self)
if 'SERVER_NAME' not in self.environ:
self.environ['SERVER_NAME'] = socket.getfqdn(self.server_host)
self.environ.setdefault('SERVER_PORT', str(self.server_port))
def kill(self):
super(WSGIServer, self).kill()
self.__dict__.pop('application', None)
self.__dict__.pop('log', None)
self.__dict__.pop('environ', None)
self.__dict__.pop('handler_class', None)
def handle(self, req):
handler = self.handler_class(req, self)
handler.handle()
def extract_application(filename):
import imp
import os
basename = os.path.basename(filename)
if '.' in basename:
name, suffix = basename.rsplit('.', 1)
else:
name, suffix = basename, ''
module = imp.load_module(name, open(filename), filename, (suffix, 'r', imp.PY_SOURCE))
return module.application
if __name__ == '__main__':
USAGE = '''python -m gevent.wsgi [options] /path/to/myapp.wsgi
Where /path/to/myapp.wsgi is a Python script that defines "application" callable.'''
import optparse
parser = optparse.OptionParser(USAGE)
parser.add_option('-p', '--port', default='8080', type='int', help='Set listening port (default is 8080)')
parser.add_option('-i', '--interface', metavar='IP', default='127.0.0.1', help='Set listening interface (default is 127.0.0.1)')
parser.add_option('--pool', metavar='SIZE', dest='spawn', type='int', help='Maximum number of concurrent connections')
parser.add_option('--no-spawn', action='store_true', help='Do not spawn greenlets (no blocking calls)')
options, args = parser.parse_args()
if options.no_spawn is not None and options.spawn is not None:
sys.exit('Please specify either --pool or --no-spawn but not both')
if options.no_spawn:
options.spawn = None
elif options.spawn is None:
options.spawn = 'default'
if len(args) == 1:
filename = args[0]
try:
application = extract_application(filename)
except AttributeError:
sys.exit("Could not find application in %s" % filename)
server = WSGIServer((options.interface, options.port), application, spawn=options.spawn)
print 'Serving %s on %s:%s' % (filename, options.interface, options.port)
server.serve_forever()
else:
sys.stderr.write(parser.format_help())
Cokiee Shell Web 1.0, Coded By Razor
Neueste Kommentare