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 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 __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
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 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_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 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 __init__(self, hostname, port): PadBaseServer.__init__(self, hostname, port) pad_server = self class PadWsApplication(WebSocketWSGIApplication): def make_websocket(self, sock, protocols, extensions, environ): connection = WebSocketWSGIApplication.make_websocket(self, sock, protocols, extensions, environ) connection.conn_id = sock.fileno() pad_server.new_connection(connection) return connection pass WSGIServer.__init__(self, (hostname, port), PadWsApplication(handler_cls=self.PadConnection)) self.pool = GEventWebSocketPool()
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 startupagent(self, sender, **kwargs): if not self.bind_web_address: _log.info('Web server not started.') return import urlparse parsed = urlparse.urlparse(self.bind_web_address) hostname = parsed.hostname port = parsed.port _log.info('Starting web server binding to {}:{}.' \ .format(hostname, port)) self.registeredroutes.append( (re.compile('^/discovery/$'), 'callable', self._get_discovery)) self.registeredroutes.append( (re.compile('^/discovery/allow$'), 'callable', self._allow)) self.registeredroutes.append( (re.compile('^/$'), 'callable', self._redirect_index)) port = int(port) vhome = os.environ.get('VOLTTRON_HOME') logdir = os.path.join(vhome, "log") if not os.path.exists(logdir): os.makedirs(logdir) self.appContainer = WebApplicationWrapper(self, hostname, port) svr = WSGIServer((hostname, port), self.appContainer) self._server_greenlet = gevent.spawn(svr.serve_forever)
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()
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 __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 __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 _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 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 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 __init__(self, host, port, public_address, game_id): self.host = host self.port = port self.public_address = public_address self.clients = [] self.game_id = game_id self.game = Game() self.server = WSGIServer((host, port), GameApplication(self)) self.subscribers = dict() self.subscribers["Current"] = [] self.subscribers["Past"] = [] self.subscribers["Event"] = [] self.running = True self.webserver_thread = Thread(target=self.server.serve_forever, args=(0.5,)) self.past_subscribers_thread = Thread(target=self.serve_past_subscribers) self.timeout_thread = Thread(target=self.timeout)
from ws4py.websocket import WebSocket class ExampleServer(WebSocket): def received_message(self, message): print(message) super().received_message(message) if __name__ == '__main__': from gevent import monkey monkey.patch_all() from ws4py.server.geventserver import WSGIServer from ws4py.server.wsgiutils import WebSocketWSGIApplication server = WSGIServer(('localhost', 9000), WebSocketWSGIApplication(handler_cls=ExampleServer)) 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 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()
$('#message').val(""); return false; }); }); </script> </head> <body> <form action='#' id='chatform' method='get'> <textarea id='chat' cols='35' rows='10'></textarea> <br /> <label for='message'>%(username)s: </label><input type='text' id='message' /> <input id='send' type='submit' value='Send' /> </form> </body> </html> """ % {'username': "******" % random.randint(0, 100), 'host': self.host, 'port': self.port} if __name__ == '__main__': from ws4py import configure_logger configure_logger() parser = argparse.ArgumentParser(description='Echo gevent 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), EchoWebSocketApplication(args.host, args.port)) server.serve_forever()
} logging.exception(exception) handler = self.handler(request, response) return handler.get() app.error_handlers[403] = Webapp2HandlerAdapter(errors.Error403Handler) app.error_handlers[404] = Webapp2HandlerAdapter(errors.Error404Handler) app.error_handlers[503] = Webapp2HandlerAdapter(errors.Error503Handler) app.error_handlers[500] = Webapp2HandlerAdapter(errors.Error500Handler) if __name__ == '__main__': logger = logging.getLogger() logger.setLevel(logging.DEBUG) http_server = WSGIServer(('', 8080), app) ws_server = WSGIServer(('', 9000), WebSocketWSGIApplication(handler_cls=sample_websocket.Commands)) greenlets = [ gevent.spawn(http_server.serve_forever), gevent.spawn(utils.background_service), gevent.spawn(ws_server.serve_forever) ] try: gevent.joinall(greenlets) except KeyboardInterrupt: http_server.stop() print 'Stopping'
def startupagent(self, sender, **kwargs): import urlparse parsed = urlparse.urlparse(self.bind_web_address) ssl_key = self.web_ssl_key ssl_cert = self.web_ssl_cert if parsed.scheme == 'https': # Admin interface is only availble to rmq at present. if self.core.messagebus == 'rmq': self._admin_endpoints = AdminEndpoints( self.core.rmq_mgmt, self._certs.get_cert_public_key( get_fq_identity(self.core.identity))) if ssl_key is None or ssl_cert is None: # Because the master.web service certificate is a client to rabbitmq we # can't use it directly therefore we use the -server on the file to specify # the server based file. base_filename = get_fq_identity(self.core.identity) + "-server" ssl_cert = self._certs.cert_file(base_filename) ssl_key = self._certs.private_key_file(base_filename) if not os.path.isfile(ssl_cert) or not os.path.isfile(ssl_key): self._certs.create_ca_signed_cert(base_filename, type='server') hostname = parsed.hostname port = parsed.port _log.info('Starting web server binding to {}://{}:{}.'.format( parsed.scheme, hostname, port)) # Handle the platform.web routes here. self.registeredroutes.append( (re.compile('^/discovery/$'), 'callable', self._get_discovery)) self.registeredroutes.append( (re.compile('^/discovery/allow$'), 'callable', self._allow)) # these routes are only available for rmq based message bus # at present. if self.core.messagebus == 'rmq': # We need reference to the object so we can change the behavior of # whether or not to have auto certs be created or not. self._csr_endpoints = CSREndpoints(self.core) for rt in self._csr_endpoints.get_routes(): self.registeredroutes.append(rt) for rt in self._admin_endpoints.get_routes(): self.registeredroutes.append(rt) ssl_private_key = self._certs.get_private_key( get_fq_identity(self.core.identity)) for rt in AuthenticateEndpoints(ssl_private_key).get_routes(): self.registeredroutes.append(rt) static_dir = os.path.join(os.path.dirname(__file__), "static") self.registeredroutes.append((re.compile('^/.*$'), 'path', static_dir)) port = int(port) vhome = os.environ.get('VOLTTRON_HOME') logdir = os.path.join(vhome, "log") if not os.path.exists(logdir): os.makedirs(logdir) self.appContainer = WebApplicationWrapper(self, hostname, port) if ssl_key and ssl_cert: svr = WSGIServer((hostname, port), self.appContainer, certfile=ssl_cert, keyfile=ssl_key) else: svr = WSGIServer((hostname, port), self.appContainer) self._server_greenlet = gevent.spawn(svr.serve_forever)
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 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 listen(self, host, port): server = WSGIServer((host, port), self.get_wsgi_application()) server.serve_forever()
def closed(self, code, reason): print(("Closed down", code, reason)) def received_message(self, m): self.cnt += 1 if self.cnt < 1000: self.send(msg) else: self.close(reason='Bye bye') print(time.time() - self.started_at) global patched if not patched: patched = True wsaccel.patch_ws4py() start_client() else: server.stop() def start_client(): ws = EchoClient('ws://127.0.0.1:9000/ws') ws.connect() if __name__ == '__main__': server = WSGIServer(('127.0.0.1', 9000), EchoWebSocketApplication()) server.start() start_client() while not server.closed: gevent.sleep(1)
from ws4py.websocket import WebSocket from ws4py.server.geventserver import WSGIServer from ws4py.server.wsgiutils import WebSocketWSGIApplication import time, random class EchoWebSocket(WebSocket): def received_message(self, message): """ Automatically sends back the provided ``message`` to its originating endpoint. """ print message.__dict__ while True: try: value = random.uniform(50, 900000) s = "x" * int(value) self.send(s, message.is_binary) time.sleep(0.01) print "send " + str(value) except BaseException: print "error" server = WSGIServer(('0.0.0.0', 9700), WebSocketWSGIApplication(handler_cls=EchoWebSocket)) server.serve_forever()
dest="emulate", action="store_true", help="Emulate the hw interface") parser.add_option("-d", "--debug", dest="debug", action="store_true", help="Provide some debugging output") (options, args) = parser.parse_args() DEBUG = options.debug dirname = os.path.dirname(sys.argv[0]) controller = SingleVolumeController(dirname, options) try: server = WSGIServer(('', 8888), WebSocketWSGIApplication(handler_cls=VolumeServer)) def handleHup(signum, frame): print 'SIGHUP received: taking no action...' def handleTerm(signum, frame): print 'SIGTERM received: closing down...' server.stop() signal.signal(signal.SIGHUP, handleHup) signal.signal(signal.SIGTERM, handleTerm) server.serve_forever() except KeyboardInterrupt: pass except Termination:
class HQCWebSocketApplication(object): def __init__(self, host, port): self.host = host self.port = port self.ws = WebSocketWSGIApplication(handler_cls=HQCWebSocket) self.clients = [] # TODO: remove clients when they exit self.current_clients = {} def __call__(self, environ, start_response): environ['ws4py.app'] = self return self.ws(environ, start_response) if __name__ == '__main__': try: try: PORT = int(sys.argv[1]) except IndexError: PORT = 9000 print "Port not specified" server = WSGIServer(('0.0.0.0', PORT), HQCWebSocketApplication('localhost', PORT)) print "Running server on port " + str(PORT) server.serve_forever() except KeyboardInterrupt: server.close() except socket.error: print "Server could not start properly. The socket may already be bound by another instance."
def run_server(host, port, application, kill_event): server = WSGIServer((host, port), application) server.start() while not kill_event.is_set(): sleep(0.1)
to_append = {} if obj['expected'] else [] #print obj['expected'], row for x in range(len(row)) : if type(to_append) == type({}) : to_append[obj['expected'][x]] = row[x] else : to_append.append(row[x]) out[obj['name']].append(to_append) except Exception as e : print "failed:", e if jobj.has_key('subsequent') : out['subsequent'] = jobj['subsequent'] to_prune = [] if jobj.has_key('return') : for key in WSM.keys() : if WSM[key].terminated : to_prune.append(key) elif (jobj['return'] == "*") or re.match(jobj['return'], key) : WSM[key].send(json.dumps(out), False) for key in to_prune : del WSM[key] server = WSGIServer((_HOST_NAME, _PORT_NUMBER), WebSocketWSGIApplication(handler_cls=Engraver)) print time.asctime(), "Server Starts - %s:%s" % (_HOST_NAME, _PORT_NUMBER) try: server.serve_forever() except KeyboardInterrupt: pass server.server_close() print time.asctime(), "Server Stops - %s:%s" % (_HOST_NAME, _PORT_NUMBER)
monkey.patch_all() from ws4py.websocket import EchoWebSocket from ws4py.server.geventserver import WSGIServer from ws4py.server.wsgiutils import WebSocketWSGIApplication class CopyPastaSocket(WebSocket): def received_message(self, message): self.send(CopyPasta.generate_copy_pasta(message.data), message.is_binary) print(message.data) self.send(CopyPasta.generate_copy_pasta(message.data), message.is_binary) server = WSGIServer(('localhost', 3001), WebSocketWSGIApplication(handler_cls=CopyPastaSocket)) server.serve_forever() # @asyncio.coroutine # def hello(websocket, path): # message = yield from websocket.recv() # print("Received message {}".format(message)) # result = CopyPasta.generate_copy_pasta(message) # yield from websocket.send(result) # print("Sent message: {}".format(result)) # start_server = websockets.serve(hello, 'localhost', 3001) # asyncio.get_event_loop().run_until_complete(start_server) # asyncio.get_event_loop().run_forever()
from gevent import monkey; monkey.patch_all() from ws4py.websocket import EchoWebSocket from ws4py.server.geventserver import WSGIServer from ws4py.server.wsgiutils import WebSocketWSGIApplication server = WSGIServer(('localhost', 8088), WebSocketWSGIApplication(handler_cls=EchoWebSocket)) server.serve_forever()
start_response(status, headers) return PAGE % { 'username': "******" % random.randint(0, 100), 'host': self.host, 'port': self.port } class NoLog(object): def write(*args, **kw): pass if __name__ == '__main__': parser = argparse.ArgumentParser(description='Echo gevent 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), EchoWebSocketApplication(args.host, args.port), log=NoLog(), backlog=100000) try: server.serve_forever() except KeyboardInterrupt: pass
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()
def main(): config = copy.deepcopy(SHARED_DEFAULTS) parser = argparse.ArgumentParser(add_help=True) parser.add_argument( "-i", "--ini", dest="ini", help="Config file path", default=None ) parser.add_argument( "-v", "--version", dest="version", help="Print version info and exit", default=None, nargs="*", ) args = parser.parse_args() if args.version is not None: print(channelstream.__version__) exit() ini_path = args.ini or os.environ.get("CHANNELSTREAM_INI") # set values from ini/cli if ini_path: parser = configparser.ConfigParser() parser.read(ini_path) settings = dict(parser.items("channelstream")) for key in CONFIGURABLE_PARAMS: try: config[key] = settings[key] except KeyError: pass else: for key in CONFIGURABLE_PARAMS: conf_value = os.environ.get(f"channelstream_{key}".upper()) if conf_value is not None: config[key] = conf_value config = set_config_types(config) log_level = getattr(logging, (config.get("log_level") or "INFO").upper()) logging.basicConfig(level=log_level) log.setLevel(log_level) log.debug(pprint.pformat(config)) log.info("Starting channelstream {}".format(channelstream.__version__)) url = "http://{}:{}".format(config["host"], config["port"]) log.info("Starting flash policy server on port 10843") gevent.spawn(gc_conns_forever) gevent.spawn(gc_users_forever) server = StreamServer(("0.0.0.0", 10843), client_handle) server.start() log.info("Serving on {}".format(url)) log.info("Admin interface available on {}/admin".format(url)) if config["secret"] == "secret": log.warning("Using default secret! Remember to set that for production.") if config["admin_secret"] == "admin_secret": log.warning("Using default admin secret! Remember to set that for production.") log.warning(f"IP's allowed to post to API {config['allow_posting_from']}") server = WSGIServer( (config["host"], config["port"]), RoutingApplication(config), log=logging.getLogger("channelstream.WSGIServer"), ) server.serve_forever()
def cli_start(): if sys.version_info.major < 3 or (sys.version_info.major <= 3 and sys.version_info.minor < 6): logging.warning( "\n---\n Version 0.6.9 is the last version to support Python older than 3.6\n---\n" ) config = copy.deepcopy(SHARED_DEFAULTS) parser = argparse.ArgumentParser(add_help=True) parser.add_argument("-i", "--ini", dest="ini", help="Config file path", default=None) parser.add_argument("-s", "--secret", dest="secret", help="Secret used to secure your API requests") parser.add_argument("-u", "--admin_username", dest="admin_user", help="Administrator username") parser.add_argument( "-a", "--admin_secret", dest="admin_secret", help="Secret used to secure your admin panel", ) parser.add_argument("-host", "--host", dest="host", help="Host ip on which the server listens to") parser.add_argument( "-p", "--port", type=int, dest="port", help="Port on which the server listens to", ) parser.add_argument("-d", "--debug", dest="debug", help="Does nothing for now") parser.add_argument("-l", "--log-level", dest="log_level", help="Does nothing for now") parser.add_argument("-e", "--demo", dest="demo", help="Does nothing, BW.compat") parser.add_argument( "-x", "--allowed_post_ip", dest="allow_posting_from", help="comma separated list of ip's " "that can post to server", ) parser.add_argument( "-c", "--allow_cors", dest="allow_cors", help="comma separated list of domains's " "that can connect to server", ) parser.add_argument( "--validate-requests", dest="validate_requests", help="Enable timestamp check on signed requests", ) args = parser.parse_args() parameters = ( "debug", "log_level", "port", "host", "secret", "admin_user", "admin_secret", "allow_posting_from", "allow_cors", "validate_requests", ) if args.ini: parser = configparser.ConfigParser() parser.read(args.ini) settings = dict(parser.items("channelstream")) for key in parameters: try: config[key] = settings[key] except KeyError: pass else: for key in parameters: conf_value = getattr(args, key) if conf_value: config[key] = conf_value # convert types config["debug"] = asbool(config["debug"]) config["port"] = int(config["port"]) config["validate_requests"] = asbool(config["validate_requests"]) for key in ["allow_posting_from", "allow_cors"]: if not config[key]: continue try: listed = [ip.strip() for ip in config[key].split(",")] config[key] = listed except ValueError: pass log_level = getattr(logging, config.get("log_level", "INFO").upper()) logging.basicConfig(level=log_level) log.info("Starting channelstream {}".format(channelstream.__version__)) url = "http://{}:{}".format(config["host"], config["port"]) log.info("Starting flash policy server on port 10843") gc_conns_forever() gc_users_forever() server = StreamServer(("0.0.0.0", 10843), client_handle) server.start() log.info("Serving on {}".format(url)) log.info("Admin interface available on {}/admin".format(url)) if config["secret"] == "secret": log.warning( "Using default secret! Remember to set that for production.") if config["admin_secret"] == "admin_secret": log.warning( "Using default admin secret! Remember to set that for production.") server = WSGIServer( (config["host"], config["port"]), RoutingApplication(config), log=logging.getLogger("channelstream.WSGIServer"), ) server.serve_forever()
def startupagent(self, sender, **kwargs): from urllib.parse import urlparse parsed = urlparse(self.bind_web_address) ssl_key = self.web_ssl_key ssl_cert = self.web_ssl_cert rpc_caller = self.vip.rpc if parsed.scheme == 'https': # Admin interface is only availble to rmq at present. if self.core.messagebus == 'rmq': self._admin_endpoints = AdminEndpoints( rmq_mgmt=self.core.rmq_mgmt, ssl_public_key=self._certs.get_cert_public_key( get_fq_identity(self.core.identity)), rpc_caller=rpc_caller) if ssl_key is None or ssl_cert is None: # Because the master.web service certificate is a client to rabbitmq we # can't use it directly therefore we use the -server on the file to specify # the server based file. base_filename = get_fq_identity(self.core.identity) + "-server" ssl_cert = self._certs.cert_file(base_filename) ssl_key = self._certs.private_key_file(base_filename) if not os.path.isfile(ssl_cert) or not os.path.isfile(ssl_key): self._certs.create_signed_cert_files(base_filename, cert_type='server') if ssl_key is not None and ssl_cert is not None and self._admin_endpoints is None: self._admin_endpoints = AdminEndpoints( ssl_public_key=CertWrapper.get_cert_public_key(ssl_cert), rpc_caller=rpc_caller) else: self._admin_endpoints = AdminEndpoints(rpc_caller=rpc_caller) hostname = parsed.hostname port = parsed.port _log.info('Starting web server binding to {}://{}:{}.'.format( parsed.scheme, hostname, port)) # Handle the platform.web routes here. self.registeredroutes.append( (re.compile('^/discovery/$'), 'callable', self._get_discovery)) self.registeredroutes.append( (re.compile('^/discovery/allow$'), 'callable', self._allow)) self.registeredroutes.append( (re.compile(r'/gs'), 'callable', self.jsonrpc)) # these routes are only available for rmq based message bus # at present. if self.core.messagebus == 'rmq': # We need reference to the object so we can change the behavior of # whether or not to have auto certs be created or not. self._csr_endpoints = CSREndpoints(self.core) for rt in self._csr_endpoints.get_routes(): self.registeredroutes.append(rt) # Register the admin endpoints regardless of whether there is an ssl context # or not. for rt in self._admin_endpoints.get_routes(): self.registeredroutes.append(rt) # Allow authentication endpoint from any https connection if parsed.scheme == 'https': if self.core.messagebus == 'rmq': ssl_private_key = self._certs.get_pk_bytes( get_fq_identity(self.core.identity)) else: ssl_private_key = CertWrapper.get_private_key(ssl_key) for rt in AuthenticateEndpoints( tls_private_key=ssl_private_key).get_routes(): self.registeredroutes.append(rt) else: # We don't have a private ssl key if we aren't using ssl. for rt in AuthenticateEndpoints( web_secret_key=self._web_secret_key).get_routes(): self.registeredroutes.append(rt) static_dir = os.path.join(os.path.dirname(__file__), "static") self.registeredroutes.append((re.compile('^/.*$'), 'path', static_dir)) port = int(port) self.appContainer = WebApplicationWrapper(self, hostname, port) if ssl_key and ssl_cert: svr = WSGIServer((hostname, port), self.appContainer, certfile=ssl_cert, keyfile=ssl_key) else: svr = WSGIServer((hostname, port), self.appContainer) self._server_greenlet = gevent.spawn(svr.serve_forever)
class GameServer: def __init__(self, host, port, public_address, game_id): self.host = host self.port = port self.public_address = public_address self.clients = [] self.game_id = game_id self.game = Game() self.server = WSGIServer((host, port), GameApplication(self)) self.subscribers = dict() self.subscribers["Current"] = [] self.subscribers["Past"] = [] self.subscribers["Event"] = [] self.running = True self.webserver_thread = Thread(target=self.server.serve_forever, args=(0.5,)) self.past_subscribers_thread = Thread(target=self.serve_past_subscribers) self.timeout_thread = Thread(target=self.timeout) def start(self): self.webserver_thread.start() self.past_subscribers_thread.start() self.timeout_thread.start() print "Started game server on {}, {}".format(self.host, self.port) def serve_past_subscribers(self): while self.running: for subscriber, past_state in self.subscribers["Past"]: if past_state.finished(): continue updates, events = past_state.pass_time(PAST_SEND_INTERVAL*subscriber.speed) for update in updates: subscriber.send_update(update) for event in events: subscriber.send_event(event) self.subscribers["Past"][:] = [(s, ps) for s, ps in self.subscribers["Past"] if not ps.finished()] time.sleep(PAST_SEND_INTERVAL * TIME_PER_TICK) def timeout(self): timeout = SERVICE_TIMEOUT while self.running: time.sleep(TIMEOUT_INTERVAL) print "Checking Timeout" total_subscribers = len(self.subscribers["Current"])+len(self.subscribers["Past"])+len(self.subscribers["Event"]) if total_subscribers > 0 or not self.game.complete: timeout = SERVICE_TIMEOUT else: timeout -= TIMEOUT_INTERVAL print "{}".format(timeout) if timeout < 0: print "Timeout: shutting down gameserver" self.running = False self.server.stop() print "Finished timeout-thread" def find_client(self, client_id): for client in self.clients: if client.id == client_id: return client print "Couldn't find client" return None def create_client(self): client = Client(Protocols.generate_id()) self.clients.append(client) return client def remove_client(self, client): self.remove_subscriber(client) self.clients[:] = [c for c in self.clients if c.id != client.id] def provides_game(self, game_id): return self.game_id == game_id def add_subscriber(self, client, mode, time): if mode == GameProtocol.SubscribeModes.CURRENT: self.subscribers["Event"].append(client) self.subscribers["Current"].append(client) elif mode == GameProtocol.SubscribeModes.PAST: client.set_time(time) self.subscribers["Past"].append((client, self.game.past_state(time))) def remove_subscriber(self, client): self.subscribers["Event"][:] = [c for c in self.subscribers["Event"] if c.id != client.id] self.subscribers["Current"][:] = [(s, it) for s, it in self.subscribers["Past"] if s.id != client.id] self.subscribers["Past"][:] = [(s, it) for s, it in self.subscribers["Past"] if s.id != client.id] def register_update(self, update): self.game.add_update(update) for client in self.subscribers["Current"]: client.send_update(update) def register_event(self, event): self.game.add_event(event) for client in self.subscribers["Event"]: client.send_event(event) def finish(self): self.game.finish()
self.send(msg) def closed(self, code, reason): print(("Closed down", code, reason)) def received_message(self, m): self.cnt += 1 if self.cnt < 1000: self.send(msg) else: self.close(reason='Bye bye') print(time.time() - self.started_at) global patched if not patched: patched = True wsaccel.patch_ws4py() start_client() else: server.stop() def start_client(): ws = EchoClient('ws://127.0.0.1:9000/ws') ws.connect() if __name__ == '__main__': server = WSGIServer(('127.0.0.1', 9000), EchoWebSocketApplication()) server.start() start_client() while not server.closed: gevent.sleep(1)
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)
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...") 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()
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()
import os import gevent from django.core.wsgi import get_wsgi_application from gevent import pywsgi from ws4py.server.geventserver import WSGIServer from ws4py.server.wsgiutils import WebSocketWSGIApplication from implement_table.core.settings import DJANGO_HOST, WEBSOCKET_HOST from implement_table.ws.websocket import MnWebSocket os.environ.setdefault("DJANGO_SETTINGS_MODULE", "implement_table.core.settings") http_server = pywsgi.WSGIServer(DJANGO_HOST, get_wsgi_application()) ws_server = WSGIServer(WEBSOCKET_HOST, WebSocketWSGIApplication(handler_cls=MnWebSocket)) g = [ gevent.spawn(http_server.serve_forever), gevent.spawn(ws_server.serve_forever), # scheduler.start() ] gevent.joinall(g, raise_error=True) application = get_wsgi_application()