def __init__(self, conn, debug=False): """Prepare async connection.""" # greenify! super(PostgresGreenlet, self).__init__() self.logger = create_logger(__name__, debug=debug) # queues for processing incoming sub/unsub requests and processing self.subs = gevent.queue.Queue() self.unsubs = gevent.queue.Queue() self.proc_queue = gevent.queue.Queue() self._stop_event = gevent.event.Event() # dict of name: subscribers # eg: {'bookstore.book': {'tpozNWMPphaJ2n8bj': <function at ...>}} self.all_subs = collections.defaultdict(dict) self._sub_lock = gevent.lock.RLock() # connect to DB in async mode conn.allow_thread_sharing = True self.connection = conn self.conn_params = conn.get_connection_params() self.conn_params.update( async=True, ) self.conn = psycopg2.connect(**self.conn_params) self.poll() # wait for conneciton to start self.cur = self.conn.cursor()
def serve_wsgi(host, port, app, quiet=False): server = WSGIServer((host, port), app, handler_class=WebSocketHandler) if not quiet: server.logger = create_logger('geventwebsocket.logging') server.logger.setLevel(logging.INFO) server.logger.addHandler(logging.StreamHandler()) server.logger.info(f'Listening on http://{host}:{port}/\nHit Ctrl-C to quit.\n') server.serve_forever()
def run(self, handler): server = pywsgi.WSGIServer((self.host, self.port), handler, handler_class=WebSocketHandler) if not self.quiet: server.logger = create_logger('geventwebsocket.logging') server.logger.setLevel(logging.INFO) server.logger.addHandler(logging.StreamHandler()) server.serve_forever()
def run(self, handler): self.server = pywsgi.WSGIServer((self.host, self.port), handler, handler_class=WebSocketHandler) if not self.quiet: self.server.logger = create_logger('geventwebsocket.logging') self.server.logger.setLevel(logging.INFO) self.server.logger.addHandler(logging.StreamHandler()) self.server.serve_forever()
def __init__(self, conn, debug=False): """Prepare async connection.""" super(PostgresGreenlet, self).__init__() self.logger = create_logger(__name__, debug=debug) # queues for processing incoming sub/unsub requests and processing self.connections = {} self.chunks = {} self._stop_event = gevent.event.Event() # connect to DB in async mode conn.allow_thread_sharing = True self.connection = conn self.conn_params = conn.get_connection_params() self.conn_params.update(async=True, ) self.conn = psycopg2.connect(**self.conn_params) self.poll() # wait for conneciton to start self.cur = self.conn.cursor()
def __init__(self, conn, debug=False): """Prepare async connection.""" super(PostgresGreenlet, self).__init__() self.logger = create_logger(__name__, debug=debug) # queues for processing incoming sub/unsub requests and processing self.connections = {} self.chunks = {} self._stop_event = gevent.event.Event() # connect to DB in async mode conn.allow_thread_sharing = True self.connection = conn self.conn_params = conn.get_connection_params() self.conn_params.update( async=True, ) self.conn = psycopg2.connect(**self.conn_params) self.poll() # wait for conneciton to start self.cur = self.conn.cursor()
def __init__(self, fd): self.logger = create_logger('ws_'.format(fd), True)
def start(port=0): multiprocessing.set_start_method('spawn') app = bottle.Bottle() logger = create_logger('geventwebsocket.logging') logger.setLevel(logging.DEBUG) logger.addHandler(logging.StreamHandler()) logger.propagate = False if config.bundled: root = os.path.join(config.root, 'web') else: root = os.path.join(os.path.dirname(__file__), 'dist') httpsock = gevent.socket.socket(gevent.socket.AF_INET, gevent.socket.SOCK_STREAM) httpsock.bind(('127.0.0.1', port)) httpsock.listen() token = '1145141919' @app.route("/") def serve_root(): return bottle.static_file("index.html", root) @app.route('/itemimg/<name>.png') def itemimg(name): logger.info('serving file %s', name) import imgreco.resources import imgreco.item items = imgreco.item.all_known_items() respath = items.get(name, None) if respath: bottle.response.content_type = 'image/png' return imgreco.resources.open_file(respath) else: return 404 def readws(ws): while True: try: msg = ws.receive() except WebSocketError: return None if msg is not None: if not isinstance(msg, str): continue try: obj = json.loads(msg) except: logger.error("invalid JSON") continue logger.debug("received request %r", obj) return obj else: return None @app.route("/ws") def rpc_endpoint(): wsock: geventwebsocket.websocket.WebSocket = bottle.request.environ.get( 'wsgi.websocket') if not wsock: bottle.abort(400, 'Expected WebSocket request.') authorized = False wsock.send('{"type":"need-authorize"}') while True: try: obj = readws(wsock) if obj is None: break request_type = obj.get('type', None) if request_type == 'web:authorize': client_token = obj.get('token', None) if client_token == token: authorized = True break except WebSocketError: break if authorized: logger.info('client authorized') from .worker_launcher import worker_process inq = multiprocessing.Queue() outq = multiprocessing.Queue() p = multiprocessing.Process(target=worker_process, args=(inq, outq), daemon=True) logger.info('spawning worker process') p.start() pool: gevent.threadpool.ThreadPool = gevent.get_hub().threadpool error = False logger.info('starting worker loop') outqread = pool.spawn(outq.get) wsread = gevent.spawn(readws, wsock) while not error: for task in gevent.wait((outqread, wsread), count=1): if task is outqread: try: outval = outqread.get() except: logger.error( 'read worker output failed with exception', exc_info=True) error = True break gevent.spawn(wsock.send, json.dumps(outval)) outqread = pool.spawn(outq.get) elif task is wsread: try: obj = wsread.get() except: logger.error( 'read message from websocket failed with exception', exc_info=True) error = True break if obj is None: error = True break wsread = gevent.spawn(readws, wsock) pool.spawn(inq.put, obj) logger.info('worker loop stopped') with contextlib.suppress(Exception): gevent.kill(wsread) wsock.close() inq.put_nowait(None) p.kill() @app.route("/<filepath:path>") def serve_static(filepath): return bottle.static_file(filepath, root) group = gevent.pool.Pool() server = gevent.pywsgi.WSGIServer(httpsock, app, handler_class=WebSocketHandler, log=logger, spawn=group) url = f'http://{server.address[0]}:{server.address[1]}/?token={token}' print(url) server_task = gevent.spawn(server.serve_forever) if port != 0: server_task.get() return from .webhost import get_host host = get_host() host.start(url, 980, 820) if host.wait_handle: # neither gevent nor pywebview like non-main thread webview_task = gevent.get_hub().threadpool.spawn(host.wait_handle) webview_task.wait() else: idlechk_interval = getattr(host, 'poll_interval', 60) idlecount = 1 while True: gevent.sleep(idlechk_interval) if len(group) == 0: idlecount += 1 else: idlecount = 0 if idlecount >= 3: print("stopping idle server") break # gevent.util.print_run_info() server.stop()