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

refactoring

Browse Source
This commit is contained in:
Maxim Devaev 2025-02-10 00:06:49 +02:00
parent 97b405297b
commit 6ffaa8d6bd
6 changed files with 53 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
kvmd/apps/kvmd/api/log.py
View File

@ -52,11 +52,11 @@ class LogApi:
raise LogReaderDisabledError() raise LogReaderDisabledError()
seek = valid_log_seek(req.query.get("seek", 0)) seek = valid_log_seek(req.query.get("seek", 0))
follow = valid_bool(req.query.get("follow", False)) follow = valid_bool(req.query.get("follow", False))
response = await start_streaming(req, "text/plain") resp = await start_streaming(req, "text/plain")
async for record in self.__log_reader.poll_log(seek, follow): async for record in self.__log_reader.poll_log(seek, follow):
await response.write(("[%s %s] --- %s" % ( await resp.write(("[%s %s] --- %s" % (
record["dt"].strftime("%Y-%m-%d %H:%M:%S"), record["dt"].strftime("%Y-%m-%d %H:%M:%S"),
record["service"], record["service"],
record["msg"], record["msg"],
)).encode("utf-8") + b"\r\n") )).encode("utf-8") + b"\r\n")
return response return resp

20
kvmd/apps/kvmd/api/msd.py
View File

