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
