GithubFollow/One-KVM
1
0
Fork 0
mirror of https://github.com/mofeng-git/One-KVM.git synced 2025-12-13 01:30:31 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

improved vnc logging

Browse Source
This commit is contained in:
Maxim Devaev 2022-07-21 13:54:47 +03:00
parent af4eb77231
commit ca87bd66d7
2 changed files with 27 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
kvmd/apps/vnc/rfb/__init__.py
View File

@ -94,7 +94,7 @@ class RfbClient(RfbClientStream): # pylint: disable=too-many-instance-attribute
async def _run(self, **coros: Coroutine) -> None: async def _run(self, **coros: Coroutine) -> None:
logger = get_logger(0) logger = get_logger(0)
logger.info("[entry] %s: Starting client tasks ...", self._remote) logger.info("%s [entry]: Starting client tasks ...", self._remote)
tasks = list(map(asyncio.create_task, [ # type: ignore # Я хз, почему github action фейлится здесь tasks = list(map(asyncio.create_task, [ # type: ignore # Я хз, почему github action фейлится здесь
self.__wrapper(name, coro) self.__wrapper(name, coro)
for (name, coro) in {"main": self.__main_task_loop(), **coros}.items() for (name, coro) in {"main": self.__main_task_loop(), **coros}.items()
@ -106,7 +106,7 @@ class RfbClient(RfbClientStream): # pylint: disable=too-many-instance-attribute
task.cancel() task.cancel()
await asyncio.gather(*tasks, return_exceptions=True) await asyncio.gather(*tasks, return_exceptions=True)
await self._close() await self._close()
logger.info("[entry] %s: Connection closed", self._remote) logger.info("%s [entry]: Connection closed", self._remote)
async def __wrapper(self, name: str, coro: Coroutine) -> None: async def __wrapper(self, name: str, coro: Coroutine) -> None:
logger = get_logger(0) logger = get_logger(0)
@ -114,14 +114,14 @@ class RfbClient(RfbClientStream): # pylint: disable=too-many-instance-attribute
await coro await coro
raise RuntimeError("Subtask just finished without any exception") raise RuntimeError("Subtask just finished without any exception")
except asyncio.CancelledError: except asyncio.CancelledError:
logger.info("[%s] %s: Cancelling subtask ...", name, self._remote) logger.info("%s [%s]: Cancelling subtask ...", self._remote, name)
raise raise
except RfbConnectionError as err: except RfbConnectionError as err:
logger.info("[%s] %s: Gone: %s", name, self._remote, err) logger.info("%s [%s]: Gone: %s", self._remote, name, err)
except (RfbError, ssl.SSLError) as err: except (RfbError, ssl.SSLError) as err:
logger.error("[%s] %s: Error: %s", name, self._remote, err) logger.error("%s [%s]: Error: %s", self._remote, name, err)
except Exception: except Exception:
logger.exception("[%s] %s: Unhandled exception", name, self._remote) logger.exception("%s [%s]: Unhandled exception", self._remote, name)
async def __main_task_loop(self) -> None: async def __main_task_loop(self) -> None:
await self.__handshake_version() await self.__handshake_version()
@ -225,7 +225,7 @@ class RfbClient(RfbClientStream): # pylint: disable=too-many-instance-attribute
except ValueError: except ValueError:
raise RfbError(f"Invalid version response: {response!r}") raise RfbError(f"Invalid version response: {response!r}")
self.__rfb_version = (3 if version == 5 else version) self.__rfb_version = (3 if version == 5 else version)
get_logger(0).info("[main] %s: Using RFB version 3.%d", self._remote, self.__rfb_version) get_logger(0).info("%s [main]: Using RFB version 3.%d", self._remote, self.__rfb_version)
# ===== # =====
@ -250,7 +250,7 @@ class RfbClient(RfbClientStream): # pylint: disable=too-many-instance-attribute
raise RfbError(f"Invalid security type: {sec_type}") raise RfbError(f"Invalid security type: {sec_type}")
(sec_name, handler) = sec_types[sec_type] (sec_name, handler) = sec_types[sec_type]
get_logger(0).info("[main] %s: Using %s security type", self._remote, sec_name) get_logger(0).info("%s [main]: Using %s security type", self._remote, sec_name)
await handler() await handler()
async def __handshake_security_vencrypt(self) -> None: # pylint: disable=too-many-branches async def __handshake_security_vencrypt(self) -> None: # pylint: disable=too-many-branches
@ -294,7 +294,7 @@ class RfbClient(RfbClientStream): # pylint: disable=too-many-instance-attribute
raise RfbError(f"Invalid VeNCrypt auth type: {auth_type}") raise RfbError(f"Invalid VeNCrypt auth type: {auth_type}")
(auth_name, tls, handler) = auth_types[auth_type] (auth_name, tls, handler) = auth_types[auth_type]
logger.info("[main] %s: Using %s auth type", self._remote, auth_name) logger.info("%s [main]: Using %s auth type", self._remote, auth_name)
if tls: if tls:
assert self.__tls_ciphers, (self.__tls_ciphers, auth_name, tls, handler) assert self.__tls_ciphers, (self.__tls_ciphers, auth_name, tls, handler)
@ -306,7 +306,7 @@ class RfbClient(RfbClientStream): # pylint: disable=too-many-instance-attribute
assert self.__x509_cert_path assert self.__x509_cert_path
ssl_context.load_cert_chain(self.__x509_cert_path, (self.__x509_key_path or None)) ssl_context.load_cert_chain(self.__x509_cert_path, (self.__x509_key_path or None))
ssl_context.set_ciphers(self.__tls_ciphers) ssl_context.set_ciphers(self.__tls_ciphers)
logger.info("[main] %s: Starting TLS (%s) ...", self._remote, tls_str) logger.info("%s [main]: Starting TLS (%s) ...", self._remote, tls_str)
await self._start_tls(ssl_context, self.__tls_timeout) await self._start_tls(ssl_context, self.__tls_timeout)
await handler() await handler()
@ -358,7 +358,7 @@ class RfbClient(RfbClientStream): # pylint: disable=too-many-instance-attribute
async def __handshake_security_send_result(self, allow: bool, allow_msg: str, deny_msg: str, deny_reason: str) -> None: async def __handshake_security_send_result(self, allow: bool, allow_msg: str, deny_msg: str, deny_reason: str) -> None:
if allow: if allow:
get_logger(0).info("[main] %s: %s", self._remote, allow_msg) get_logger(0).info("%s [main]: %s", self._remote, allow_msg)
await self._write_struct("access OK", "L", 0) await self._write_struct("access OK", "L", 0)
else: else:
await self._write_struct("access denial flag", "L", 1, drain=(self.__rfb_version < 8)) await self._write_struct("access denial flag", "L", 1, drain=(self.__rfb_version < 8))
@ -425,9 +425,9 @@ class RfbClient(RfbClientStream): # pylint: disable=too-many-instance-attribute
raise RfbError(f"Too many encodings: {encodings_count}") raise RfbError(f"Too many encodings: {encodings_count}")
self._encodings = RfbClientEncodings(frozenset(await self._read_struct("encodings list", "l" * encodings_count))) self._encodings = RfbClientEncodings(frozenset(await self._read_struct("encodings list", "l" * encodings_count)))
logger.info("[main] %s: Client features (SetEncodings):", self._remote) logger.info("%s [main]: Client features (SetEncodings):", self._remote)
for item in self._encodings.get_summary(): for item in self._encodings.get_summary():
logger.info("[main] %s: ... %s", self._remote, item) logger.info("%s [main]: ... %s", self._remote, item)
self.__check_encodings() self.__check_encodings()
if self._encodings.has_ext_keys: # Preferred method if self._encodings.has_ext_keys: # Preferred method

28
kvmd/apps/vnc/server.py
View File

@ -157,14 +157,14 @@ class _Client(RfbClient): # pylint: disable=too-many-instance-attributes
logger = get_logger(0) logger = get_logger(0)
await self.__stage1_authorized.wait_passed() await self.__stage1_authorized.wait_passed()
logger.info("[kvmd] %s: Waiting for the SetEncodings message ...", self._remote) logger.info("%s [kvmd]: Waiting for the SetEncodings message ...", self._remote)
if not (await self.__stage2_encodings_accepted.wait_passed(timeout=5)): if not (await self.__stage2_encodings_accepted.wait_passed(timeout=5)):
raise RfbError("No SetEncodings message recieved from the client in 5 secs") raise RfbError("No SetEncodings message recieved from the client in 5 secs")
assert self.__kvmd_session assert self.__kvmd_session
try: try:
async with self.__kvmd_session.ws() as self.__kvmd_ws: async with self.__kvmd_session.ws() as self.__kvmd_ws:
logger.info("[kvmd] %s: Connected to KVMD websocket", self._remote) logger.info("%s [kvmd]: Connected to KVMD websocket", self._remote)
self.__stage3_ws_connected.set_passed() self.__stage3_ws_connected.set_passed()
async for (event_type, event) in self.__kvmd_ws.communicate(): async for (event_type, event) in self.__kvmd_ws.communicate():
await self.__process_ws_event(event_type, event) await self.__process_ws_event(event_type, event)
@ -202,7 +202,7 @@ class _Client(RfbClient): # pylint: disable=too-many-instance-attributes
streaming = False streaming = False
async for frame in streamer.read_stream(): async for frame in streamer.read_stream():
if not streaming: if not streaming:
logger.info("[streamer] %s: Streaming ...", self._remote) logger.info("%s [streamer]: Streaming ...", self._remote)
streaming = True streaming = True
if frame["online"]: if frame["online"]:
await self.__queue_frame(frame) await self.__queue_frame(frame)
@ -211,9 +211,9 @@ class _Client(RfbClient): # pylint: disable=too-many-instance-attributes
except StreamerError as err: except StreamerError as err:
if isinstance(err, StreamerPermError): if isinstance(err, StreamerPermError):
streamer = self.__get_default_streamer() streamer = self.__get_default_streamer()
logger.info("[streamer] %s: Permanent error: %s; switching to %s ...", self._remote, err, streamer) logger.info("%s [streamer]: Permanent error: %s; switching to %s ...", self._remote, err, streamer)
else: else:
logger.info("[streamer] %s: Waiting for stream: %s", self._remote, err) logger.info("%s [streamer]: Waiting for stream: %s", self._remote, err)
await self.__queue_frame("Waiting for stream ...") await self.__queue_frame("Waiting for stream ...")
await asyncio.sleep(1) await asyncio.sleep(1)
@ -225,13 +225,13 @@ class _Client(RfbClient): # pylint: disable=too-many-instance-attributes
streamer: Optional[BaseStreamerClient] = None streamer: Optional[BaseStreamerClient] = None
for streamer in self.__streamers: for streamer in self.__streamers:
if getattr(self._encodings, formats[streamer.get_format()]): if getattr(self._encodings, formats[streamer.get_format()]):
get_logger(0).info("[streamer] %s: Using preferred %s", self._remote, streamer) get_logger(0).info("%s [streamer]: Using preferred %s", self._remote, streamer)
return streamer return streamer
raise RuntimeError("No streamers found") raise RuntimeError("No streamers found")
def __get_default_streamer(self) -> BaseStreamerClient: def __get_default_streamer(self) -> BaseStreamerClient:
streamer = self.__streamers[-1] streamer = self.__streamers[-1]
get_logger(0).info("[streamer] %s: Using default %s", self._remote, streamer) get_logger(0).info("%s [streamer]: Using default %s", self._remote, streamer)
return streamer return streamer
async def __queue_frame(self, frame: Union[Dict, str]) -> None: async def __queue_frame(self, frame: Union[Dict, str]) -> None:
@ -382,14 +382,14 @@ class _Client(RfbClient): # pylint: disable=too-many-instance-attributes
assert self.__stage1_authorized.is_passed() assert self.__stage1_authorized.is_passed()
assert self.__kvmd_session assert self.__kvmd_session
logger = get_logger(0) logger = get_logger(0)
logger.info("[main] %s: Printing %d characters ...", self._remote, len(text)) logger.info("%s [main]: Printing %d characters ...", self._remote, len(text))
try: try:
(keymap_name, available) = await self.__kvmd_session.hid.get_keymaps() (keymap_name, available) = await self.__kvmd_session.hid.get_keymaps()
if self.__keymap_name in available: if self.__keymap_name in available:
keymap_name = self.__keymap_name keymap_name = self.__keymap_name
await self.__kvmd_session.hid.print(text, 0, keymap_name) await self.__kvmd_session.hid.print(text, 0, keymap_name)
except Exception: except Exception:
logger.exception("[main] %s: Can't print characters", self._remote) logger.exception("%s [main]: Can't print characters", self._remote)
async def _on_set_encodings(self) -> None: async def _on_set_encodings(self) -> None:
assert self.__stage1_authorized.is_passed() assert self.__stage1_authorized.is_passed()
@ -398,7 +398,7 @@ class _Client(RfbClient): # pylint: disable=too-many-instance-attributes
has_quality = (await self.__kvmd_session.streamer.get_state())["features"]["quality"] has_quality = (await self.__kvmd_session.streamer.get_state())["features"]["quality"]
quality = (self._encodings.tight_jpeg_quality if has_quality else None) quality = (self._encodings.tight_jpeg_quality if has_quality else None)
get_logger(0).info("[main] %s: Applying streamer params: jpeg_quality=%s; desired_fps=%d ...", get_logger(0).info("%s [main]: Applying streamer params: jpeg_quality=%s; desired_fps=%d ...",
self._remote, quality, self.__desired_fps) self._remote, quality, self.__desired_fps)
await self.__kvmd_session.streamer.set_params(quality, self.__desired_fps) await self.__kvmd_session.streamer.set_params(quality, self.__desired_fps)
@ -449,7 +449,7 @@ class VncServer: # pylint: disable=too-many-instance-attributes
async def handle_client(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None: async def handle_client(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
logger = get_logger(0) logger = get_logger(0)
remote = rfb_format_remote(writer) remote = rfb_format_remote(writer)
logger.info("[entry] %s: Connected client", remote) logger.info("%s [entry]: Connected client", remote)
try: try:
sock = writer.get_extra_info("socket") sock = writer.get_extra_info("socket")
if no_delay: if no_delay:
@ -468,7 +468,7 @@ class VncServer: # pylint: disable=too-many-instance-attributes
async with kvmd.make_session("", "") as kvmd_session: async with kvmd.make_session("", "") as kvmd_session:
none_auth_only = await kvmd_session.auth.check() none_auth_only = await kvmd_session.auth.check()
except (aiohttp.ClientError, asyncio.TimeoutError) as err: except (aiohttp.ClientError, asyncio.TimeoutError) as err:
logger.error("[entry] %s: Can't check KVMD auth mode: %s", remote, tools.efmt(err)) logger.error("%s [entry]: Can't check KVMD auth mode: %s", remote, tools.efmt(err))
return return
await _Client( await _Client(
@ -489,10 +489,10 @@ class VncServer: # pylint: disable=too-many-instance-attributes
shared_params=shared_params, shared_params=shared_params,
).run() ).run()
except Exception: except Exception:
logger.exception("[entry] %s: Unhandled exception in client task", remote) logger.exception("%s [entry]: Unhandled exception in client task", remote)
finally: finally:
if (await aiotools.close_writer(writer)): if (await aiotools.close_writer(writer)):
logger.info("[entry] %s: Connection is closed in an emergency", remote) logger.info("%s [entry]: Connection is closed in an emergency", remote)
self.__handle_client = handle_client self.__handle_client = handle_client