def setUp(self):
self.port = 8000
self.url = 'localhost'
self.server = WSGIServer((self.url, self.port), WSGIRequestHandler)
self.server.set_app(timezones_app)
self.t = threading.Thread(target=self.server.serve_forever)
self.t.start()
def server_close(self):
"""
Properly initiate closing handshakes on
all websockets when the WSGI server terminates.
"""
print "closing sockets"
_WSGIServer.server_close(self)
def run_wsgi(port=8123):
server = WSGIServer(('', port), WSGIRequestHandler)
app = create_publisher()
server.set_app(app)
print 'serving on %s:%d' % (interface, port,)
server.serve_forever()
def start_wsgi_server():
from rdb.RobotDebuger import DebugSetting
app_settings = DebugSetting()
work_root = os.getcwd()
config_path = os.path.abspath(config_file)
if os.path.isfile(config_path):
app_settings.load_from_file(config_path)
init_sys_logging(app_settings)
logger = logging.getLogger("rdb.proxy")
logger.info("Loading RDB proxy at %s" % work_root)
try:
SERVER_CONTEXT = ApplicationContext(work_root, app_settings)
globals()['SERVER_CONTEXT'] = SERVER_CONTEXT
from wsgiref.simple_server import WSGIServer
server_address = (app_settings.WEB_BIND, int(app_settings.WEB_PORT))
server = WSGIServer(server_address, RDBProxyWSGIHandler)
server.set_app(wsgi_global_app)
SERVER_CONTEXT.server = server
logger.info("Serving HTTP on %s:%s..." %(app_settings.WEB_BIND,
app_settings.WEB_PORT))
server.serve_forever()
except BaseException, e:
logger.exception(e)
def runserver():
"""Lance un serveur wsgi de test, puis lui attribue l'application a
lancer avec eventuellement le chainage de middleware
"""
from pyson.middleware.error import HandleError
from pyson.middleware.log import Log
from pyson.middleware.session import Session #se wrapp automatiquement avec cookie
from pyson.middleware.force_auth import Force_auth
from pyson.middleware.http_basic import Http_basic
from pyson.middleware.formdata import Formdata
from pyson.middleware.restriction import Middle as Restriction
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr, os.environ).run(urls.urls)
print "------------- Attention ---------------"
else:
import wsgiref
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', int(context.conf["port"])), WSGIRequestHandler)
wrapper = Session(Formdata((Restriction(urls.urls))))
httpd.set_app(wrapper)
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def finish_request(self, request, client_address):
try:
WSGIServer.finish_request(self, request, client_address)
except IOError as ex:
if ex.errno == 32:
print('client disconnected.')
else:
raise ex
def __init__(self, machine_id, host, port, ui):
self.machine_id = machine_id
WSGIServer.__init__(self, (host, port), WSGIRequestHandler)
self.set_app(self.wsgi_app)
Partner.__init__(self, ui)
self.text_format = XMLFormat()
self.stopped = False
self.sessions = {} # {session_token: session}
self.session_token_for_user = {} # {user_name: session_token}
def __init__(self, *args, **kwargs):
WSGIServer.__init__(self, *args, **kwargs)
# NonBlockingClient -> timestamp
self.clients = {}
# Number of simultaneous clients.
self.limit = 1000
# Number of seconds before we bounce idle clients.
self.timeout = 60
self._shutdown_event = threading.Event()
def __init__(self, server_address, HandlerClass):
WSGIServer.__init__(self, server_address, HandlerClass)
if self.cert_file:
ctx = SSL.Context(SSL.SSLv3_METHOD)
ctx.use_privatekey_file(self.cert_file)
ctx.use_certificate_file(self.cert_file)
self.socket = SSL.Connection(
ctx, socket.socket(self.address_family, self.socket_type))
self.server_bind()
self.server_activate()
def run(self, handler):
# Handle the TIME_WAIT state for quick server restarts
WSGIServer.allow_reuse_address = 1
# Create the server and start it
self.srv = WSGIServer((self.host, self.port), _HTTPRequestHandler)
self.srv.set_app(self.app)
try:
self.srv.serve_forever()
finally:
self.srv.server_close()
def run():
import urls
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr, os.environ).run(urls.urls)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', 8000), WSGIRequestHandler)
httpd.set_app(urls.urls)
print "Serving HTTP os %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def server_close(self):
"""
Properly initiate closing handshakes on
all websockets when the WSGI server terminates.
"""
if hasattr(self, 'manager'):
self.manager.close_all()
self.manager.stop()
self.manager.join()
delattr(self, 'manager')
_WSGIServer.server_close(self)
def __init__(self, server_address, HandlerClass):
WSGIServer.__init__(self, server_address, HandlerClass)
if self.cert_file:
ctx = SSL.Context(SSL.SSLv3_METHOD)
ctx.use_privatekey_file(self.cert_file)
ctx.use_certificate_file(self.cert_file)
self.socket = SSL.Connection(ctx, socket.socket(self.address_family,
self.socket_type))
self.server_bind()
self.server_activate()
def run():
import urls
if os.environ.get('REQUEST_METHOD', ''):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr, os.environ).run(urls.urls)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', 8080), WSGIRequestHandler)
httpd.set_app(urls.urls)
host, port = httpd.socket.getsockname()[:2]
print 'Serving HTTP on {0} port {1}...'.format(host, port)
httpd.serve_forever()
class HealthCheck:
def __init__(self, port):
self.server = WSGIServer(('0.0.0.0', port),
NoLoggingWSGIRequestHandler)
api = falcon.App()
api.add_route('/health', self)
self.server.set_app(api)
def on_get(self, _, response):
response.media = {'status': 'available'}
def start(self):
self.server.serve_forever()
def serve(handler, host='localhost', port=8080, debug=True):
"""
Starts a developent server on the local machine. By default, the
server runs on port 8080 on localhost. You can pass in a different
hostname and/or IP using the keyword arguments.
"""
if debug:
handler = DebugMiddleware.wrap(handler)
httpd = WSGIServer((host, port), WSGIRequestHandler)
httpd.set_app(WSGIHandler(handler))
print("Development server is running at http://%s:%s/" % (host, port))
httpd.serve_forever()
def get_request(self):
socket, client_address = WSGIServer.get_request(self)
socket = ssl.wrap_socket(socket,
server_side=True,
certfile=certfile,
keyfile=keyfile)
return socket, client_address
def get_request(self):
socket, client_address = WSGIServer.get_request(self)
socket = ssl.wrap_socket(socket,
server_side=True,
certfile=SERVER_CERT_FILE,
keyfile=SERVER_KEY_FILE)
return socket, client_address
def get_request(self):
socket, client_address = WSGIServer.get_request(self)
socket = ssl.wrap_socket(socket,
server_side=True,
certfile=certfile,
keyfile=keyfile)
return socket, client_address
def get_request(self):
socket, client_address = WSGIServer.get_request(self)
socket = ssl.wrap_socket(socket,
server_side=True,
certfile=SERVER_CERT_FILE,
keyfile=SERVER_KEY_FILE)
return socket, client_address
def get_request(self):
(sock, addr) = WSGIServer.get_request(self)
ssock = ssl.wrap_socket(sock,
keyfile=self.keypath,
certfile=self.certpath,
server_side=True)
return (ssock, addr)
def get_unix_request(self):
sock, _ = WSGIServer.get_request(self)
cred = sock.getsockopt(socket.SOL_SOCKET,
socket.SO_PEERCRED,
self.csize)
cred = struct.unpack('3i', cred)
ret = [sock, ['pid: %i, uid: %i, gid: %i' % cred, 0]]
return ret
def run(selector):
"""Run the server provided by selector"""
print selector
exec "from " + selector + " import urls, port"
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr, os.environ) \
.run(urls)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
# with the code like this we are binding to no particular interface, matter?
httpd = WSGIServer(('', port), WSGIRequestHandler)
httpd.set_app(urls)
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def __init__(self, server_address,
RequestHandlerClass=AsyncWsgiHandler,
map=None):
if map is None:
map = {}
asyncore.dispatcher.__init__(self, map=map)
WSGIServer.__init__(self, server_address, RequestHandlerClass, False)
self._poll_func = get_poll_func()
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind(server_address)
self.listen(5)
self.server_address = self.socket.getsockname()
host, port = self.server_address[:2]
self.server_name = socket.getfqdn(host)
self.server_port = port
self.setup_environ()
def run(create_publisher, host='', port=80, handler_class=RequestHandler):
"""Runs a Quixote application using the simple server from wsgiref."""
publisher = create_publisher()
app = QWIP(publisher)
server = WSGIServer((host, port), handler_class)
server.set_app(app)
try:
server.serve_forever()
finally:
server.server_close()
def start_simple(filename, hostname, port):
"""
Start a wsgiref.simple_server to run our app.
Provides the simplest base for testing, debugging
and development.
XXX no longer used
"""
os.environ = {}
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
hostname = config["server_host"]["host"]
port = int(config["server_host"]["port"])
httpd = WSGIServer((hostname, port), WSGIRequestHandler)
httpd.set_app(load_app())
print >>sys.stderr, "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def __init__(self, server_address, url, api, is_ssl):
WSGIServer.__init__(self, server_address, ApiHandler)
self.is_ssl = is_ssl
if self.is_ssl:
self.base_environ["HTTPS"] = "yes"
app = ApiApplication(
Application([SubregCzService],
'http://subreg.cz/wsdl',
'SubregCzService',
in_protocol=Soap11(),
out_protocol=Soap11(),
config={"api": api}))
self.set_app(app)
app.doc.wsdl11.build_interface_document(url)
class TimezoneTest(unittest.TestCase):
def setUp(self):
self.port = 8000
self.url = 'localhost'
self.server = WSGIServer((self.url, self.port), WSGIRequestHandler)
self.server.set_app(timezones_app)
self.t = threading.Thread(target=self.server.serve_forever)
self.t.start()
def test_api(self):
tz_list = ('GMT', 'Europe/Moscow', 'EST')
for tz in tz_list:
response = requests.get(f'http://localhost:{self.port}/{tz}')
dt = datetime.now(timezone(tz))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'),
dt.strftime('%m.%d.%Y %H:%M:%S'))
payload = {
"first_date": "12.20.2021 22:21:05",
"first_tz": "GMT",
"second_date": "12.20.2021 22:21:05",
"second_tz": "Europe/Moscow"
}
response = requests.post(
f'http://localhost:{self.port}/api/v1/datediff', json=payload)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'), '9000.0')
payload = {
"date": "12.20.2021 22:21:05",
"tz": "Europe/Moscow",
"target_tz": "Asia/Tomsk"
}
response = requests.post(
f'http://localhost:{self.port}/api/v1/convert', json=payload)
input_dt = datetime.strptime(payload['date'], '%m.%d.%Y %H:%M:%S')
input_dt_tz = input_dt.replace(tzinfo=timezone(payload['tz']))
output_dt = input_dt_tz.astimezone(timezone(payload['target_tz']))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.decode('utf-8'),
output_dt.strftime('%m.%d.%Y %H:%M:%S'))
def tearDown(self):
self.server.shutdown()
self.t.join()
def serve(site_factory, port=0, use_reloader=False, dry=False):
"""Create a new WSGI server listening on `host` and `port` for `app`"""
server = WSGIServer(('', port), WSGIRequestHandler)
server.set_app(site_factory.wsgi())
LOGGER.info('Serving on port {0}'.format(port))
if not dry: #pragma nocover
server.serve_forever()
def runserver():
"""Lance un serveur wsgi de test, puis lui attribue l'application a
lancer avec eventuellement le chainage de middleware
"""
from pyson.middleware.error import HandleError
from pyson.middleware.log import Log
from pyson.middleware.session import Session #se wrapp automatiquement avec cookie
from pyson.middleware.force_auth import Force_auth
from pyson.middleware.http_basic import Http_basic
from pyson.middleware.formdata import Formdata
from pyson.middleware.restriction import Middle as Restriction
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr,
os.environ).run(urls.urls)
print "------------- Attention ---------------"
else:
import wsgiref
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', int(context.conf["port"])), WSGIRequestHandler)
wrapper = Session(Formdata((Restriction(urls.urls))))
httpd.set_app(wrapper)
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
class ThreadedAmfServer(object):
"""
Threaded WSGI server that doesn't block the Swing GUI.
"""
def __init__(self, host, port, serviceName):
services = {serviceName: self.echo}
gw = WSGIGateway(services, logger=logging)
self.httpd = WSGIServer((host, port),
ServerRequestLogger)
self.httpd.set_app(gw)
def start(self):
"""
Start the server.
"""
class WSGIThread(lang.Runnable):
"""
Create a thread for the server.
"""
def run(this):
try:
self.httpd.serve_forever()
except lang.InterruptedException:
return
self.thread = lang.Thread(WSGIThread())
self.thread.start()
def stop(self):
"""
Stop the server.
"""
self.thread = None
def echo(self, data):
"""
Just return data back to the client.
"""
return data
class ThreadedAmfServer(object):
"""
Threaded WSGI server that doesn't block the Swing GUI.
"""
def __init__(self, host, port, serviceName):
services = {serviceName: self.echo}
gw = WSGIGateway(services, logger=logging)
self.httpd = WSGIServer((host, port), ServerRequestLogger)
self.httpd.set_app(gw)
def start(self):
"""
Start the server.
"""
class WSGIThread(lang.Runnable):
"""
Create a thread for the server.
"""
def run(this):
try:
self.httpd.serve_forever()
except lang.InterruptedException:
return
self.thread = lang.Thread(WSGIThread())
self.thread.start()
def stop(self):
"""
Stop the server.
"""
self.thread = None
def echo(self, data):
"""
Just return data back to the client.
"""
return data
def get_request(self):
sock, addr = WSGIServer.get_request(self)
if len(self.clients) >= self.limit:
# Too many clients, disconnect idle ones.
self.kill_idle_clients()
if len(self.clients) >= self.limit:
# We _still_ have too many connected non-idle clients. We
# can't accept this request.
return sock.close()
client = NonBlockingClient(self, sock, addr)
self.clients[client] = time.time()
log.debug2('new client [%d]: %s:%d', client.fileno(), *addr)
return client, addr
class MyWSGIServer(WSGIServer):
"""
I override WSGIServer to make it possibly IPV6-able.
"""
def __init__(self, (host, port), handler_class):
ipv = self.address_family = AF_INET
if ktbs_config.get('server', 'force-ipv4', 1):
info = getaddrinfo(host, port, AF_INET, SOCK_STREAM)
else:
info = getaddrinfo(host, port, 0, SOCK_STREAM)
# when IPV6 is available, prefer it to IPV4
if [i for i in info if i[0] == AF_INET6]:
ipv = self.address_family = AF_INET6
LOG.info("Using IPV%s" % {AF_INET: 4, AF_INET6: 6}[ipv])
WSGIServer.__init__(self, (host, port), handler_class)
def run():
import urls
if os.environ.get('REQUEST_METHOD', ''):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(
sys.stdin, sys.stdout, sys.stderr, os.environ).run(urls.urls)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', 8080), WSGIRequestHandler)
httpd.set_app(urls.urls)
print "Server HTTP on %s port %s..." % httpd.socket.getsockname()
httpd.serve_forever()
def run():
import urls
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
f = file("log", "a")
BaseCGIHandler(sys.stdin, sys.stdout, f, os.environ).run(urls.urls)
f.close()
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', 8080), WSGIRequestHandler)
httpd.set_app(urls.urls)
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def run():
import urls
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr, os.environ) \
.run(urls.load('urls.map'))
else:
os.environ = {}
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', 8080), WSGIRequestHandler)
httpd.set_app(urls.load('urls.map'))
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def run():
import urls
if os.environ.get('REQUEST_METHOD', ''):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr,
os.environ).run(urls.urls)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', 8080), WSGIRequestHandler)
httpd.set_app(urls.urls)
host, port = httpd.socket.getsockname()[:2]
print 'Serving HTTP on {0} port {1}...'.format(host, port)
httpd.serve_forever()
class _HTTPServer(bottle.ServerAdapter):
"""
Reimplement bottle's WSGIRefServer. Override the request handler class and
add a stop() method for cleanly shutting down the server.
"""
srv = None
app = None
def run(self, handler):
# Handle the TIME_WAIT state for quick server restarts
WSGIServer.allow_reuse_address = 1
# Create the server and start it
self.srv = WSGIServer((self.host, self.port), _HTTPRequestHandler)
self.srv.set_app(self.app)
try:
self.srv.serve_forever()
finally:
self.srv.server_close()
def stop(self):
if self.srv:
self.srv.shutdown()
class GaeTestServer(object):
def __init__(self):
self.sdk_path = resolve_sdk_path()
print 'python sdk found', self.sdk_path
sys.path.insert(0, self.sdk_path)
import dev_appserver
dev_appserver.fix_sys_path()
sys.path.insert(0, 'src')
self.testbed = None
self.httpd = None
def boot_gae(self):
from google.appengine.api import memcache
from google.appengine.ext import ndb
from google.appengine.ext import testbed
from google.appengine.datastore import datastore_stub_util
self.testbed = testbed.Testbed()
self.testbed.activate()
self.policy = datastore_stub_util.PseudoRandomHRConsistencyPolicy(probability=0)
self.testbed.init_datastore_v3_stub(consistency_policy=self.policy)
self.testbed.init_memcache_stub()
def boot_web(self, port, app):
self.port = port
self.httpd = WSGIServer(('localhost', port), WSGIRequestHandler)
self.httpd.set_app(app)
def server_forever_background(self):
self.thread = threading.Thread(target=self.httpd.serve_forever)
self.thread.start()
def server_forever(self):
self.httpd.serve_forever()
def shutdown(self):
if self.testbed:
self.testbed.deactivate()
if self.httpd:
self.httpd.shutdown()
self.httpd = None
def run():
""" run server """
from users import urls
if os.environ.get("REQUEST_METHOD", ""):
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr,
os.environ).run(urls.urls)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
from beaker.middleware import SessionMiddleware
session_opts = {
'session.type': 'file',
'session.cookie_expires': True,
'session.data_dir': 'var',
}
app = SessionMiddleware(urls.urls, session_opts)
httpd = WSGIServer(('', 8080), WSGIRequestHandler)
httpd.set_app(app)
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
ret = tools.sparql_post(env)
elif path[0].lower() == 'submit':
ret = tools.submit(env)
elif env['REQUEST_METHOD'] == 'PUT':
if path[0].lower() == 'submit':
ret = tools.submit(env)
elif env['REQUEST_METHOD'] == 'DELETE':
# Not supported until authentication gets added TODO
pass
else:
# Unsupported as yet
pass
status, headers, content = ret
start_response(status, headers)
return content
if __name__ == '__main__':
if 'REQUEST_METHOD' in os.environ:
from wsgiref.handlers import BaseCGIHandler
BaseCGIHandler(sys.stdin, sys.stdout, sys.stderr, os.environ).run(run)
else:
from wsgiref.simple_server import WSGIServer, WSGIRequestHandler
httpd = WSGIServer(('', config.port), WSGIRequestHandler)
httpd.set_app(run)
print "Serving HTTP on %s port %s ..." % httpd.socket.getsockname()
httpd.serve_forever()
def __init__(self, thread_count=None, *args, **kwargs):
'''If 'thread_count' == None, we'll use multiprocessing.cpu_count() threads.'''
WSGIServer.__init__(self, *args, **kwargs)
self.thread_count = thread_count
self.pool = multiprocessing.pool.ThreadPool(self.thread_count)
def boot_web(self, port, app):
self.port = port
self.httpd = WSGIServer(('localhost', port), WSGIRequestHandler)
self.httpd.set_app(app)
def shutdown(self):
self.application.shutdown()
WSGIServer.shutdown(self)
def __init__(self, address, handler_class):
WSGIServer.__init__(self, address, handler_class)
# Update address if we are listening on a ephemeral port.
self.address = self.socket.getsockname()
def setup_environ(self):
WSGIServer.setup_environ(self)
for (k, v) in self.wsgi_env.iteritems():
self.base_environ[k] = v
@register('/update', method=['POST'])
def update_book(self, request):
return 'update book'
@register('/query', method=['GET'])
def query_book(self, request):
return 'query books'
@tramp.before_request
def judge_user(request):
return Response('Find Page')
@tramp.before_request
def judge_hello(request):
response = Response('Sorry')
response.set_status_code(404)
return response
if __name__ == '__main__':
host = '127.0.0.1'
port = 9000
server = WSGIServer((host, port), WSGIRequestHandler)
server.set_app(tramp)
print('Server Listen at: {}:{}'.format(host, port))
server.serve_forever()
from os import environ
from wsgiref.simple_server import WSGIServer
from main import app
if __name__ == '__main__':
HOST = environ.get('SERVER_HOST', 'localhost')
app.secret_key = "SuPeR_SeCReT_KeY"
try:
PORT = int(environ.get('SERVER_PORT', '5555'))
except ValueError:
PORT = 5555
app.run(HOST, PORT, debug=True, threaded=True)
server = WSGIServer(("", 5000), app)
server.serve_forever()
def __init__(self, server_address, app = None, RequestHandlerClass = WSGIRequestHandler): _WSGIServer.__init__(self, server_address, RequestHandlerClass) self.set_app(app)
def __init__(self, host, port, serviceName):
services = {serviceName: self.echo}
gw = WSGIGateway(services, logger=logging)
self.httpd = WSGIServer((host, port),
ServerRequestLogger)
self.httpd.set_app(gw)
def handle_error(self, request, client_address):
if not should_ignore(sys.exc_info()):
WSGIServer.handle_error(self, request, client_address)
def __init__(self, *args, **kwargs):
for (k, d) in (('address_family', AF_INET), ('wsgi_env', {})):
setattr(self, k, kwargs.pop(k, d))
WSGIServer.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
WSGIServer.__init__(self, *args, **kwargs)
def shape_text(this_cls, doc=pydoc.plaintext):
attrs = [
(name, kind) for name, kind, cls, _ in pydoc.classify_class_attrs(this_cls)
if cls == this_cls
]
attrs = [
(name, kind) for name, kind in attrs if not (name.startswith("__") and name.endswith("__"))
]
method_names = [name for name, kind in attrs if kind == "method"]
content = doc.indent("".join([doc.document(getattr(this_cls, name)) for name in method_names]))
mro = " <- ".join([cls.__name__ for cls in this_cls.mro()])
return "\n".join([mro, content])
def grep_by_indent(s, level, rx=re.compile("^\s+")):
for line in s.split("\n"):
m = rx.search(line)
if m is None or len(m.group(0)) <= level:
yield line
from matplotlib.backends.backend_svg import RendererSVG # noqa
# from collections import ChainMap
from wsgiref.simple_server import WSGIServer
for cls in WSGIServer.mro():
if cls == object:
break
text = shape_text(cls)
print("\n".join(grep_by_indent(text, 4)))
def make_server(host, port, app):
server = WSGIServer((host, port), WSGIRequestHandler)
server.set_app(app)
return server
