def serve(blocking = False): ws_server = WSGIServer(('localhost', int(Config.get('server', 'ws_port'))), WebSocketWSGIApplication(handler_cls=_LAUWebSocketHandler)) if blocking == True: ws_server.serve_forever() # Non-blocking serve else: ws_server.start() # Non-blocking serve pass pass
class WSServer(object): def __init__(self, listen, app_factory): WSServerTransport.APP_FACTORY = app_factory self._listen = listen def server_forever(self): self._server = WSGIServer(self._listen, WebSocketWSGIApplication(handler_cls=WSServerTransport), log=logging.getLogger('websocket server')) log.info("Starting websocket server on {0}".format(self._listen)) self._server.serve_forever()
def run_gevent_server(host="127.0.0.1", port=9001): from gevent import monkey; monkey.patch_all() from ws4py.websocket import EchoWebSocket from ws4py.server.geventserver import WebSocketWSGIApplication, WSGIServer server = WSGIServer((host, port), WebSocketWSGIApplication(handler_cls=EchoWebSocket)) logger = logging.getLogger('autobahn_testsuite') logger.warning("Serving gevent server on %s:%s" % (host, port)) server.serve_forever()
def serve(blocking=False): ws_server = WSGIServer( ('localhost', int(Config.get('server', 'ws_port'))), WebSocketWSGIApplication(handler_cls=_LAUWebSocketHandler)) if blocking == True: ws_server.serve_forever() # Non-blocking serve else: ws_server.start() # Non-blocking serve pass pass
def serve(wsgi_app, global_config, **kw): ws_handler = kw.get('websocket_resource') host = kw.get('host', '0.0.0.0') port = int(kw.get('port', 8080)) print('Starting WebSocket (ws4py) enabled Gevent HTTP server on http://%s:%s' % ( host, port)) s = WSGIServer((host, port), WrapWebSocket(host, port, wsgi_app, ws_handler)) s.serve_forever()
def run_gevent_server(host="127.0.0.1", port=9001): from gevent import monkey monkey.patch_all() from ws4py.websocket import EchoWebSocket from ws4py.server.geventserver import WebSocketWSGIApplication, WSGIServer server = WSGIServer((host, port), WebSocketWSGIApplication(handler_cls=EchoWebSocket)) logger = logging.getLogger("autobahn_testsuite") logger.warning("Serving gevent server on %s:%s" % (host, port)) server.serve_forever()
class WSServer(object): def __init__(self, listen, app_factory): WSServerTransport.APP_FACTORY = app_factory self._listen = listen def server_forever(self): self._server = WSGIServer( self._listen, WebSocketWSGIApplication(handler_cls=WSServerTransport)) log.info("Starting server on {0}".format(self._listen)) self._server.serve_forever()
def run_gevent_server(host="127.0.0.1", port=9001): """ Runs a gevent server on Python 2.x """ from gevent import monkey; monkey.patch_all() import wsaccel wsaccel.patch_ws4py() from ws4py.websocket import EchoWebSocket from ws4py.server.geventserver import WebSocketWSGIApplication, WSGIServer server = WSGIServer((host, port), WebSocketWSGIApplication(handler_cls=EchoWebSocket)) logger = logging.getLogger('autobahn_testsuite') logger.warning("Serving gevent server on %s:%s" % (host, port)) server.serve_forever()
class WSDemoServer(threading.Thread): '''A threaded wrapper around the websockets server so that we can run the Flask and Websockets in parallel together. Args: port (int): The port number for the Websockets server to run on. ''' def __init__(self, host, port): threading.Thread.__init__(self) self.log = logs.Logger('WebSocketsServer').getLogger() self.port = int(port) self.host = host self.daemon = True self.flag = True self.server = WSGIServer((self.host, self.port), WSDemoApp()) pass def run(self): '''Runs the threaded server Args: N/A Returns: N/A ''' self.log.info('Starting websockets server') self.server.serve_forever() def broadcast(self, data): '''A wrapper on the server's broadcast method so that it can be easily accessed from the flask application Args: data (str): A string message to send to the client. Returns: N/A ''' self.server.application.broadcast(data) def stop(self): '''Stops the websockets server''' self.server.stop()
def run_server(host, port, routes): compiled_routes = [(re.compile(route), app) for route, app in routes] def router(environ, start_response): query_path = environ.get('PATH_INFO', '') for route, app in compiled_routes: if route.match(query_path): if hasattr(app, 'get_wsgi_application'): app = app.get_wsgi_application() return app(environ, start_response) start_response("404 Not Found", [('Content-type', 'text/plain')]) return [] server = WSGIServer((host, port), router) server.serve_forever()
def main(address=None): args = parser.parse_args() conf = create_settings(args=args) address = address or conf.get_address() print('Run', address) server = WSGIServer(address, SessionServer(handler_cls=SessionClient)) session = setup_session(server, settings=conf) server.environ['WEBSOCKET_SESSION'] = session try: server.serve_forever() except KeyboardInterrupt as e: print('.. Stopped') session.close() server.stop() server.close()
def main(): import argparse from ws4py import configure_logger configure_logger() parser = argparse.ArgumentParser(description='Twister Server') parser.add_argument('--host', default='127.0.0.1') parser.add_argument('-p', '--port', default=9000, type=int) args = parser.parse_args() server = WSGIServer((args.host, args.port), WebSocketWSGIApplication(handler_cls=Twister)) print "Twister running on %s:%s" % (args.host, args.port) server.serve_forever()
class WSDemoServer(threading.Thread): '''A threaded wrapper around the websockets server so that we can run the Flask and Websockets in parallel together. Args: port (int): The port number for the Websockets server to run on. ''' def __init__(self, host, port): threading.Thread.__init__(self) self.log = logs.Logger('WebSocketsServer').getLogger() self.port = int(port) self.host = host self.daemon = True self.flag = True self.server = WSGIServer((self.host, self.port), WSDemoApp()) pass def run(self): '''Runs the threaded server Args: N/A Returns: N/A ''' self.log.info('Starting websockets server') self.server.serve_forever() def broadcast(self, data): '''A wrapper on the server's broadcast method so that it can be easily accessed from the flask application Args: data (str): A string message to send to the client. Returns: N/A ''' self.server.application.broadcast(data) def stop(self): '''Stops the websockets server''' self.server.stop()
to_id = int(data['oid']) channel = '%s-%d' % (to_type, to_id) from_type = self.user_type from_id = self.obj.oid msg['path'] = data['path'] msg['from_type'] = from_type msg['from_id'] = from_id if 'body' in msg: created_at = Message.save(from_type, from_id, to_type, to_id, msg['body']) msg['created_at'] = created_at ret = self.redis.publish(channel, json.dumps(msg)) return {'status': 'ok'} def message(self, data): print 'message.data:', data msg = { 'body': data['body'] } return self._message(data, msg) def typing(self, data): msg = { 'typing': data['typing'] } # True | False return self._message(data, msg) ### API methods END ### server = WSGIServer(('0.0.0.0', 9000), WebSocketWSGIApplication(handler_cls=ChatWebSocket)) server.serve_forever()
class WebfrontEngine(object): """ The client-facing web interface. """ def __init__(self): logger.debug("Initializing webfront engine...") global webfront webfront = self self._http_listener = None self._https_listener = None self.listen_port = 5000 self.listen_addr = '127.0.0.1' self.secure_listen_port = 0 # 0 means not binding self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port,) self.secure_base_url = "https://127.0.0.1:%d/" % \ (self.secure_listen_port,) self._token = None @property def access_token(self): return self._token def _acquire_access_token(self): self._token = os.environ.get('AVA_ACCESS_TOKEN', base58.b58encode(os.urandom(16))) def start(self, ctx=None): logger.debug("Starting webfront engine...") disabled = settings[_CONF_SECTION].get('disabled') if disabled: logger.debug("Webfront is not enabled.") return self._acquire_access_token() logger.info("Access Token: %s", self._token) self.listen_port = settings[_CONF_SECTION]['listen_port'] self.listen_addr = settings[_CONF_SECTION]['listen_addr'] self.secure_listen_port = settings[_CONF_SECTION]['secure_listen_port'] self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port,) logger.debug("Local base URL:%s", self.local_base_url) if self.listen_port > 0: ctx.add_child_greenlet(gevent.spawn(self._run_http)) if self.secure_listen_port > 0: ctx.add_child_greenlet(gevent.spawn(self._run_https)) else: logger.debug("HTTPS listener is disabled.") ctx.bind('webfront', self) logger.debug("Webfront engine started.") def stop(self, ctx=None): logger.debug("Webfront engine stopped.") def _run_https(self): logger.debug("Webfront engine(HTTPS) is running...") conf_dir = environ.conf_dir() keyfile = os.path.join(conf_dir, 'ava.key') certfile = os.path.join(conf_dir, 'ava.crt') self._https_listener = WSGIServer( (self.listen_addr, self.secure_listen_port), dispatcher, keyfile=keyfile, certfile=certfile) logger.debug("Webfront engine(HTTPS) is listening on port: %d", self._https_listener.address[1]) self._https_listener.serve_forever() def _run_http(self): logger.debug("Webfront engine(HTTP) is running...") self._http_listener = WSGIServer( (self.listen_addr, self.listen_port), dispatcher) logger.debug("Webfront engine(HTTP) is listening on port: %d", self._http_listener.address[1]) self._http_listener.serve_forever()
try: from gunicorn.workers.ggevent import GeventPyWSGIWorker, PyWSGIHandler class WSGIHandler(PyWSGIHandler, WebSocketWSGIHandler): pass class Worker(GeventPyWSGIWorker): """Worker for Gunicorn. """ server_class = WSGIServer wsgi_handler = WSGIHandler except ImportError: pass REDIS_URL = 'redis://127.0.0.1:6379/0' application = WebSocketChannelApp(redis_url=REDIS_URL) if __name__ == '__main__': logger = ws4py.configure_logger(level='INFO') parser = argparse.ArgumentParser(description='Echo gevent Server') parser.add_argument('--host', default='127.0.0.1') parser.add_argument('--port', default=9000, type=int) args = parser.parse_args() server = WSGIServer((args.host, args.port), application) server.serve_forever()
class WebfrontEngine(object): """ The client-facing web interface. """ def __init__(self): logger.debug("Initializing webfront engine...") global webfront webfront = self self._http_listener = None self._https_listener = None self.listen_port = 5000 self.listen_addr = '127.0.0.1' self.secure_listen_port = 0 # 0 means not binding self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port, ) self.secure_base_url = "https://127.0.0.1:%d/" % \ (self.secure_listen_port,) self._token = None @property def access_token(self): return self._token def _acquire_access_token(self): self._token = os.environ.get('AVA_ACCESS_TOKEN', base58.b58encode(os.urandom(16))) def start(self, ctx=None): logger.debug("Starting webfront engine...") disabled = settings[_CONF_SECTION].get('disabled') if disabled: logger.debug("Webfront is not enabled.") return self._acquire_access_token() logger.info("Access Token: %s", self._token) self.listen_port = settings[_CONF_SECTION]['listen_port'] self.listen_addr = settings[_CONF_SECTION]['listen_addr'] self.secure_listen_port = settings[_CONF_SECTION]['secure_listen_port'] self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port, ) logger.debug("Local base URL:%s", self.local_base_url) if self.listen_port > 0: ctx.add_child_greenlet(gevent.spawn(self._run_http)) if self.secure_listen_port > 0: ctx.add_child_greenlet(gevent.spawn(self._run_https)) else: logger.debug("HTTPS listener is disabled.") ctx.bind('webfront', self) logger.debug("Webfront engine started.") def stop(self, ctx=None): logger.debug("Webfront engine stopped.") def _run_https(self): logger.debug("Webfront engine(HTTPS) is running...") conf_dir = environ.conf_dir() keyfile = os.path.join(conf_dir, 'ava.key') certfile = os.path.join(conf_dir, 'ava.crt') self._https_listener = WSGIServer( (self.listen_addr, self.secure_listen_port), dispatcher, keyfile=keyfile, certfile=certfile) logger.debug("Webfront engine(HTTPS) is listening on port: %d", self._https_listener.address[1]) self._https_listener.serve_forever() def _run_http(self): logger.debug("Webfront engine(HTTP) is running...") self._http_listener = WSGIServer((self.listen_addr, self.listen_port), dispatcher) logger.debug("Webfront engine(HTTP) is listening on port: %d", self._http_listener.address[1]) self._http_listener.serve_forever()
class WSServer(object): def __init__(self, listen, request_handler, msg_handler_pool_size=1024, indent='indented', pingpong_trigger=0, pingpong_timeout=0, keyfile=None, certfile=None): """ :param listen: string ip:port :param request_handler: instance of januscloud.proxy.core.request:RequestHandler :param msg_handler_pool_size: :param keyfile: :param certfile: """ if msg_handler_pool_size == 0: msg_handler_pool_size = None self._msg_handler_pool = Pool(size=msg_handler_pool_size) self._request_handler = request_handler self._listen = listen if keyfile or certfile: self._server = WSGIServer( self._listen, WebSocketWSGIApplication(protocols=['janus-protocol'], handler_cls=WSServerConn), log=logging.getLogger('websocket server'), keyfile=keyfile, certfile=certfile) else: self._server = WSGIServer( self._listen, WebSocketWSGIApplication(protocols=['janus-protocol'], handler_cls=WSServerConn), log=logging.getLogger('websocket server'), ) self._server.set_environ({ 'app.recv_msg_cbk': self._async_incoming_msg_handler, 'app.closed_cbk': self._request_handler.transport_gone, 'json_indent': indent, 'pingpong_trigger': pingpong_trigger, 'pingpong_timeout': pingpong_timeout }) def serve_forever(self): log.info("Starting websocket server on {0}".format(self._listen)) self._server.serve_forever() def stop(self): self._server.stop() def _async_incoming_msg_handler(self, transport_session, message, exception_handler): greenlet = Greenlet( self._incoming_msg_handler, transport_session, message, ) greenlet.link_exception(exception_handler) self._msg_handler_pool.start(greenlet, blocking=True) def _incoming_msg_handler(self, transport_session, message): if self._request_handler: response = self._request_handler.incoming_request( Request(transport_session, message)) if response: transport_session.send_message(response)
class ConnectionServer: def __init__(self, host, port, public_address, registration_port): self.server = WSGIServer((host, port), ConnectionApplication(self)) self.public_address = public_address self.game_servers = [] self.next_gs_port = port + 1 self.next_loader_port = registration_port + 1 self.loaders = [] self.requested_games = [] self.registration_port = registration_port self.registration_server = StreamServer((host, self.registration_port), self.handle_registration) self.registration_server.start() def find_game_server(self, message): game_id = int(message["GameID"]) server = None for game_server in self.game_servers: if game_server["game_id"] == game_id: return ConnectProtocol.AvailabilityStates.AVAILABLE, game_server if server is None: response = ConnectProtocol.AvailabilityStates.PENDING, None if game_id in self.requested_games: print "server to be created is already requested" else: if os.path.isfile("server/data/replays/{}.dem".format(game_id)): self.create_game_server(game_id) else: response = ConnectProtocol.AvailabilityStates.UNAVAILABLE, None return response def handle_registration(self, socket_, address): message = socket_.recv(1024) data = message.split(" ") if data[0] == "GAME_SERVER" and len(data) is 4: server = dict() server["host"] = data[1] server["port"] = int(data[2]) server["game_id"] = int(data[3]) print "registered game server for game {} at ({},{})".format(server["game_id"], server["host"], server["port"]) self.game_servers.append(server) self.requested_games.remove(server["game_id"]) socket_.sendall("ACCEPTED") elif data[0] == "REMOVE_GAME_SERVER" and len(data) is 2: print "removed game server at host" self.game_servers[:] = [s for s in self.game_servers if s["game_id"] != int(data[1])] socket_.sendall("ACCEPTED") elif data[0] == "LOADER" and len(data) is 3: loader = dict() loader["game_id"] = int(data[1]) loader["port"] = int(data[2]) print "registered loader for game {} at port {}".format(loader["game_id"], loader["port"]) self.loaders.append(loader) socket_.sendall("ACCEPTED") if loader["game_id"] in self.requested_games: self.create_game_server(loader["game_id"]) elif data[0] == "REMOVE_LOADER" and len(data) is 2: print "removed loader at host" self.loaders[:] = [l for l in self.loaders if l["game_id"] != int(data[1])] socket_.sendall("ACCEPTED") else: socket_.sendall("ERROR") print "Bad message: {} parsed: {}".format(message, data) print "{}, {}, {}".format(data[0] == "GAME_SERVER", data[0] == "LOADER", len(data)) socket_.close() def create_game_server(self, game_id): print "Trying to create server for game {}".format(game_id) loader_port = -1 for loader in self.loaders: if loader["game_id"] == game_id: loader_port = loader["port"] break if loader_port < 0: print "Spawning Loader" loader_port = self.next_loader_port subprocess.Popen(["python", "server/executables/loader_main.py", str(game_id), str(loader_port), str(self.registration_port)]) self.next_loader_port += 1 self.requested_games.append(game_id) else: print "Creating server for game {} that registers at {}".format(game_id, self.registration_port) subprocess.Popen(["python", "server/executables/gameserver_main.py", str(game_id), str(self.next_gs_port), str(self.registration_port), self.public_address, str(loader_port)]) self.next_gs_port += 1 def start(self): self.server.serve_forever()
class WebfrontEngine(object): """ The client-facing web interface. """ def __init__(self): logger.debug("Initializing webfront engine...") self._http_listener = None self._https_listener = None self.listen_port = 5000 self.listen_addr = '127.0.0.1' self.secure_listen_port = 0 # o means not binding self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port,) def start(self, ctx=None): logger.debug("Starting webfront engine...") self.listen_port = settings[_CONF_SECTION]['listen_port'] self.listen_addr = settings[_CONF_SECTION]['listen_addr'] self.secure_listen_port = settings[_CONF_SECTION]['secure_listen_port'] self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port,) logger.debug("Local base URL:%s", self.local_base_url) if self.listen_port != 0: ctx.add_child_greenlet(gevent.spawn(self._run_http)) if self.secure_listen_port != 0: ctx.add_child_greenlet(gevent.spawn(self._run_https)) logger.debug("Webfront engine started.") def stop(self, ctx=None): logger.debug("Webfront engine stopped.") def _run_https(self): logger.debug("Webfront engine(HTTPS) is running...") conf_dir = environ.conf_dir() keyfile = os.path.join(conf_dir, 'ava.key') certfile = os.path.join(conf_dir, 'ava.crt') self._https_listener = WSGIServer( (self.listen_addr, self.secure_listen_port), dispatcher, keyfile=keyfile, certfile=certfile) logger.debug("Webfront engine(HTTPS) is listening on port: %d", self._https_listener.address[1]) self._https_listener.serve_forever() def _run_http(self): logger.debug("Webfront engine(HTTP) is running...") self._http_listener = WSGIServer( (self.listen_addr, self.listen_port), dispatcher) logger.debug("Webfront engine(HTTP) is listening on port: %d", self._http_listener.address[1]) self._http_listener.serve_forever()
def listen(self, host, port): server = WSGIServer((host, port), self.get_wsgi_application()) server.serve_forever()