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()
seek = valid_log_seek(req.query.get("seek", 0))
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):
await response.write(("[%s %s] --- %s" % (
await resp.write(("[%s %s] --- %s" % (
record["dt"].strftime("%Y-%m-%d %H:%M:%S"),
record["service"],
record["msg"],
)).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()
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:
await response.write(chunk)
return response
await resp.write(chunk)
return resp
# =====
@ -160,11 +160,11 @@ class MsdApi:
name = ""
size = written = 0
response: (StreamResponse | None) = None
resp: (StreamResponse | None) = None
async def stream_write_info() -> None:
assert response is not None
await stream_json(response, self.__make_write_info(name, size, written))
assert resp is not None
await stream_json(resp, self.__make_write_info(name, size, written))
try:
async with htclient.download(
@ -184,7 +184,7 @@ class MsdApi:
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:
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()
last_report_ts = 0
async for chunk in remote.content.iter_chunked(chunk_size):
@ -195,12 +195,12 @@ class MsdApi:
last_report_ts = now
await stream_write_info()
return response
return resp
except Exception as ex:
if response is not None:
if resp is not None:
await stream_write_info()
await stream_json_exception(response, ex)
await stream_json_exception(resp, ex)
elif isinstance(ex, aiohttp.ClientError):
return make_json_exception(ex, 400)
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):
try:
async with self.__make_http_session() as session:
async with session.get("http://localhost/state") as response:
htclient.raise_not_200(response)
return (await response.json())["result"]
async with session.get("http://localhost/state") as resp:
htclient.raise_not_200(resp)
return (await resp.json())["result"]
except Exception as ex:
get_logger(0).error("Can't read fan state: %s", ex)
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")
response = await self._read_text("handshake client version", 12)
resp = await self._read_text("handshake client version", 12)
if (
not response.startswith("RFB 003.00")
or not response.endswith("\n")
or response[-2] not in ["3", "5", "7", "8"]
not resp.startswith("RFB 003.00")
or not resp.endswith("\n")
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:
version = int(response[-2])
version = int(resp[-2])
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)
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()
if value is not None
},
) as response:
htclient.raise_not_200(response)
) as resp:
htclient.raise_not_200(resp)
class _AuthApiPart(_BaseApiPart):
async def check(self) -> bool:
session = self._ensure_http_session()
try:
async with session.get("/auth/check") as response:
htclient.raise_not_200(response)
async with session.get("/auth/check") as resp:
htclient.raise_not_200(resp)
return True
except aiohttp.ClientResponseError as ex:
if ex.status in [400, 401, 403]:
@ -71,9 +71,9 @@ class _AuthApiPart(_BaseApiPart):
class _StreamerApiPart(_BaseApiPart):
async def get_state(self) -> dict:
session = self._ensure_http_session()
async with session.get("/streamer") as response:
htclient.raise_not_200(response)
return (await response.json())["result"]
async with session.get("/streamer") as resp:
htclient.raise_not_200(resp)
return (await resp.json())["result"]
async def set_params(self, quality: (int | None)=None, desired_fps: (int | None)=None) -> None:
await self._set_params(
@ -86,9 +86,9 @@ class _StreamerApiPart(_BaseApiPart):
class _HidApiPart(_BaseApiPart):
async def get_keymaps(self) -> tuple[str, set[str]]:
session = self._ensure_http_session()
async with session.get("/hid/keymaps") as response:
htclient.raise_not_200(response)
result = (await response.json())["result"]
async with session.get("/hid/keymaps") as resp:
htclient.raise_not_200(resp)
result = (await resp.json())["result"]
return (result["keymaps"]["default"], set(result["keymaps"]["available"]))
async def print(self, text: str, limit: int, keymap_name: str) -> None:
@ -97,8 +97,8 @@ class _HidApiPart(_BaseApiPart):
url="/hid/print",
params={"limit": limit, "keymap": keymap_name},
data=text,
) as response:
htclient.raise_not_200(response)
) as resp:
htclient.raise_not_200(resp)
async def set_params(self, keyboard_output: (str | None)=None, mouse_output: (str | None)=None) -> None:
await self._set_params(
@ -111,9 +111,9 @@ class _HidApiPart(_BaseApiPart):
class _AtxApiPart(_BaseApiPart):
async def get_state(self) -> dict:
session = self._ensure_http_session()
async with session.get("/atx") as response:
htclient.raise_not_200(response)
return (await response.json())["result"]
async with session.get("/atx") as resp:
htclient.raise_not_200(resp)
return (await resp.json())["result"]
async def switch_power(self, action: str) -> bool:
session = self._ensure_http_session()
@ -121,8 +121,8 @@ class _AtxApiPart(_BaseApiPart):
async with session.post(
url="/atx/power",
params={"action": action},
) as response:
htclient.raise_not_200(response)
) as resp:
htclient.raise_not_200(resp)
return True
except aiohttp.ClientResponseError as ex:
if ex.status == 409:

26
kvmd/clients/streamer.py
View File

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