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): (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()
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()
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