def run(self): if self._ssl_path: self.ws = WebSocketServer((self._address, self._port), Resource({ '/api/bridge': PytoWebSocketApp, '/api/device*': self.api_app, '/api/voice': self.api_app, '/': self.http_file_app }), pre_start_hook=auth_hook, keyfile=self._ssl_path + '/server.key', certfile=self._ssl_path + '/server.crt') else: self.ws = WebSocketServer((self._address, self._port), Resource({ '/api/bridge': PytoWebSocketApp, '/api/device*': self.api_app, '/api/voice': self.api_app, '/': self.http_file_app }), pre_start_hook=auth_hook) print "Serving WebSocket Connection on", self._address, "port", self._port, "..." StateDevice.onStateChangedGlobal(self.broadcast_state) self.ws.serve_forever()
def run(self): self.green_monitor() gevent.signal(signal.SIGTERM, self.kill) gevent.signal(signal.SIGUSR1, self.pdb) Application.middleware = self wsserver = WebSocketServer( ('127.0.0.1', 6000), Resource(OrderedDict([ ('/websocket', Application), ]))) restful_api = RESTfulAPI(self) apidocs_app.middleware = self apidocsserver = WSGIServer(('127.0.0.1', 8001), apidocs_app) restserver = WSGIServer(('127.0.0.1', 8002), restful_api.get_app()) fileserver = WSGIServer(('127.0.0.1', 8003), FileApplication(self)) self.__server_threads = [ gevent.spawn(wsserver.serve_forever), gevent.spawn(apidocsserver.serve_forever), gevent.spawn(restserver.serve_forever), gevent.spawn(fileserver.serve_forever), gevent.spawn(self.__jobs.run), ] self.logger.debug('Accepting connections') gevent.joinall(self.__server_threads)
def server(self): if not self._server: if self.ssl: self._server = WebSocketServer( ("0.0.0.0", self.port), Resource(OrderedDict([("/", Application)])), keyfile=self.ssl_keyfile, certfile=self.ssl_certfile, ) else: self._server = WebSocketServer( ("0.0.0.0", self.port), Resource(OrderedDict([("/", Application)]))) return self._server
def run_web_servers(port): resource = Resource( OrderedDict([('/ws', ClientConnection), ('.*', static_file_server)])) server = WebSocketServer(("", port), resource, debug=False) print "Now listening on port %d" % port server.serve_forever()
def test_high_level_echo(self): data = [] data.append("") data.append("0123456789") data.append("0123456789" * 20) data.append("0123456789" * 2000) data.append("0123456789" * 20000) data.append("0123456789" * 200000) data.append(b"") data.append(b"0123456789") data.append(b"0123456789" * 20) data.append(b"0123456789" * 2000) data.append(b"0123456789" * 20000) data.append(b"0123456789" * 200000) class EchoApplication(WebSocketApplication): def on_open(self): server.logger.info("Connection opened") def on_message(self, message): if message is None: return server.logger.info("Message received %s", len(message)) self.ws.send(message) def on_close(self, reason): server.logger.info("Connection closed %s", reason) server = WebSocketServer(self.s_socket, Resource(OrderedDict([('/', EchoApplication)])), debug=True) server.start() self.server = server try: self.server_thread = Thread(target=self.start_server) self.server_thread.start() ws = create_connection("ws://%s:%s/" % (self.server.environ["SERVER_NAME"], self.server.environ["SERVER_PORT"])) try: for i in range(2): if i == 1: ws.set_mask_key(lambda _: b'1234') for d in data: if isinstance(d, bytes): ws.send_binary(d) else: ws.send(d) self.assertEqual(ws.recv(), d) ws.ping("ping") pong = ws.recv_data_frame(10) self.assertEqual(pong[0], pong[1].OPCODE_PONG) self.assertEqual(pong[1].data, b'ping') self.assertFalse(self.err) finally: ws.close(timeout=10) finally: server.close()
def server(): s = WebSocketServer(('0.0.0.0', 8001), Resource(OrderedDict([('/', TestApplication)]))) s.start() thread = Greenlet.spawn(s.serve_forever) yield s s.stop() thread.kill()
def gevent_server_get(self, port=7766): """ returns a gevent server for j.servers.rack """ server = WebSocketServer(("", port), Resource(OrderedDict([("/", GeventGunServer)]))) return server
def run(ip='127.0.0.1', port=63482, jobq_thread_count=10): JobdWebSocketApplication.jobq_mgr = jobq.JobManager([(_parse_request, jobq_thread_count)]) WebSocketServer( (ip, port), Resource(OrderedDict({'/': JobdWebSocketApplication})), ).serve_forever()
def startMonitorServer(port=9000): logging.info("Starting monitor server in port {}".format(port)) WebSocketServer(('0.0.0.0', port), Resource({ '^/monitor_socket': MonitorSocket, '^/.*': flask_app }), debug=False).serve_forever()
def __init__(self, ssl_args, port, application=WSRpcApplication): self.port = port self.application = application patterns = {'/websocket': application} res = Resource( collections.OrderedDict( sorted(patterns.items(), key=lambda t: t[0]))) self.server = WebSocketServer(('', port), res, **ssl_args) self.protocol = PT_WEB_SOCKET
def start_service(self): port = self.options["service_port"] ip = self.options["service_ip"] print("[+]Service Started") WebSocketServer( (ip, port), Resource(OrderedDict([('/', EchoApplication)]))).serve_forever() self.HTTPServerThread.stop()
def __init__(self, ssl_args, port, application=WSRpcApplication): self.application = application patterns = {'/': application} res = Resource( collections.OrderedDict( sorted(patterns.items(), key=lambda t: t[0]))) super(WsRpcServer, self).__init__(PT_WEB_SOCKET, port, WebSocketServer(('', port), res, **ssl_args))
def init_websocket_api(): res_map = OrderedDict({ '/+websocket': WebsocketApi, }) if WSGI_APP: res_map['^(?!/+websocket)'] = WSGI_APP resource = Resource(res_map) cm = ChannelMgr() cm.add_channel("status_changes") return (resource, cm)
def websocket(): """ Run websocket flask application, SSL handled by nginx """ http_server_ws = WebSocketServer( ('127.0.0.1', 8890), Resource(OrderedDict([('/websocket/', HandlerWS)])) ) http_server_ws.serve_forever()
def run_forever(self, host='0.0.0.0', debug=False): try: dealer_server = WebSocketServer( (host, 8080), Resource(OrderedDict({'/': DealerApplication})), debug=debug) dealer_server.serve_forever() except KeyboardInterrupt: dealer_server.close() raise KeyboardInterrupt
def _run(self): """启动监听器\n """ log.msg('WebSocketServer on %s' % self.port) self.factory = WebSocketServer(self.getHost(), Resource([(i, self.apps) for i in self.urls]), debug=self.debug, **self.ssl_options) self.factory.serve_forever()
def websocket(): from ._app import WebSocketInfer from collections import OrderedDict from geventwebsocket import WebSocketServer, Resource port = int(os.getenv("PORT", "8080")) host = os.getenv("HOST", "0.0.0.0") WebSocketServer( (host, port), Resource(OrderedDict([("/infer", WebSocketInfer)])) ).serve_forever()
def run(self): resource = collections.OrderedDict() resource['/api/bridge'] = PytoWebSocketApp resource['/api/device*'] = self.api_app resource['/api/voice'] = self.api_app resource['/'] = self.http_file_app if self._ssl_path: self.ws = WebSocketServer((self._address, self._port), Resource(resource), pre_start_hook=auth_hook, keyfile=self._ssl_path + '/server.key', certfile=self._ssl_path + '/server.crt') else: self.ws = WebSocketServer((self._address, self._port), Resource(resource), pre_start_hook=auth_hook) print("Serving WebSocket Connection on", self._address, "port", self._port, "...") StateDevice.onStateChangedGlobal(self.broadcast_state) self.ws.serve_forever()
def main(): "" host = config.get("HOSTDIVULGER") port = config.get("PORTDIVULGER") print(u"serving on {host}:{port}".format(**locals())) server = WebSocketServer( (host, port), Resource(OrderedDict({ "^/divulge/.+/": DivulgeApplication, })), debug=False, ) server.serve_forever()
def run(address='', port=6060, endpoint='/', static=False, debug=False): """ Run our websocket server with configured urls. """ resources = [('/ws', GuacamoleApp)] if static: # we need to serve static webapp as well resources += get_webapp_resources(debug) WebSocketServer( (address, int(port)), Resource(resources), debug=debug ).serve_forever()
def run(self): Application.middleware = self wsserver = WebSocketServer(('127.0.0.1', 6000), Resource(OrderedDict([ ('/websocket', Application), ]))) restful_api = RESTfulAPI(self) apidocs_app.middleware = self apidocsserver = WSGIServer(('127.0.0.1', 8001), apidocs_app) restserver = WSGIServer(('127.0.0.1', 8002), restful_api.get_app()) server_threads = [ gevent.spawn(wsserver.serve_forever), gevent.spawn(apidocsserver.serve_forever), gevent.spawn(restserver.serve_forever), gevent.spawn(self.__jobs.run), ] self.logger.debug('Accepting connections') gevent.joinall(server_threads)
def run(self): self.online = True manager = self class MainApplication(WebSocketApplication): def on_open(self): print("Connection opened") manager.setContext(self.ws) def on_message(self, message): print(message) data = json.loads(message) cmd = data["cmd"] if "args" in data: args = data["args"] else: args = None if cmd == 'goto': print('I will goto', data["args"]["x"], data["args"]["y"]) executor = InputExecutor(manager.robot, [data["args"]["y"], data["args"]["x"], 20, True]) executor.start() elif cmd == 'stop': print('Stop command received') manager.robot.cancelOperations() manager.robot.stopMotors() print('STOOOOP') elif cmd == 'reset_pos': print('Reset pos command') manager.robot.positionWatcher.reset() elif cmd == 'start_position_trace': print('LOG# > Enabled position trace') elif cmd == 'stop_position_trace': print('LOG# > Disabled position trace') else: print("Command not recognized") print('Start a websocket server on 0.0.0.0:8080') WebSocketServer( ('0.0.0.0', 8080), Resource(OrderedDict([('/', MainApplication)])) ).serve_forever()
def websocket_server_add(self, name="websocket", port=4444, appclass=None): from geventwebsocket import WebSocketServer, WebSocketApplication, Resource from collections import OrderedDict if not appclass: class EchoApplication(WebSocketApplication): def on_open(self): print("Connection opened") def on_message(self, message): self.ws.send(message) def on_close(self, reason): print(reason) appclass = EchoApplication server = WebSocketServer(("0.0.0.0", port), Resource(OrderedDict([("/", appclass)]))) self.add(name=name, server=server)
def gevent_websocket_server(port, path='/'): from geventwebsocket import WebSocketServer, WebSocketApplication, Resource class WebSocketRPCApplication(WebSocketApplication): def on_open(self): log.debug('conn open: %s %s', args, kwargs) def on_message(self, message): try: ret = server_call(message, self.ws.send) log.info('ret=%s', ret) if isinstance(ret, str): self.ws.send(ret) except: log.info(traceback.format_exc()) def on_close(self, reason): log.debug('conn close: %s', reason) srv = WebSocketServer(('0.0.0.0', port), Resource({path: MyApplication})) log.info('server started at:%d', port) srv.serve_forever() log.warn("stopped")
def main(): opt = process_command_line() print opt zmq_ctx = zmq.Context() resources = OrderedDict() resources['^/websocket'] = WSApplication resources['^/.*'] = app server = WebSocketServer(('0.0.0.0', opt.port), Resource(resources)) def shutdown(): print("\nShutting down...") server.stop() zmq_ctx.destroy() sys.exit() gevent.signal(signal.SIGINT, shutdown) gevent.signal(signal.SIGTERM, shutdown) server.serve_forever()
def main(): xmas = WebSocketServer( ('0.0.0.0', 8000), Resource( OrderedDict([('/xmas', client.ClientImpl), ('/interface', interface.InterfaceImpl)]))) application_state = State() application_gui = gui.GuiImpl(application_state, santa.GaOptimizingSanta(application_state)) """ So that interface can update the packages aswell. """ application_state.add_package = application_gui.add_package """ Make state reachable throughout all applications """ xmas.state = application_state try: application_gui.start() xmas.start() xmas.serve_forever() except KeyboardInterrupt: pass application_state.clean() application_gui.stop()
from gevent import monkey # type: ignore monkey.patch_all() try: from mephisto.abstractions.architects.router.flask.mephisto_flask_blueprint import ( # type: ignore MephistoRouter, mephisto_router, ) except: from mephisto_flask_blueprint import ( # type: ignore MephistoRouter, mephisto_router, ) from geventwebsocket import WebSocketServer, Resource # type: ignore from werkzeug.debug import DebuggedApplication # type: ignore from flask import Flask # type: ignore import os port = int(os.environ.get("PORT", 3000)) flask_app = Flask(__name__) flask_app.register_blueprint(mephisto_router, url_prefix=r"/") if __name__ == "__main__": WebSocketServer( ("", port), Resource([("^/.*", MephistoRouter), ("^/.*", DebuggedApplication(flask_app))]), debug=False, ).serve_forever()
'nickname': message['nickname'], 'message': message['message'], 'created_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S') })) def on_close(self, reason): """ 接続が切れた """ print("Connection closed! ") @flask_app.route('/') def index(): """ クライアント画面 """ return render_template('index.html') if __name__ == '__main__': args = getargs() print('Host: {}, Port: {}'.format(args.host, args.port)) WebSocketServer((args.host, args.port), Resource([('^/', ChatApplication), ('^/.*', DebuggedApplication(flask_app))]), debug=args.debug).serve_forever()
:param _file: path to file :return: True for file exists, Raises RuntimeError if doesn't exist """ if not os.path.isfile(_file): raise RuntimeError("The file provided does not exist! {}".format(_file)) return True if __name__ == '__main__': args = parse_args() server_args = [] server_kwargs = dict() try: scale = set_scale() except ValueError: print "ERROR: Unable to connect to the scale!!" scale = None if not args.cert and not args.key: pass elif validate_file(args.cert) and validate_file(args.key): server_kwargs.update({'keyfile': args.key, 'certfile': args.cert}) server_args.append((args.bind, args.port)) server_args.append( Resource([ ('/', static_wsgi_app), ('/data', WeightApp) ]) ) WebSocketServer(*server_args, **server_kwargs).serve_forever()
while True: gevent.sleep(settings.websocket_timeout) for uid in wss: gevent.spawn(send_message, uid, 'ping') def send_message(uid, message): try: wslist = wss[uid] except KeyError: return dead = [] for i, ws in enumerate(wslist): try: ws.send(message) except WebSocketError: log.debug('WebSocket %s (uid=%s) id dead.' % (ws, uid)) dead.append(i) wss[uid] = [i for j, i in enumerate(wss[uid]) if j not in dead] gevent.spawn(ping_sockets) log.info('ws server') WebSocketServer((settings.websocket_host, settings.websocket_port), Resource({settings.websocket_url: WsApplication})).serve_forever()