@ -127,10 +127,10 @@ class MsdApi:
src = compressed() src = compressed()
size = -1 size = -1
response = await start_streaming(req, "application/octet-stream", size, name + suffix) resp = await start_streaming(req, "application/octet-stream", size, name + suffix)
async for chunk in src: async for chunk in src:
await response.write(chunk) await resp.write(chunk)
return response return resp
# ===== # =====
@ -160,11 +160,11 @@ class MsdApi:
name = "" name = ""
size = written = 0 size = written = 0
response: (StreamResponse | None) = None resp: (StreamResponse | None) = None
async def stream_write_info() -> None: async def stream_write_info() -> None:
assert response is not None assert resp is not None
await stream_json(response, self.__make_write_info(name, size, written)) await stream_json(resp, self.__make_write_info(name, size, written))
try: try:
async with htclient.download( async with htclient.download(
@ -184,7 +184,7 @@ class MsdApi:
get_logger(0).info("Downloading image %r as %r to MSD ...", url, name) get_logger(0).info("Downloading image %r as %r to MSD ...", url, name)
async with self.__msd.write_image(name, size, remove_incomplete) as writer: async with self.__msd.write_image(name, size, remove_incomplete) as writer:
chunk_size = writer.get_chunk_size() chunk_size = writer.get_chunk_size()
response = await start_streaming(req, "application/x-ndjson") resp = await start_streaming(req, "application/x-ndjson")
await stream_write_info() await stream_write_info()
last_report_ts = 0 last_report_ts = 0
async for chunk in remote.content.iter_chunked(chunk_size): async for chunk in remote.content.iter_chunked(chunk_size):
@ -195,12 +195,12 @@ class MsdApi:
last_report_ts = now last_report_ts = now
await stream_write_info() await stream_write_info()
return response return resp
except Exception as ex: except Exception as ex:
if response is not None: if resp is not None:
await stream_write_info() await stream_write_info()
await stream_json_exception(response, ex) await stream_json_exception(resp, ex)
elif isinstance(ex, aiohttp.ClientError): elif isinstance(ex, aiohttp.ClientError):
return make_json_exception(ex, 400) return make_json_exception(ex, 400)
raise raise

6
kvmd/apps/kvmd/info/fan.py
View File

@ -99,9 +99,9 @@ class FanInfoSubmanager(BaseInfoSubmanager):
async def __get_fan_state(self) -> (dict | None): async def __get_fan_state(self) -> (dict | None):
try: try:
async with self.__make_http_session() as session: async with self.__make_http_session() as session:
async with session.get("http://localhost/state") as response: async with session.get("http://localhost/state") as resp:
htclient.raise_not_200(response) htclient.raise_not_200(resp)
return (await response.json())["result"] return (await resp.json())["result"]
except Exception as ex: except Exception as ex:
get_logger(0).error("Can't read fan state: %s", ex) get_logger(0).error("Can't read fan state: %s", ex)
return None return None

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

@ -235,18 +235,18 @@ class RfbClient(RfbClientStream): # pylint: disable=too-many-instance-attribute
await self._write_struct("handshake server version", "", b"RFB 003.008\n") await self._write_struct("handshake server version", "", b"RFB 003.008\n")
response = await self._read_text("handshake client version", 12) resp = await self._read_text("handshake client version", 12)
if ( if (
not response.startswith("RFB 003.00") not resp.startswith("RFB 003.00")
or not response.endswith("\n") or not resp.endswith("\n")
or response[-2] not in ["3", "5", "7", "8"] or resp[-2] not in ["3", "5", "7", "8"]
): ):
raise RfbError(f"Invalid version response: {response!r}") raise RfbError(f"Invalid version response: {resp!r}")
try: try:
version = int(response[-2]) version = int(resp[-2])
except ValueError: except ValueError:
raise RfbError(f"Invalid version response: {response!r}") raise RfbError(f"Invalid version response: {resp!r}")
self.__rfb_version = (3 if version == 5 else version) self.__rfb_version = (3 if version == 5 else version)
get_logger(0).info("%s [main]: 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)

34
kvmd/clients/kvmd.py
View File

@ -51,16 +51,16 @@ class _BaseApiPart:
for (key, value) in params.items() for (key, value) in params.items()
if value is not None if value is not None
}, },
) as response: ) as resp:
htclient.raise_not_200(response) htclient.raise_not_200(resp)
class _AuthApiPart(_BaseApiPart): class _AuthApiPart(_BaseApiPart):
async def check(self) -> bool: async def check(self) -> bool:
session = self._ensure_http_session() session = self._ensure_http_session()
try: try:
async with session.get("/auth/check") as response: async with session.get("/auth/check") as resp:
htclient.raise_not_200(response) htclient.raise_not_200(resp)
return True return True
except aiohttp.ClientResponseError as ex: except aiohttp.ClientResponseError as ex:
if ex.status in [400, 401, 403]: if ex.status in [400, 401, 403]:
@ -71,9 +71,9 @@ class _AuthApiPart(_BaseApiPart):
class _StreamerApiPart(_BaseApiPart): class _StreamerApiPart(_BaseApiPart):
async def get_state(self) -> dict: async def get_state(self) -> dict:
session = self._ensure_http_session() session = self._ensure_http_session()
async with session.get("/streamer") as response: async with session.get("/streamer") as resp:
htclient.raise_not_200(response) htclient.raise_not_200(resp)
return (await response.json())["result"] return (await resp.json())["result"]
async def set_params(self, quality: (int | None)=None, desired_fps: (int | None)=None) -> None: async def set_params(self, quality: (int | None)=None, desired_fps: (int | None)=None) -> None:
await self._set_params( await self._set_params(
@ -86,9 +86,9 @@ class _StreamerApiPart(_BaseApiPart):
class _HidApiPart(_BaseApiPart): class _HidApiPart(_BaseApiPart):
async def get_keymaps(self) -> tuple[str, set[str]]: async def get_keymaps(self) -> tuple[str, set[str]]:
session = self._ensure_http_session() session = self._ensure_http_session()
async with session.get("/hid/keymaps") as response: async with session.get("/hid/keymaps") as resp:
htclient.raise_not_200(response) htclient.raise_not_200(resp)
result = (await response.json())["result"] result = (await resp.json())["result"]
return (result["keymaps"]["default"], set(result["keymaps"]["available"])) return (result["keymaps"]["default"], set(result["keymaps"]["available"]))
async def print(self, text: str, limit: int, keymap_name: str) -> None: async def print(self, text: str, limit: int, keymap_name: str) -> None:
@ -97,8 +97,8 @@ class _HidApiPart(_BaseApiPart):
url="/hid/print", url="/hid/print",
params={"limit": limit, "keymap": keymap_name}, params={"limit": limit, "keymap": keymap_name},
data=text, data=text,
) as response: ) as resp:
htclient.raise_not_200(response) htclient.raise_not_200(resp)
async def set_params(self, keyboard_output: (str | None)=None, mouse_output: (str | None)=None) -> None: async def set_params(self, keyboard_output: (str | None)=None, mouse_output: (str | None)=None) -> None:
await self._set_params( await self._set_params(
@ -111,9 +111,9 @@ class _HidApiPart(_BaseApiPart):
class _AtxApiPart(_BaseApiPart): class _AtxApiPart(_BaseApiPart):
async def get_state(self) -> dict: async def get_state(self) -> dict:
session = self._ensure_http_session() session = self._ensure_http_session()
async with session.get("/atx") as response: async with session.get("/atx") as resp:
htclient.raise_not_200(response) htclient.raise_not_200(resp)
return (await response.json())["result"] return (await resp.json())["result"]
async def switch_power(self, action: str) -> bool: async def switch_power(self, action: str) -> bool:
session = self._ensure_http_session() session = self._ensure_http_session()
@ -121,8 +121,8 @@ class _AtxApiPart(_BaseApiPart):
async with session.post( async with session.post(
url="/atx/power", url="/atx/power",
params={"action": action}, params={"action": action},
) as response: ) as resp:
htclient.raise_not_200(response) htclient.raise_not_200(resp)
return True return True
except aiohttp.ClientResponseError as ex: except aiohttp.ClientResponseError as ex:
if ex.status == 409: if ex.status == 409:

26
kvmd/clients/streamer.py
View File

@ -117,25 +117,25 @@ class StreamerSnapshot:
class HttpStreamerClientSession(BaseHttpClientSession): class HttpStreamerClientSession(BaseHttpClientSession):
async def get_state(self) -> dict: async def get_state(self) -> dict:
session = self._ensure_http_session() session = self._ensure_http_session()
async with session.get("/state") as response: async with session.get("/state") as resp:
htclient.raise_not_200(response) htclient.raise_not_200(resp)
return (await response.json())["result"] return (await resp.json())["result"]
async def take_snapshot(self, timeout: float) -> StreamerSnapshot: async def take_snapshot(self, timeout: float) -> StreamerSnapshot:
session = self._ensure_http_session() session = self._ensure_http_session()
async with session.get( async with session.get(
url="/snapshot", url="/snapshot",
timeout=aiohttp.ClientTimeout(total=timeout), timeout=aiohttp.ClientTimeout(total=timeout),
) as response: ) as resp:
htclient.raise_not_200(response) htclient.raise_not_200(resp)
return StreamerSnapshot( return StreamerSnapshot(
online=(response.headers["X-UStreamer-Online"] == "true"), online=(resp.headers["X-UStreamer-Online"] == "true"),
width=int(response.headers["X-UStreamer-Width"]), width=int(resp.headers["X-UStreamer-Width"]),
height=int(response.headers["X-UStreamer-Height"]), height=int(resp.headers["X-UStreamer-Height"]),
headers=tuple( headers=tuple(
(key, value) (key, value)
for (key, value) in tools.sorted_kvs(dict(response.headers)) for (key, value) in tools.sorted_kvs(dict(resp.headers))
if key.lower().startswith("x-ustreamer-") or key.lower() in [ if key.lower().startswith("x-ustreamer-") or key.lower() in [
"x-timestamp", "x-timestamp",
"access-control-allow-origin", "access-control-allow-origin",
@ -144,7 +144,7 @@ class HttpStreamerClientSession(BaseHttpClientSession):
"expires", "expires",
] ]
), ),
data=bytes(await response.read()), data=bytes(await resp.read()),
) )
@ -187,10 +187,10 @@ class HttpStreamerClient(BaseHttpClient, BaseStreamerClient):
connect=session.timeout.total, connect=session.timeout.total,
sock_read=session.timeout.total, sock_read=session.timeout.total,
), ),
) as response: ) as resp:
htclient.raise_not_200(response) htclient.raise_not_200(resp)
reader = aiohttp.MultipartReader.from_response(response) reader = aiohttp.MultipartReader.from_response(resp)
self.__patch_stream_reader(reader.resp.content) self.__patch_stream_reader(reader.resp.content)
async def read_frame(key_required: bool) -> dict: async def read_frame(key_required: bool) -> dict: