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()
class LogViewWorker(EntityWorker): def __init__(self, config_address, entity_port, http_port, ws_port): """ :param config_address: config进程的监听地址 :param entity_port: entity的服务接口 :param http_port: http的监听端口 :param ws_port: websocket的监听端口 :return: """ EntityWorker.__init__(self, "log_view", "log_view", entity_port, config_address) self._http_port = http_port self._ws_port = ws_port self._ws_server = None self._http_server = None global WS_PORT WS_PORT = ws_port def init_entity(self): self._ws_server = WebSocketServer( ('', self._ws_port), Resource(OrderedDict({"/": LogWebSocket})) ) self._ws_server.start() self._http_server = HttpConnector(self._http_port) self._http_server.add_route("/showlog", ShowLog) self._http_server.add_route("/greplog", GrepLog) self._http_server.add_route("/nodes", AllNode) self._http_server.add_route("/nodemanage", NodeManage) self._http_server.add_route("/addnode", AddNode) self._http_server.add_route("/delnode", DelNode) self._http_server.start() WebSocketManager()
class Server(Singleton): STARTED = "server_started" STOPPED = "server_stopped" def __init__(self, settings): self.settings = settings if "events" in self.settings: self.eventer = Eventer(self.settings["events"]) else: self.eventer = Eventer() self.init_controllers_mapping() def start(self): wsgi_app = Router(self) wsgi_app = SharedDataMiddleware(wsgi_app, { '/': self.settings["files"] }) self.server = None if "ssl" in self.settings: ssl_info = self.settings["ssl"] if "key" in ssl_info and "cert" in ssl_info: self.server = WebSocketServer((self.settings["application"]["address"], self.settings["application"]["port"]), wsgi_app, keyfile=ssl_info["key"], certfile=ssl_info["cert"]) if not self.server: self.server = WebSocketServer((self.settings["application"]["address"], self.settings["application"]["port"]), wsgi_app) gevent.signal(signal.SIGTERM, self.stop) gevent.signal(signal.SIGINT, self.stop) self.eventer.publish(Server.STARTED, self) try: self.server.serve_forever() except Exception, e: logger.error("start server error %s", str(e), exc_info=True)
def __init__(self, game): WebSocketServer.__init__(self, ('', 8000), Resource({'/': PlayerSocket})) self.players = {} self.nextid = 0 self.packer = msgpack.Packer() self.unpacker = msgpack.Unpacker() self.game = game
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 server(): s = WebSocketServer( ('0.0.0.0', 8001), Resource(OrderedDict([('/', WsApplication)])) ) s.start() thread = Greenlet.spawn(s.serve_forever) yield s s.stop() thread.kill()
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 serve_forever(self, server): self.wss = WebSocketServer( (self.address, self.port), ServerResource(self.apps, server), **self.kwargs ) self.wss.serve_forever()
def start(self): wsgi_app = Router(self) wsgi_app = SharedDataMiddleware(wsgi_app, { '/': self.settings["files"] }) self.server = None if "ssl" in self.settings: ssl_info = self.settings["ssl"] if "key" in ssl_info and "cert" in ssl_info: self.server = WebSocketServer((self.settings["application"]["address"], self.settings["application"]["port"]), wsgi_app, keyfile=ssl_info["key"], certfile=ssl_info["cert"]) if not self.server: self.server = WebSocketServer((self.settings["application"]["address"], self.settings["application"]["port"]), wsgi_app) gevent.signal(signal.SIGTERM, self.stop) gevent.signal(signal.SIGINT, self.stop) self.eventer.publish(Server.STARTED, self) try: self.server.serve_forever() except Exception, e: logger.error("start server error %s", str(e), exc_info=True)
class ServerTransportWS(ServerTransport): def __init__(self, scheme, parsed_uri, apps=None, kwargs=None): super(ServerTransportWS, self).__init__() assert scheme == 'ws' self.wss = None self.address = parsed_uri.hostname self.port = parsed_uri.port self.apps = apps or {} self.apps[parsed_uri.path] = ServerApplication self.kwargs = kwargs or {} def serve_forever(self, server): self.wss = WebSocketServer( (self.address, self.port), ServerResource(self.apps, server), **self.kwargs ) self.wss.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 init_entity(self): self._ws_server = WebSocketServer( ('', self._ws_port), Resource(OrderedDict({"/": LogWebSocket})) ) self._ws_server.start() self._http_server = HttpConnector(self._http_port) self._http_server.add_route("/showlog", ShowLog) self._http_server.add_route("/greplog", GrepLog) self._http_server.add_route("/nodes", AllNode) self._http_server.add_route("/nodemanage", NodeManage) self._http_server.add_route("/addnode", AddNode) self._http_server.add_route("/delnode", DelNode) self._http_server.start() WebSocketManager()
def __init__(self, **kwargs): self.irc_nick = kwargs.pop('irc_nick', DEFAULT_IRC_NICK) self.irc_host = kwargs.pop('irc_host', DEFAULT_IRC_HOST) self.irc_port = kwargs.pop('irc_port', DEFAULT_IRC_PORT) self.irc_channels = [x.strip('#') for x in kwargs.pop('irc_channels', DEFAULT_IRC_CHANNELS)] # TODO: validate channel formatting? self.irc_client = IRCClient(self.irc_host, self.irc_nick, self.irc_port, reconnect=True) self.irc_client.add_handler(ping_handler, 'PING') self.irc_client.add_handler(self.on_irc_connect, _JOIN_CODE) self.irc_client.add_handler(self._on_irc) self.irc_client.add_handler(self.on_message, 'PRIVMSG') self.ws_port = kwargs.pop('ws_port', DEFAULT_WS_PORT) self.ws_server = WebSocketServer(('', self.ws_port), Resource({'/': WebSocketApplication})) defer_start = kwargs.pop('defer_start', False) if not defer_start: self.start()
'clients': [ getattr(client, 'nickname', 'anonymous') for client in self.ws.handler.server.clients.values() ] })) def broadcast(self, message): for client in self.ws.handler.server.clients.values(): client.ws.send( json.dumps({ 'msg_type': 'message', 'nickname': message['nickname'], 'message': message['message'] })) def on_close(self, reason): print "Connection closed! " @flask_app.route('/') def index(): return render_template('index.html') from geventwebsocket.handler import WebSocketHandler WebSocketServer(('0.0.0.0', 5000), Resource({ '^/websocket': ChatApplication, '^/.*': DebuggedApplication(flask_app) }), debug=False).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()
def on_close(self, reason): current_client = self.ws.handler.active_client.custom_client token = current_client.get_token() print("on_close %s" % token) print(reason) self.broadcast_exclude_sender( json.dumps({ "action": "left", "client_id": current_client.get_token() }), self.ws.handler.active_client) #clients=ClientKeeper() WebSocketServer(('', 5000), Resource({'/': ClientSocketApplication})).serve_forever() # from geventwebsocket import WebSocketServer, WebSocketApplication, Resource # 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) # WebSocketServer( # ('', 5000),
for k, v in node.items(): if k == "_": continue val = json.dumps(v) app.backend.put(soul, k, v, diff[soul]['_']['>'][k]) elif 'get' in payload: get = payload['get'] soul = get['#'] ack = lex_from_graph(get, app.backend) uid = trackid(str(uuid.uuid4())) loggraph(graph) resp = {'put': ack, '@': soul, '#': uid, 'ok': True} self.sendall(resp) self.sendall(msg) self.ws.send(message) def on_close(self, reason): print(reason) def sendall(self, resp): for client in self.ws.handler.server.clients.values(): client.ws.send(json.dumps(resp)) geventserverapp = WebSocketServer( ('', 8000), Resource(OrderedDict([('/', GeventGunServer)])))
all_urls = [ url('', Home), url('static/{path:any}', file_handler(root='static/'), name='static') ] options = {} # Template Engine searchpath = [''] engine = Engine(loader=FileLoader(searchpath), extensions=[ CoreExtension(), ]) engine.global_vars.update({'h': html_escape}) options.update({'render_template': WheezyTemplate(engine)}) main = WSGIApplication(middleware=[ bootstrap_defaults(url_mapping=all_urls), path_routing_middleware_factory ], options=options) if __name__ == '__main__': WebSocketServer(('0.0.0.0', 8000), Resource({ '^/chat': ChatApplication, '^/.*': main }), debug=False).serve_forever()
super(Messaging, self).__init__(*args, **kwargs) def on_connect(self, sid, environ): Messaging.logger.info("Socket connected %s", sid) pass def on_disconnect(self, sid): Messaging.logger.info("Socket disconnected %s", sid) def on_message(self, sid, data): Messaging.logger.info("Message received %s", str(data)) def on_save(self, sid, data): with open("NONUWSGI_SAVED_DATA.txt", "w+") as f: f.write(str(data)) Messaging.logger.info("Saving data: %s", str(data)) self.emit("save", {"saved": True}, room=sid) # async_handlers so that socketio sends emits as soon as that line is processed, not to wait for whole method to finish sio = socketio.Server(logger=logging.getLogger(), engineio_logger=logging.getLogger(), ping_timeout=120, ping_interval=10, async_handlers=True) handler = Messaging('/socket2') handler.server = sio sio.register_namespace(handler) # wrap WSGI application with socketio's middleware application = socketio.Middleware(sio, application) from geventwebsocket import WebSocketServer WebSocketServer(('', 8001), application).serve_forever()
class PytoWebSocketServer(HAInterface): _api = PytomationAPI() def __init__(self, *args, **kwargs): self._address = kwargs.get('address', config.http_address) self._port = kwargs.get('port', int(config.http_port)) self._path = kwargs.get('path', config.http_path) super(PytoWebSocketServer, self).__init__(self._address, *args, **kwargs) self.unrestricted = True # To override light object restrictions def _init(self, *args, **kwargs): self._ssl_path = None self.ws = None try: self._ssl_path = config.ssl_path except: pass super(PytoWebSocketServer, self)._init(*args, **kwargs) 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 api_app(self, environ, start_response): method = environ['REQUEST_METHOD'].lower() if method == 'post': data = environ['wsgi.input'].read() else: data = None start_response("200 OK", [("Content-Type", "text/html"), ('Access-Control-Allow-Origin', '*')]) return self._api.get_response(path='/'.join(environ['PATH_INFO'].split('/')[2:]), source=PytoWebSocketServer, method=method, data=data) def http_file_app(self, environ, start_response): path_info = environ['PATH_INFO'] http_file = self._path + path_info if self._ssl_path: protocol = 'https://' else: protocol = 'http://' if os.path.exists(http_file): if os.path.isdir(http_file): if http_file.endswith('/'): http_file += 'index.html' else: if path_info.startswith('/'): location = protocol + self._address + ':' + str(self._port) + path_info + '/' else: location = protocol + self._address + ':' + str(self._port) + '/' + path_info + '/' start_response("302 Found", [("Location", location), ('Access-Control-Allow-Origin', '*')]) return '' mime = mimetypes.guess_type(http_file) start_response("200 OK", [("Content-Type", mime[0]), ('Access-Control-Allow-Origin', '*')]) return open(http_file, "rb") else: start_response("404 Not Found", [("Content-Type", "text/html"), ('Access-Control-Allow-Origin', '*')]) return "404 Not Found" def broadcast_state(self, state, source, prev, device): # TODO: add queue system and separate thread to avoid blocking on long network operations if self.ws: for client in self.ws.clients.values(): message = self._api.get_state_changed_message(state, source, prev, device) client.ws.send(message)
def listen(self, port, host = ''): server = WebSocketServer((host, port), Resource({'/': self.client_handler})) logger.debug('server will listening on %d %s' % (port, server)) server.serve_forever()
def websockets_server(): server = WebSocketServer((WS_LISTEN_HOST, WS_LISTEN_PORT), Resource({'/': WsServerApp}), debug=DEBUG) server.serve_forever()
import json from datetime import datetime from geventwebsocket import WebSocketServer, WebSocketApplication, Resource class EchoApplication(WebSocketApplication): def on_open(self): print("Connection opened") # Try sending a JSON encoded message with timestamp def on_message(self, message): d = datetime.now() ds = d.strftime("%d/%m/%Y %H:%M:%S") data = json.dumps({'time': ds, 'text': 'Hello there!'}) self.ws.send(data) def on_close(self, reason): print(reason) WebSocketServer(('', 8000), Resource({'/': EchoApplication})).serve_forever()
def start(): logger.info("Starting klystronserver.") host = "127.0.0.1" port = 8889 server = WebSocketServer((host, port), wsgi_klystron_app) server.serve_forever()
# Action.objects.create( # author=Author.objects.get_or_create(name=action['author'])[0], # content=action['message'], # stream_id=action['stream'] # ) # self.push_socket.send_json({'message': message}) def get_all(self, body): stream_id = int(body) actions = Action.objects.filter(stream_id=stream_id).values( 'author__name', 'self_sha', 'timestamp', 'message') self.ws.send('actions:%s' % json.dumps(actions, cls=JSONEncoder)) def new_action(self, body): print repr(body) action = json.loads(body) if set(action.keys()) != {'author', 'message', 'stream'}: self.ws.send('error: action has wrong keys: %r' % action.keys()) return Action.objects.create( author=Author.objects.get_or_create(name=action['author'])[0], message=action['message'], stream_id=action['stream']) resources = Resource({'/': ZmqApplication}) if __name__ == '__main__': WebSocketServer(('', 8001), resources).serve_forever()
def start(ctx, presentation, port, config, media, theme, style, debug): """Start revelation presentation command""" # Check if reveal.js is installed if not os.path.exists(REVEALJS_FOLDER): click.echo("Reveal.js not found, running installation...") ctx.invoke(installreveal) # Check for presentation file if os.path.isfile(presentation): path = os.path.dirname(presentation) else: click.echo("Error: Presentation file not found.") ctx.exit(1) # Check for style override file if style and (not os.path.isfile(style) or not style.endswith(".css")): click.echo("Error: Style is not a css file or does not exists.") ctx.exit(1) # Check for media root if not media: media = os.path.join(path, "media") if not os.path.isdir(media): # Running without media folder media = None click.echo("Media folder not detected, running without media") # Check for theme root if not theme: theme = os.path.join(path, "theme") if not os.path.isdir(theme): # Running without theme folder theme = None # Check for configuration file if not config: config = os.path.join(path, "config.py") if not os.path.isfile(config): # Running without configuration file config = None click.echo("Configuration file not detected, running with defaults.") click.echo("Starting revelation server...") # instantiating revelation app app = Revelation(presentation, config, media, theme, style, True) if debug: app = DebuggedApplication(app) PresentationReloader.tracking_path = os.path.abspath(path) click.echo("Running at http://localhost:{}".format(port)) WebSocketServer( ("localhost", port), Resource([ ("^/reloader.*", PresentationReloader), ("^/.*", DebuggedApplication(app)), ]), ).serve_forever()
''' DATE: 2020/09/08 AUTHOR: Yanxi Li ref: https://gitlab.com/noppo/gevent-websocket pip install gevent-websocket gunicorn -k "geventwebsocket.gunicorn.workers.GeventWebSocketWorker" wsgi:websocket_app ''' from geventwebsocket import WebSocketServer, WebSocketApplication, Resource from collections import OrderedDict 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) WebSocketServer( ('', 8000), Resource(OrderedDict([('/', EchoApplication)]))).serve_forever()
def start(): logger.info("Starting pycaserver.") host = "192.168.1.5" #"127.0.0.1" port = 8888 server = WebSocketServer((host, port), wsgi_app) server.serve_forever()
Run it using Gevent directly using: $ python plot_grapg.py Or with an Gunicorn wrapper: $ gunicorn -k "geventwebsocket.gunicorn.workers.GeventWebSocketWorker" \ plot_graph:app """ import gevent import random from geventwebsocket import WebSocketServer, WebSocketApplication, Resource class PlotApplication(WebSocketApplication): def on_open(self): for i in xrange(10000): self.ws.send("0 %s %s\n" % (i, random.random())) gevent.sleep(0.1) def static_wsgi_app(environ, start_response): start_response("200 OK", [("Content-Type", "text/html")]) return open("plot_graph.html").readlines() if __name__ == "__main__": resource = Resource({'/': static_wsgi_app, '/data': PlotApplication}) server = WebSocketServer(('', 8000), resource, debug=True) server.serve_forever()
# -*- coding: utf-8 -*- """gevent websocket server""" # https://github.com/gf0842wf/gevent-websocket from geventwebsocket import WebSocketServer, WebSocketApplication, Resource 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 if __name__ == "__main__": wss = WebSocketServer(('', 8201),Resource({'/chat': EchoApplication})) wss.serve_forever()
from geventwebsocket import WebSocketServer, Resource #from servers.ai import AIServer #from servers.tick import TickServer from servers.application import BrowserQuestApplication if __name__ == "__main__": #AIServer().start() #TickServer().start() WebSocketServer(('', 8000), Resource({'/': BrowserQuestApplication})).serve_forever()
class PytoWebSocketServer(HAInterface): _api = PytomationAPI() def __init__(self, *args, **kwargs): self._address = kwargs.get("address", config.http_address) self._port = kwargs.get("port", int(config.http_port)) self._path = kwargs.get("path", config.http_path) super(PytoWebSocketServer, self).__init__(self._address, *args, **kwargs) self.unrestricted = True # To override light object restrictions self.ws = None def _init(self, *args, **kwargs): self._ssl_path = None try: self._ssl_path = config.ssl_path except: pass super(PytoWebSocketServer, self)._init(*args, **kwargs) 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 api_app(self, environ, start_response): method = environ["REQUEST_METHOD"].lower() if method == "post": data = environ["wsgi.input"].read() else: data = None start_response("200 OK", [("Content-Type", "text/html"), ("Access-Control-Allow-Origin", "*")]) return self._api.get_response( path="/".join(environ["PATH_INFO"].split("/")[2:]), source=PytoWebSocketServer, method=method, data=data ) def http_file_app(self, environ, start_response): path_info = environ["PATH_INFO"] http_file = self._path + path_info if self._ssl_path: protocol = "https://" else: protocol = "http://" if os.path.exists(http_file): if os.path.isdir(http_file): if http_file.endswith("/"): http_file += "index.html" else: if path_info.startswith("/"): location = protocol + self._address + ":" + str(self._port) + path_info + "/" else: location = protocol + self._address + ":" + str(self._port) + "/" + path_info + "/" start_response("302 Found", [("Location", location), ("Access-Control-Allow-Origin", "*")]) return "" mime = mimetypes.guess_type(http_file) start_response("200 OK", [("Content-Type", mime[0]), ("Access-Control-Allow-Origin", "*")]) return open(http_file, "rb") else: start_response("404 Not Found", [("Content-Type", "text/html"), ("Access-Control-Allow-Origin", "*")]) return "404 Not Found" def broadcast_state(self, state, source, prev, device): # TODO: add queue system and separate thread to avoid blocking on long network operations if self.ws: for client in self.ws.clients.values(): message = self._api.get_state_changed_message(state, source, prev, device) client.ws.send(message)
""" When module ttg is executed start a wsgi web server """ import os from geventwebsocket import WebSocketServer from ttg.webapp import app server = WebSocketServer(('0.0.0.0', int(os.environ['PORT'])), app) server.serve_forever()
def app_worker(app, port): server = WebSocketServer(('', port), app) server.serve_forever()
class MyWebSocketServer(Greenlet): """ websocket服务器/当factory用吧 """ def __init__(self, port, urls, app, debug=False, **ssl_options): """端口监听器\n @param port: int 监听的端口\n @param urls: 链接的正则表达式列表\n @param apps: gevent-websocket封装的applications @param ssl_options: ssl参数 """ Greenlet.__init__(self) self.port = port self.urls = urls self.apps = app self.factory = None #sessionno生成器 self.countGenerator = itertools.count(1, 1) self.allClients = {} #服务通道 self.service = None #ssl_options root_ca = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "ca") if ssl_options: self.ssl_options = ssl_options self.ssl_options.update({ "keyfile": os.path.join(root_ca, self.ssl_options['keyfile']), "certfile": os.path.join(root_ca, self.ssl_options['certfile']) }) else: self.ssl_options = {} log.msg(self.ssl_options) self.debug = debug def addServiceChan(self, service): """ 添加服务通道 :return: """ self.service = service def getHost(self): """获取主机地址\n """ return "0.0.0.0", self.port def getClientBySessionno(self, sessionno): """ 根据sessionno获取client :param sessionno: :return: """ return self.allClients.get(sessionno, None) 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()
class Barnsworth(object): def __init__(self, **kwargs): self.irc_nick = kwargs.pop('irc_nick', DEFAULT_IRC_NICK) self.irc_host = kwargs.pop('irc_host', DEFAULT_IRC_HOST) self.irc_port = kwargs.pop('irc_port', DEFAULT_IRC_PORT) self.irc_channels = [x.strip('#') for x in kwargs.pop('irc_channels', DEFAULT_IRC_CHANNELS)] # TODO: validate channel formatting? self.irc_client = IRCClient(self.irc_host, self.irc_nick, self.irc_port, reconnect=True) self.irc_client.add_handler(ping_handler, 'PING') self.irc_client.add_handler(self.on_irc_connect, _JOIN_CODE) self.irc_client.add_handler(self._on_irc) self.irc_client.add_handler(self.on_message, 'PRIVMSG') self.ws_port = kwargs.pop('ws_port', DEFAULT_WS_PORT) self.ws_server = WebSocketServer(('', self.ws_port), Resource({'/': WebSocketApplication})) defer_start = kwargs.pop('defer_start', False) if not defer_start: self.start() def start(self): self._start_irc() self._start_ws() def _on_irc(self, client, msg): if DEBUG: msg_content = ' '.join(msg.params[1:]).decode('utf-8') clean_msg = parsers.clean_irc_markup(msg_content) BLOG.debug('irc message').success(clean_msg) def on_irc_connect(self, client, msg): # TODO: need another handler to register a join failure? for channel in self.irc_channels: with BLOG.critical('joining channel %s' % channel): client.send_message(Join(channel)) def on_message(self, client, msg): msg_content = ' '.join(msg.params[1:]).decode('utf-8') msg_content.replace(u'\x02', '') # hmm, TODO try: action_dict = parsers.parse_irc_message(msg_content) except Exception as e: # log return action_ctx = ActionContext(action_dict) with BLOG.debug('activity publish'): self.publish_activity(action_ctx) return def publish_activity(self, action_ctx): action_json = json.dumps(action_ctx.action, sort_keys=True) for addr, ws_client in self.ws_server.clients.iteritems(): ws_client.ws.send(action_json) # TODO: store action for activity batch service? with BLOG.debug('action context augmentation') as r: self._augment_action_ctx(action_ctx) with BLOG.debug('event detection') as r: event_list = self._detect_events(action_ctx) r.success('detected %s events' % len(event_list)) for event in event_list: event_cn = event.__class__.__name__ with BLOG.critical('publishing %r' % event_cn) as r: r.extras.update(event.to_dict()) action_ctx.add_event(event) event_json = event.to_json() for addr, ws_client in self.ws_server.clients.iteritems(): ws_client.ws.send(event_json) return def _augment_action_ctx(self, action_ctx): action = action_ctx.action if action['is_anon']: # TODO: geo-augmentor return # TODO? username = action['user'] rc = ransom.Client() resp = rc.get(_USERDAILY_URL_TMPL % username) try: udc_dict = json.loads(resp.text)['userdailycontribs'] except KeyError: return # Log? user_daily = UserDailyInfo.from_dict(username, udc_dict) action_ctx.user_daily_info = user_daily return def _detect_events(self, action_ctx): try: event_types = EVENT_MAP[action_ctx.action_type] except KeyError: return [] event_list = [] for event_type in event_types: try: event = event_type.from_action_context(action_ctx) event_list.append(event) except events.Uneventful: # probably won't even log this # Uneventful is uneventful for a reason #print 'event not applicable: ', ue pass except Exception: BLOG.critical('event detection error').exception() return event_list def _start_irc(self): self.irc_client.start() def _start_ws(self): self.ws_server.serve_forever()
try: msg = os.tp_read(self.tuntap.fd, 1500) if not msg: break except IOError: break if self.ws.closed: break self.ws.send(msg, True) def on_open(self): self.reader = gevent.spawn(self.read_fd) def on_close(self, reason): if (hasattr(self, 'reader')): self.reader.kill() def on_message(self, msg): if not msg: return os.tp_write(self.tuntap.fd, msg) if __name__ == "__main__": server.tuntap = tuntap.tuntap(args.tuntap) wss = WebSocketServer((args.src, args.port), Resource({args.loc: server})) try: wss.serve_forever() except KeyboardInterrupt: wss.close()
$ gunicorn -k "geventwebsocket.gunicorn.workers.GeventWebSocketWorker" \ plot_graph:app """ import gevent import random from geventwebsocket import WebSocketServer, WebSocketApplication, Resource class PlotApplication(WebSocketApplication): def on_open(self): for i in xrange(10000): self.ws.send("0 %s %s\n" % (i, random.random())) gevent.sleep(0.1) def static_wsgi_app(environ, start_response): start_response("200 OK", [("Content-Type", "text/html")]) return open("plot_graph.html").readlines() if __name__ == "__main__": resource = Resource({ '/': static_wsgi_app, '/data': PlotApplication }) server = WebSocketServer(('', 8000), resource, debug=True) server.serve_forever()
class APIServer(): _api_prefix = '/api/1' def __init__( self, rest_api: RestAPI, ws_notifier: RotkiNotifier, cors_domain_list: List[str] = None, ) -> None: flask_app = Flask(__name__) if cors_domain_list: CORS(flask_app, origins=cors_domain_list) blueprint = create_blueprint(self._api_prefix) setup_urls( blueprint=blueprint, rest_api=rest_api, urls=URLS_V1, ) self.rest_api = rest_api self.rotki_notifier = ws_notifier self.flask_app = flask_app self.blueprint = blueprint self.wsgiserver: Optional[WSGIServer] = None self.flask_app.register_blueprint(self.blueprint) self.ws_server: Optional[WebSocketServer] = None self.flask_app.errorhandler(HTTPStatus.NOT_FOUND)(endpoint_not_found) self.flask_app.register_error_handler(Exception, self.unhandled_exception) @staticmethod def unhandled_exception(exception: Exception) -> Response: """ Flask.errorhandler when an exception wasn't correctly handled """ log.critical( 'Unhandled exception when processing endpoint request', exc_info=True, exception=str(exception), ) return api_response(wrap_in_fail_result(str(exception)), HTTPStatus.INTERNAL_SERVER_ERROR) def run(self, host: str = '127.0.0.1', port: int = 5042, **kwargs: Any) -> None: """This is only used for the data faker and not used in production""" self.flask_app.run(host=host, port=port, **kwargs) def start( self, host: str = '127.0.0.1', rest_port: int = 5042, websockets_port: int = 5043, ) -> None: """This is used to start the API server in production""" wsgi_logger = logging.getLogger(__name__ + '.pywsgi') self.wsgiserver = WSGIServer( listener=(host, rest_port), application=self.flask_app, log=wsgi_logger, error_log=wsgi_logger, ) msg = f'rotki REST API server is running at: {host}:{rest_port}' print(msg) log.info(msg) self.wsgiserver.start() self.ws_server = WebSocketServer( listener=(host, websockets_port), application=WebsocketResource([ ('^/', RotkiWSApp), ]), debug=False, environ={'rotki_notifier': self.rotki_notifier}, ) msg = f'rotki Websockets API server is running at: {host}:{websockets_port}' print(msg) log.info(msg) self.ws_server.start() def stop(self, timeout: int = 5) -> None: """Stops the API server. If handlers are running after timeout they are killed""" if self.wsgiserver is not None: self.wsgiserver.stop(timeout) self.wsgiserver = None if self.ws_server is not None: self.ws_server.stop(timeout) self.wsgiserver = None self.rest_api.stop()