async def test_put_with_waiting_getters(self): loop = janus.current_loop() fut = loop.create_future() async def go(): fut.set_result(None) ret = await q.get() return ret async def put(): await q.put("a") _q = janus.Queue() q = _q.async_q t = loop.create_task(go()) await fut await put() assert await t == "a" assert not _q._sync_mutex.locked() _q.close() await _q.wait_closed()
def test_get_cancelled(self): _q = janus.Queue(loop=self.loop) q = _q.async_q @asyncio.coroutine def queue_get(): return (yield from asyncio.wait_for(q.get(), 0.051, loop=self.loop)) @asyncio.coroutine def test(): get_task = asyncio.Task(queue_get(), loop=self.loop) yield from asyncio.sleep(0.01, loop=self.loop) # let the task start q.put_nowait(1) return (yield from get_task) self.assertEqual(1, self.loop.run_until_complete(test())) self.assertFalse(_q._sync_mutex.locked()) _q.close() self.loop.run_until_complete(_q.wait_closed())
async def start(self): self.main_loop = asyncio.get_running_loop() if not args.no_speech: self.time_check() #self.queue = asyncio.Queue(loop=self.main_loop) self.queue = janus.Queue(loop=self.main_loop) tasks = [] self.server_stop = self.main_loop.create_future() self.osc_server = OSCServer(self.main_loop, self.queue.async_q) tasks.append( asyncio.create_task(self.osc_server.start(self.server_stop))) self.server = Server(self.gain_update, self.queue, self.control, self.mood_update, self.pix2pix_update) print("Starting server") self.server_task = asyncio.create_task( self.server.start(self.server_stop)) if not args.no_speech: #self.recognizer = Recognizer(self.queue.sync_q, self.main_loop, self.args#) #fut = self.main_loop.run_in_executor(None, self.recognizer.start) print("Waiting on queue") else: self.recognizer = None tasks.append(asyncio.create_task(self.consume_speech())) tasks.append(self.server_task) print("Gathering tasks") self.main_loop.call_soon(self.wakeup) self.tasks = asyncio.gather(*tasks) await self.tasks print("Server done!")
def start_server(self, consume_rpcs=True): """Server startup procedure Must be called from within the main thread """ # Ensure an event loop exists get_event_loop() self._server_shutdown_queue = janus.Queue() self._server_tasks = set() async def server_shutdown_monitor(): exit_code = await self._server_shutdown_queue.async_q.get() self.exit_code = exit_code self.loop.stop() self._server_shutdown_queue.async_q.task_done() shutdown_monitor_task = asyncio.ensure_future(server_shutdown_monitor()) shutdown_monitor_task.add_done_callback(make_exception_checker(self, die=True)) self._shutdown_monitor_task = shutdown_monitor_task block(self._start_server_inner())
def run(self): print("Starting proboty...") event_loop = asyncio.get_event_loop() queue = janus.Queue(maxsize=100, loop=event_loop) conn_handler = ConnectionHandler(queue.async_q) ws_server = websockets.serve(conn_handler.handle, '127.0.0.1', 55777) controller = Controller(event_loop, queue.sync_q) controller.start() event_loop.run_until_complete(ws_server) event_loop.run_forever() controller.join() print("Exiting proboty")
def test_async_join_async_done(self): q = janus.Queue(loop=self.loop) def threaded(): for i in range(5): val = q.sync_q.get() self.assertEqual(val, i) q.sync_q.task_done() @asyncio.coroutine def go(): f = self.loop.run_in_executor(None, threaded) for i in range(5): yield from q.async_q.put(i) yield from q.async_q.join() yield from f self.assertTrue(q.async_q.empty()) for i in range(3): self.loop.run_until_complete(go())
def read_file( self, vfid: UUID, relpath: PurePosixPath, *, chunk_size: int = 0, ) -> AsyncIterator[bytes]: target_path = self.sanitize_vfpath(vfid, relpath) q: janus.Queue[bytes] = janus.Queue() loop = asyncio.get_running_loop() def _read(q: janus._SyncQueueProxy[bytes]) -> None: with open(target_path, 'rb') as f: while True: buf = f.read(chunk_size) q.put(buf) if not buf: return async def _aiter() -> AsyncIterator[bytes]: nonlocal chunk_size if chunk_size == 0: # get the preferred io block size _vfs_stat = await loop.run_in_executor(None, os.statvfs, self.mount_path) chunk_size = _vfs_stat.f_bsize read_task = asyncio.create_task( loop.run_in_executor(None, _read, q.sync_q)) await asyncio.sleep(0) try: while True: buf = await q.async_q.get() yield buf q.async_q.task_done() finally: await read_task return _aiter()
def main(): loop = tornado.ioloop.IOLoop.current() asyncio_loop = loop.asyncio_loop db_pool = loop.asyncio_loop.run_until_complete(init_db(DSN)) # Set WebHook for Telegram Bot if TG_BOT['enabled']: urlopen(url=TG_BOT['set_webhook_url'], data=urlencode({ 'url': TG_BOT['url'] }).encode()) # If some external notifications backend is enabled, create a queue # for notification processing and start external sending worker async_queue = None sync_queue = None if any(item['enabled'] for item in EXTERNAL_NOTIFICATIONS.values()): queue = janus.Queue(loop=asyncio_loop) notifications_task = asyncio_loop.create_task( run_manager(queue.async_q)) async_queue = queue.async_q sync_queue = queue.sync_q app = WebQuotesApp(loop, db_pool, async_queue) http_server = tornado.httpserver.HTTPServer(app) http_server.listen(PORT, HOST) try: loop.start() except KeyboardInterrupt: if sync_queue: sync_queue.put(None) asyncio_loop.run_until_complete(notifications_task) if TG_BOT['enabled']: urlopen(TG_BOT['delete_webhook_url']) loop.stop() finally: loop.close()
async def gen_chunks(self) -> AsyncIterator[LocalChunk]: res_q: janus.Queue[LocalChunk] = janus.Queue() crawl_fut = create_thread_task( _dir_crawl_worker, ( res_q.sync_q, self._root_path, self._recurse, self._file_ext, self._max_chunk, ), ) while True: try: chunk = await asyncio.wait_for(res_q.async_q.get(), timeout=1.0) except asyncio.TimeoutError: # Check if the worker thread exited prematurely if crawl_fut.done(): break else: yield chunk await crawl_fut
async def test_sync_put_async_get(self): loop = janus.current_loop() q = janus.Queue() def threaded(): for i in range(5): q.sync_q.put(i) async def go(): f = loop.run_in_executor(None, threaded) for i in range(5): val = await q.async_q.get() self.assertEqual(val, i) self.assertTrue(q.async_q.empty()) await f for i in range(3): await go() q.close() await q.wait_closed()
async def subscribe(self): q = janus.Queue() with self._condition_subscribers: self.subscribers.append(q) last_idx, last_item = self.last_enumarated if last_item is self.End: return if last_item is not self.NoLastItem: yield last_item while True: idx, item = await q.async_q.get() if item is self.End: break if last_idx < idx: yield item with self._condition_subscribers: self.subscribers.remove(q) q.close() await q.wait_closed()
async def test_close_after_sync_join(self): q = janus.Queue() q.sync_q.put(1) loop = asyncio.get_event_loop() fut = asyncio.Future() def sync_join(): try: q.sync_q.join() except Exception as exc: loop.call_soon_threadsafe(fut.set_exception, exc) thr = threading.Thread(target=sync_join, daemon=True) thr.start() thr.join(0.1) # ensure tasks are blocking q.close() with pytest.raises(RuntimeError), contextlib.suppress(asyncio.TimeoutError): await asyncio.wait_for(fut, timeout=0.1) await q.wait_closed()
async def client(tmpdir, loop): store = PanStore(tmpdir) queue = janus.Queue() conf = ServerConfig("example", "https://exapmle.org") conf.history_fetch_delay = 0.1 store.save_server_user("example", "@example:example.org") pan_client = PanClient( "example", store, conf, "https://example.org", queue.async_q, "@example:example.org", "DEVICEID", tmpdir, store_class=SqliteStore, ) yield pan_client await pan_client.close()
def test_put_with_waiting_getters(self): fut = asyncio.Future(loop=self.loop) @asyncio.coroutine def go(): fut.set_result(None) ret = yield from q.get() return ret @asyncio.coroutine def put(): yield from q.put('a') _q = janus.Queue(loop=self.loop) q = _q.async_q t = asyncio.Task(go(), loop=self.loop) self.loop.run_until_complete(fut) self.loop.run_until_complete(put()) self.assertEqual(self.loop.run_until_complete(t), 'a') self.assertFalse(_q._sync_mutex.locked()) _q.close() self.loop.run_until_complete(_q.wait_closed())
async def test_sync_put_async_join(self): loop = janus.current_loop() q = janus.Queue() for i in range(5): q.sync_q.put(i) async def do_work(): await asyncio.sleep(1) while True: await q.async_q.get() q.async_q.task_done() task = loop.create_task(do_work()) async def wait_for_empty_queue(): await q.async_q.join() task.cancel() await wait_for_empty_queue() q.close() await q.wait_closed()
async def 启动程序(账户data): global CTP用户名对应实例和登陆名,myqueue CTP用户名对应实例和登陆名={} myqueue=janus.Queue() while True: #每个CTP账户实例遍历,建立spi和api实例 for x in 账户data: if 账户data[x] is None: 账户data[x]=[list(x[1:3])+[0]] #登陆交易实例 tradeapi=api.CThostFtdcTraderApi_CreateFtdcTraderApi() BROKERID,USERID,PASSWORD,AppID,AuthCode,FrontAddr=x tradespi=CTradeSpi(tradeapi,BROKERID,USERID,PASSWORD,AppID,AuthCode,myqueue.sync_q) tradeapi.RegisterFront(FrontAddr) tradeapi.RegisterSpi(tradespi) tradeapi.SubscribePrivateTopic(api.THOST_TERT_RESTART) tradeapi.SubscribePublicTopic(api.THOST_TERT_RESTART) tradeapi.Init() while True: if tradespi.init_start is None: time.sleep(1) else: break if x[1] not in CTP用户名对应实例和登陆名: CTP用户名对应实例和登陆名[x[1]]={"td_obj":tradespi,'td_user_pass':账户data[x],"td_websockets":[],"td_api":tradeapi} else: CTP用户名对应实例和登陆名[x[1]]["td_obj"]=tradespi CTP用户名对应实例和登陆名[x[1]]["td_api"]=tradeapi await asyncio.sleep(100) #进行无限延迟,到达重连时间,去释放原来的api while True: await asyncio.sleep(10) if time_to_str(time.time())[11:16] in ("08:35","20:35"): for x in 账户data: CTP用户名对应实例和登陆名[x[1]]["td_api"].Release() break
def test_maxsize(self): _q = janus.Queue(maxsize=2, loop=self.loop) q = _q.async_q self.assertEqual(2, q.maxsize) have_been_put = [] fut = asyncio.Future(loop=self.loop) @asyncio.coroutine def putter(): for i in range(3): yield from q.put(i) have_been_put.append(i) if i == q.maxsize - 1: fut.set_result(None) return True @asyncio.coroutine def test(): t = asyncio.Task(putter(), loop=self.loop) yield from fut # The putter is blocked after putting two items. self.assertEqual([0, 1], have_been_put) self.assertEqual(0, q.get_nowait()) # Let the putter resume and put last item. yield from t self.assertEqual([0, 1, 2], have_been_put) self.assertEqual(1, q.get_nowait()) self.assertEqual(2, q.get_nowait()) self.loop.run_until_complete(test()) self.assertFalse(_q._sync_mutex.locked()) _q.close() self.loop.run_until_complete(_q.wait_closed())
def test_get_with_putters(self): _q = janus.Queue(1, loop=self.loop) q = _q.async_q q.put_nowait(1) fut = self.loop.create_future() async def put(): t = janus.ensure_future(q.put(2), loop=self.loop) await asyncio.sleep(0.01) fut.set_result(None) return t t = self.loop.run_until_complete(put()) res = self.loop.run_until_complete(q.get()) self.assertEqual(1, res) self.loop.run_until_complete(t) self.assertEqual(1, q.qsize()) self.assertFalse(_q._sync_mutex.locked()) _q.close() self.loop.run_until_complete(_q.wait_closed())
async def _init(self, cmdargs) -> None: self.cmdargs = cmdargs loop = current_loop() self._service_lock = asyncio.Lock() # Initialize event loop. executor = concurrent.futures.ThreadPoolExecutor(max_workers=2) loop.set_default_executor(executor) self.zctx = zmq.asyncio.Context() self.insock = self.zctx.socket(zmq.PULL) self.insock.bind('tcp://*:2000') self.outsock = self.zctx.socket(zmq.PUSH) self.outsock.bind('tcp://*:2001') self.log_queue = janus.Queue() self.task_queue = asyncio.Queue() self.init_done = asyncio.Event() setup_logger(self.log_queue.sync_q, self.log_prefix, cmdargs.debug) self._log_task = loop.create_task(self._handle_logs()) await asyncio.sleep(0) service_def_folder = Path('/etc/backend.ai/service-defs') if service_def_folder.is_dir(): self.service_parser = ServiceParser({ 'runtime_path': str(self.runtime_path), }) await self.service_parser.parse(service_def_folder) log.debug('Loaded new-style service definitions.') else: self.service_parser = None self._main_task = loop.create_task(self.main_loop(cmdargs)) self._run_task = loop.create_task(self.run_tasks())
async def websocket_run(self, symbols): global connection_open await self.load_markets() loop = asyncio.get_event_loop() queue = janus.Queue(loop=loop) self.pre_queue = [] await self.signalr_connect(symbols, queue.sync_q) while True: market = await queue.async_q.get() if market == "closed": logger.error("bittrex restart") break yield [ 'bittrex', { 'asks': list(sorted(orderbooks[market]['asks'].items())), 'bids': list( sorted(orderbooks[market]['bids'].items(), reverse=True)) }, market ]
def start(self): # general asyncio stuff asyncio.set_event_loop(self.loop) self.loop = asyncio.get_event_loop() # synchronous input/output self.synchronous_tx_queue = janus.Queue(loop=self.loop) self.synchronous_rx_queue = queue.Queue() asyncio.ensure_future(self.handle_synchronous_input()) # client lists self.tcp_clients = {} # task -> (reader, writer) self.ws_clients = {} # tcp server self.tcp_server = self.loop.run_until_complete(asyncio.start_server(self.client_connected_handler, '127.0.0.1', 5678)) # websocket server start_ws_server = websockets.serve(self.handle_ws_client, '127.0.0.1', 5679) self.loop.run_until_complete(start_ws_server) # kick things off self.loop.run_forever() self.stopped()
async def watch_commits(self, branch=None, from_commit=None): """Fill queue of commits.""" if not branch: branch = self._master if branch.get_name() in self._commit_watch_queues: queue = self._commit_watch_queues[branch.get_name()] else: client = self._clients['pfs'] loop = asyncio.get_event_loop() queue = janus.Queue(loop=loop) cancel_event = threading.Event() commit_future = loop.run_in_executor( None, _watch_commits_real, loop, queue.sync_q, self._clients, self.get_name(), branch.get_name(), from_commit.get_name() if from_commit else None, cancel_event) self._commit_watch_futures[branch.get_name()] = (commit_future, cancel_event) self._commit_watch_queues[branch.get_name()] = queue return queue.async_q
async def tunnel(self): print('tunnel, launch...') self.__putTunnelQueue = janus.Queue() _state = False while True: print('tunnel, ready...') msg = await self.__putTunnelQueue.async_q.get() print('tunnel, get msg') print(f'tunnel, state: {_state} && msg: {msg}') if _state is False and msg == 'RUN': print(f'tunnel, start') self.__palletInfo = palletObj(self.__cls, 'localhost', 5001); _state = True #self.__putPalletQueue.sync_q.put(msg) print(f"tunnel, put 'RUN' msg") self.__putPalletQueue.sync_q.put('RUN') elif _state is True and msg == 'FIN': print(f'tunnel, finish') self.__palletInfo.done() del self.__palletInfo; _state = False else: print(f'tunnel, bypass') await self.__palletInfo.put_sq(msg) print('tunnel, again~~~')
async def test_maxsize(self): loop = janus.current_loop() _q = janus.Queue(maxsize=2) q = _q.async_q assert 2 == q.maxsize have_been_put = [] fut = loop.create_future() async def putter(): for i in range(3): await q.put(i) have_been_put.append(i) if i == q.maxsize - 1: fut.set_result(None) return True async def test(): t = loop.create_task(putter()) await fut # The putter is blocked after putting two items. assert [0, 1] == have_been_put assert 0 == q.get_nowait() # Let the putter resume and put last item. await t assert [0, 1, 2] == have_been_put assert 1 == q.get_nowait() assert 2 == q.get_nowait() await test() assert not _q._sync_mutex.locked() _q.close() await _q.wait_closed()
def __init__(self, channel_discord_object: discord.TextChannel, service_object): st = InsightLogger.InsightLogger.time_start() assert isinstance(service_object, Service.ServiceModule) self.channel_discord_object = channel_discord_object self.channel_id = channel_discord_object.id self.logger = InsightLogger.InsightLogger.get_logger( 'Insight.feed.{}.{}'.format( str(self).replace(' ', ''), self.channel_id), 'Insight_feed.log', child=True) self.logger_filter = InsightLogger.InsightLogger.get_logger( 'Insight.filter.{}'.format(self.channel_id), 'Insight_filter.log', child=True) self.log_mail_error = InsightLogger.InsightLogger.get_logger( 'MailError.{}'.format(self.channel_id), 'MailError.log', child=True) self.service = service_object self.channel_manager = self.service.channel_manager self.discord_client = self.service.channel_manager.get_discord_client() self.kmQueue = janus.Queue(loop=self.discord_client.loop) self.__deque_task = None self.linked_options = self.get_linked_options() self.setup_table() self.template_loader() self.load_table() self.last_mention = datetime.datetime.utcnow() - datetime.timedelta( hours=24) self.last_prune = datetime.datetime.utcnow() self.appearance_class = None self.lock = asyncio.Lock(loop=self.discord_client.loop) InsightLogger.InsightLogger.time_log(self.logger, st, 'Feed loading and setup')
def __init__(self): self.dbmanager = MongodbManager() self.async_dbmanager = None self.symbol_queue_to_crawl = janus.Queue().async_q self.symbol_crawled_set = set()
def __init__(self): self.queue = janus.Queue() self.was_ended_put = False self.was_ended_get = False self.__class__.__opened_instances.append(self)
def scandir(self, vfid: UUID, relpath: PurePosixPath) -> AsyncIterator[DirEntry]: target_path = self.sanitize_vfpath(vfid, relpath) q: janus.Queue[Union[Sentinel, DirEntry]] = janus.Queue() loop = asyncio.get_running_loop() def _scandir( q: janus._SyncQueueProxy[Union[Sentinel, DirEntry]]) -> None: count = 0 limit = self.local_config["storage-proxy"]["scandir-limit"] try: with os.scandir(target_path) as scanner: for entry in scanner: symlink_target = "" entry_type = DirEntryType.FILE if entry.is_dir(): entry_type = DirEntryType.DIRECTORY if entry.is_symlink(): entry_type = DirEntryType.SYMLINK symlink_target = str(Path(entry).resolve()) entry_stat = entry.stat(follow_symlinks=False) q.put( DirEntry( name=entry.name, path=Path(entry.path), type=entry_type, stat=Stat( size=entry_stat.st_size, owner=str(entry_stat.st_uid), mode=entry_stat.st_mode, modified=fstime2datetime( entry_stat.st_mtime), created=fstime2datetime( entry_stat.st_ctime), ), symlink_target=symlink_target, ), ) count += 1 if limit > 0 and count == limit: break finally: q.put(SENTINEL) async def _scan_task(_scandir, q) -> None: await loop.run_in_executor(None, _scandir, q.sync_q) async def _aiter() -> AsyncIterator[DirEntry]: scan_task = asyncio.create_task(_scan_task(_scandir, q)) await asyncio.sleep(0) try: while True: item = await q.async_q.get() if item is SENTINEL: break yield item q.async_q.task_done() finally: await scan_task q.close() await q.wait_closed() return _aiter()
async def smartVISU_protocol_v4(self, websocket): #items = [] self.logs = self._sh.return_logs() self._sh.add_event_listener(['log'], self.update_visulog) client_addr = self.client_address(websocket) client_ip = websocket.remote_address[0] self.sv_clients[client_addr] = {} self.sv_clients[client_addr]['websocket'] = websocket self.sv_clients[client_addr]['sw'] = 'Visu' self.logger.info("smartVISU_protocol_v4: Client {} started".format(client_addr)) #client_addr = websocket.remote_address[0] + ':' + str(websocket.remote_address[1]) await self.get_shng_class_instances() if not self.janus_queue: self.janus_queue = janus.Queue() try: async for message in websocket: data = json.loads(message) command = data.get("cmd", '') protocol = 'wss' if websocket.secure else 'ws ' # self.logger.warning("{} <CMD : '{}' - from {}".format(protocol, data, client_addr)) self.logger.info(f"{client_addr} snt '{data}'") answer = {"error": "unhandled command"} try: if command == 'item': path = data['id'] value = data['val'] item = self.items.return_item(path) if item is not None: item_acl = item.conf.get('visu_acl', None) if item_acl is None or item_acl == '': item_acl = item.conf.get('acl', None) if item_acl is None: item_acl = self.sv_acl if item_acl != 'ro': item(value, self.sv_clients[client_addr]['sw'], client_ip) else: self.logger.warning("Client {0} want to update read only item: {1}".format(client_addr, path)) else: self.logger.warning("Client {0} want to update invalid item: {1}".format(client_addr, path)) answer = {} elif command == 'monitor': answer = {} if data['items'] != [None]: answer = await self.prepare_monitor(data, client_addr) else: self.sv_monitor_items[client_addr] = [] # stop monitoring of items elif command == 'logic': answer = {} await self.request_logic(data, client_addr) self.logger.warning("{} <CMD not yet tested: '{}' - from {}".format(protocol, data, client_addr)) elif command == 'series': path = data['item'] item = self.items.return_item(path) if item is not None: answer = await self.prepare_series(data, client_addr) if answer == {}: self.logger.warning("command 'series' -> No reply from prepare_series() (for request {})".format(data)) else: self.logger.warning("Client {} requested a series for an unknown item: {}".format(client_addr, path)) elif command == 'series_cancel': answer = await self.cancel_series(data, client_addr) elif command == 'log': answer = {} name = data['name'] num = 10 if 'max' in data: num = int(data['max']) if name in self.logs: answer = {'cmd': 'log', 'name': name, 'log': self.logs[name].export(num), 'init': 'y'} else: self.logger.warning("Client {0} requested invalid log: {1}".format(client_addr, name)) if client_addr not in self.sv_monitor_logs: self.sv_monitor_logs[client_addr] = [] if name not in self.sv_monitor_logs[client_addr]: self.sv_monitor_logs[client_addr].append(name) elif command == 'ping': answer = {'cmd': 'pong'} elif command == 'proto': # protocol version proto = data['ver'] if proto > self.proto: self.logger.warning("WebSocket: protocol mismatch. SmartHomeNG protocol version={0}, visu protocol version={1}".format(self.proto, proto)) elif proto < self.proto: self.logger.warning("WebSocket: protocol mismatch. Update your client: {0}".format(client_addr)) answer = {'cmd': 'proto', 'ver': self.proto, 'server': 'module.websocket', 'time': self.shtime.now().strftime("%Y-%m-%dT%H:%M:%S.%f")} elif command == 'identity': # identify client client = data.get('sw', 'Visu') self.sv_clients[client_addr]['sw'] = data.get('sw', '') self.sv_clients[client_addr]['ver'] = data.get('ver', '') self.sv_clients[client_addr]['hostname'] = data.get('hostname', '') self.sv_clients[client_addr]['browser'] = data.get('browser', '') self.sv_clients[client_addr]['bver'] = data.get('bver', '') self.logger.info("smartVISU_protocol_v4: Client {} identified as '{} {}' in Browser '{} {}'".format(client_addr, self.sv_clients[client_addr]['sw'], self.sv_clients[client_addr]['ver'], self.sv_clients[client_addr]['browser'], self.sv_clients[client_addr]['bver'])) answer = {} elif command == 'list_items': answer = {} if self.sv_querydef: path = data.get('path', '') answer = await self.request_list_items(path, client_addr) self.logger.warning("{} <CMD not yet tested: '{}' - from {}".format(protocol, data, client_addr)) elif command == 'list_logics': answer = {} if self.sv_querydef: enabled = data.get('enabled', 0) answer = await self.request_list_logics((enabled == 1), client_addr) self.logger.warning("{} <CMD not yet tested: '{}' - from {}".format(protocol, data, client_addr)) else: self.logger.error("unsupported event: '{}'", data) reply = json.dumps(answer, default=self.json_serial) except Exception as e: self.logger.exception("visu_protocol Exception {}".format(e)) if answer != {}: # if an answer should be send, it is done here try: await websocket.send(reply) self.logger.info("visu >REPLY: '{}' - to {}".format(answer, websocket.remote_address)) #except (asyncio.IncompleteReadError, asyncio.connection_closed) as e: except Exception as e: self.logger.warning("smartVISU_protocol_v4: Exception in 'await websocket.send(reply)': {} - reply = {}".format(e, reply)) except Exception as e: if not str(e).startswith(('code = 1005', 'code = 1006')): self.logger.error("smartVISU_protocol_v4 exception: {}".format(e)) else: self.logger.info("smartVISU_protocol_v4 error: {}".format(e)) # Remove client from monitoring dict and from dict of active clients del(self.sv_monitor_items[client_addr]) try: del(self.sv_clients[client_addr]) except Exception as e: self.logger.error("smartVISU_protocol_v4 error deleting client session data: {}".format(e)) self.logger.info("smartVISU_protocol_v4: Client {} stopped".format(client_addr)) return
async def daemon(context, log_level, debug_encryption, config, data_path): loop = asyncio.get_event_loop() conf_dir = user_config_dir("pantalaimon", "") data_dir = user_data_dir("pantalaimon", "") create_dirs(data_dir, conf_dir) config = config or os.path.join(conf_dir, "pantalaimon.conf") data_dir = data_path or data_dir if log_level: log_level = parse_log_level(log_level) pan_conf = PanConfig(config, log_level) try: pan_conf.read() except (OSError, PanConfigError) as e: context.fail(e) if not pan_conf.servers: context.fail("Homeserver is not configured.") logger.level = pan_conf.log_level if pan_conf.debug_encryption or debug_encryption: nio.crypto.logger.level = logbook.DEBUG StderrHandler().push_application() servers = [] proxies = [] if UI_ENABLED: from pantalaimon.ui import GlibT pan_queue = janus.Queue() ui_queue = janus.Queue() glib_thread = GlibT( pan_queue.sync_q, ui_queue.sync_q, data_dir, pan_conf.servers.values(), pan_conf, ) glib_fut = loop.run_in_executor(None, glib_thread.run) message_router_task = asyncio.create_task( message_router(ui_queue.async_q, pan_queue.async_q, proxies)) else: glib_thread = None glib_fut = None pan_queue = None ui_queue = None message_router_task = None try: for server_conf in pan_conf.servers.values(): proxy, runner, site = await init(data_dir, server_conf, pan_queue, ui_queue) servers.append((proxy, runner, site)) proxies.append(proxy) except keyring.errors.KeyringError as e: context.fail(f"Error initializing keyring: {e}") async def wait_for_glib(glib_thread, fut): glib_thread.stop() await fut home = os.path.expanduser("~") os.chdir(home) event = asyncio.Event() def handler(signum, frame): raise KeyboardInterrupt signal.signal(signal.SIGTERM, handler) try: for proxy, _, site in servers: click.echo(f"======== Starting daemon for homeserver " f"{proxy.name} on {site.name} ========") await site.start() click.echo("(Press CTRL+C to quit)") await event.wait() except (KeyboardInterrupt, asyncio.CancelledError): for _, runner, _ in servers: await runner.cleanup() if glib_fut: await wait_for_glib(glib_thread, glib_fut) if message_router_task: message_router_task.cancel() await asyncio.wait({message_router_task}) raise