大幅优化镜像体积

1. 使用 docker 预构建的必需文件，而不是安装全量依赖
2. 使用 zerofree 清除镜像无效数据
将 janus 日志级别调整为2

.bumpversion.cfg

@@ -1,7 +1,7 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 4.3
+current_version = 4.49
 parse = (?P<major>\d+)\.(?P<minor>\d+)(\.(?P<patch>\d+)(\-(?P<release>[a-z]+))?)?
 serialize = 
 	{major}.{minor}

.gitignore

@@ -1,5 +1,6 @@
 /pkg/
-/src/
+/src/**/*.img
+/src/tmp
 /site/
 /dist/
 /kvmd.egg-info/

LICENSE

@@ -1,11 +1,7 @@
                     GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
-<<<<<<< HEAD
  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
-=======
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
->>>>>>> origin/dev
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -649,11 +645,7 @@ the "copyright" line and a pointer to where the full notice is found.
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
-<<<<<<< HEAD
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
-=======
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
->>>>>>> origin/dev
 
 Also add information on how to contact you by electronic and paper mail.
 
@@ -672,19 +664,11 @@ might be different; for a GUI interface, you would use an "about box".
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
 For more information on this, and how to apply and follow the GNU GPL, see
-<<<<<<< HEAD
 <https://www.gnu.org/licenses/>.
-=======
-<http://www.gnu.org/licenses/>.
->>>>>>> origin/dev
 
   The GNU General Public License does not permit incorporating your program
 into proprietary programs.  If your program is a subroutine library, you
 may consider it more useful to permit linking proprietary applications with
 the library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.  But first, please read
-<<<<<<< HEAD
 <https://www.gnu.org/licenses/why-not-lgpl.html>.
-=======
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.
->>>>>>> origin/dev

Makefile

@@ -86,7 +86,9 @@ tox: testenv
 			&& cp /usr/share/kvmd/configs.default/kvmd/*.yaml /etc/kvmd \
 			&& cp /usr/share/kvmd/configs.default/kvmd/*passwd /etc/kvmd \
 			&& cp /usr/share/kvmd/configs.default/kvmd/*.secret /etc/kvmd \
+			&& cp /usr/share/kvmd/configs.default/kvmd/edid/v2.hex /etc/kvmd/switch-edid.hex \
 			&& cp /usr/share/kvmd/configs.default/kvmd/main/$(if $(P),$(P),$(DEFAULT_PLATFORM)).yaml /etc/kvmd/main.yaml \
+			&& cp /usr/share/kvmd/configs.default/kvmd/main.yaml /etc/kvmd/main.yaml \
 			&& mkdir -p /etc/kvmd/override.d \
 			&& cp /src/testenv/$(if $(P),$(P),$(DEFAULT_PLATFORM)).override.yaml /etc/kvmd/override.yaml \
 			&& cd /src \
@@ -102,6 +104,7 @@ $(TESTENV_GPIO):
 
 run: testenv $(TESTENV_GPIO)
 	- $(DOCKER) run --rm --name kvmd \
+			--ipc=shareable \
 			--privileged \
 			--volume `pwd`/testenv/run:/run/kvmd:rw \
 			--volume `pwd`/testenv:/testenv:ro \
@@ -128,6 +131,7 @@ run: testenv $(TESTENV_GPIO)
 			&& cp /usr/share/kvmd/configs.default/kvmd/*.yaml /etc/kvmd \
 			&& cp /usr/share/kvmd/configs.default/kvmd/*passwd /etc/kvmd \
 			&& cp /usr/share/kvmd/configs.default/kvmd/*.secret /etc/kvmd \
+			&& cp /usr/share/kvmd/configs.default/kvmd/edid/v2.hex /etc/kvmd/switch-edid.hex \
 			&& cp /usr/share/kvmd/configs.default/kvmd/main/$(if $(P),$(P),$(DEFAULT_PLATFORM)).yaml /etc/kvmd/main.yaml \
 			&& ln -s /testenv/web.css /etc/kvmd/web.css \
 			&& mkdir -p /etc/kvmd/override.d \
@@ -155,7 +159,9 @@ run-cfg: testenv
 			&& cp /usr/share/kvmd/configs.default/kvmd/*.yaml /etc/kvmd \
 			&& cp /usr/share/kvmd/configs.default/kvmd/*passwd /etc/kvmd \
 			&& cp /usr/share/kvmd/configs.default/kvmd/*.secret /etc/kvmd \
+			&& cp /usr/share/kvmd/configs.default/kvmd/edid/v2.hex /etc/kvmd/switch-edid.hex \
 			&& cp /usr/share/kvmd/configs.default/kvmd/main/$(if $(P),$(P),$(DEFAULT_PLATFORM)).yaml /etc/kvmd/main.yaml \
+			&& cp  /usr/share/kvmd/configs.default/kvmd/main.yaml /etc/kvmd/main.yaml \
 			&& mkdir -p /etc/kvmd/override.d \
 			&& cp /testenv/$(if $(P),$(P),$(DEFAULT_PLATFORM)).override.yaml /etc/kvmd/override.yaml \
 			&& $(if $(CMD),$(CMD),python -m kvmd.apps.kvmd -m) \
@@ -178,6 +184,7 @@ run-ipmi: testenv
 			&& cp /usr/share/kvmd/configs.default/kvmd/*.yaml /etc/kvmd \
 			&& cp /usr/share/kvmd/configs.default/kvmd/*passwd /etc/kvmd \
 			&& cp /usr/share/kvmd/configs.default/kvmd/*.secret /etc/kvmd \
+			&& cp /usr/share/kvmd/configs.default/kvmd/edid/v2.hex /etc/kvmd/switch-edid.hex \
 			&& cp /usr/share/kvmd/configs.default/kvmd/main/$(if $(P),$(P),$(DEFAULT_PLATFORM)).yaml /etc/kvmd/main.yaml \
 			&& mkdir -p /etc/kvmd/override.d \
 			&& cp /testenv/$(if $(P),$(P),$(DEFAULT_PLATFORM)).override.yaml /etc/kvmd/override.yaml \
@@ -187,6 +194,7 @@ run-ipmi: testenv
 
 run-vnc: testenv
 	- $(DOCKER) run --rm --name kvmd-vnc \
+			--ipc=container:kvmd \
 			--volume `pwd`/testenv/run:/run/kvmd:rw \
 			--volume `pwd`/testenv:/testenv:ro \
 			--volume `pwd`/kvmd:/kvmd:ro \
@@ -201,6 +209,7 @@ run-vnc: testenv
 			&& cp /usr/share/kvmd/configs.default/kvmd/*.yaml /etc/kvmd \
 			&& cp /usr/share/kvmd/configs.default/kvmd/*passwd /etc/kvmd \
 			&& cp /usr/share/kvmd/configs.default/kvmd/*.secret /etc/kvmd \
+			&& cp /usr/share/kvmd/configs.default/kvmd/edid/v2.hex /etc/kvmd/switch-edid.hex \
 			&& cp /usr/share/kvmd/configs.default/kvmd/main/$(if $(P),$(P),$(DEFAULT_PLATFORM)).yaml /etc/kvmd/main.yaml \
 			&& mkdir -p /etc/kvmd/override.d \
 			&& cp /testenv/$(if $(P),$(P),$(DEFAULT_PLATFORM)).override.yaml /etc/kvmd/override.yaml \
@@ -271,36 +280,24 @@ clean-all: testenv clean
 .PHONY: testenv
 
 run-stage-0:
-	$(DOCKER) buildx build -t registry.cn-hangzhou.aliyuncs.com/silentwind/kvmd-stage-0 \
-		--allow security.insecure --progress plain \
-		--platform linux/amd64,linux/arm64,linux/arm/v7  \
-		-f build/Dockerfile-stage-0 . \
-		--push
-	$(DOCKER) buildx build -t silentwind0/kvmd-stage-0 \
+	$(DOCKER) buildx build -t registry.cn-hangzhou.aliyuncs.com/silentwind/kvmd-stage-0 -t silentwind0/kvmd-stage-0 \
 		--allow security.insecure --progress plain \
 		--platform linux/amd64,linux/arm64,linux/arm/v7  \
 		-f build/Dockerfile-stage-0 . \
 		--push
 
 run-build-dev:
-	$(DOCKER) buildx build -t registry.cn-hangzhou.aliyuncs.com/silentwind/kvmd:dev \
-		--platform linux/amd64,linux/arm64,linux/arm/v7  \
-		-f build/Dockerfile . \
-		--push
-	$(DOCKER) buildx build -t silentwind0/kvmd:dev \
+	$(DOCKER) buildx build -t registry.cn-hangzhou.aliyuncs.com/silentwind/kvmd:dev -t silentwind0/kvmd:dev \
 		--platform linux/amd64,linux/arm64,linux/arm/v7  \
+		--build-arg CACHEBUST=$(date +%s) \
 		-f build/Dockerfile . \
 		--push
 
 run-build-release:
-	$(DOCKER) buildx build -t registry.cn-hangzhou.aliyuncs.com/silentwind/kvmd \
-		--progress plain \
-		--platform linux/amd64,linux/arm64,linux/arm/v7  \
-		-f build/Dockerfile . \
-		--push
-	$(DOCKER) buildx build -t silentwind0/kvmd \
+	$(DOCKER) buildx build -t registry.cn-hangzhou.aliyuncs.com/silentwind/kvmd	-t silentwind0/kvmd \
 		--progress plain \
 		--platform linux/amd64,linux/arm64,linux/arm/v7  \
+		--build-arg CACHEBUST=$(date +%s) \
 		-f build/Dockerfile . \
 		--push
 
@@ -331,7 +328,7 @@ run-nogpio: testenv
 			&& cp /usr/share/kvmd/configs.default/kvmd/*.yaml /etc/kvmd \
 			&& cp /usr/share/kvmd/configs.default/kvmd/*passwd /etc/kvmd \
 			&& cp /usr/share/kvmd/configs.default/kvmd/*.secret /etc/kvmd \
-			&& cp /usr/share/kvmd/configs.default/kvmd/main/$(if $(P),$(P),$(DEFAULT_PLATFORM)).yaml /etc/kvmd/main.yaml \
+			&& cp /usr/share/kvmd/configs.default/kvmd/main.yaml /etc/kvmd/main.yaml \
 			&& ln -s /testenv/web.css /etc/kvmd/web.css \
 			&& mkdir -p /etc/kvmd/override.d \
 			&& cp /testenv/$(if $(P),$(P),$(DEFAULT_PLATFORM)).override.yaml /etc/kvmd/override.yaml \

PKGBUILD

@@ -39,15 +39,15 @@ for _variant in "${_variants[@]}"; do
 	pkgname+=(kvmd-platform-$_platform-$_board)
 done
 pkgbase=kvmd
-pkgver=4.3
+pkgver=4.49
 pkgrel=1
 pkgdesc="The main PiKVM daemon"
 url="https://github.com/pikvm/kvmd"
 license=(GPL)
 arch=(any)
 depends=(
-	"python>=3.12"
-	"python<3.13"
+	"python>=3.13"
+	"python<3.14"
 	python-yaml
 	python-aiohttp
 	python-aiofiles
@@ -77,6 +77,9 @@ depends=(
 	python-ldap
 	python-zstandard
 	python-mako
+	python-luma-oled
+	python-pyusb
+	python-pyudev
 	"libgpiod>=2.1"
 	freetype2
 	"v4l-utils>=1.22.1-1"
@@ -87,11 +90,11 @@ depends=(
 	iproute2
 	dnsmasq
 	ipmitool
-	"janus-gateway-pikvm>=0.14.2-3"
+	"janus-gateway-pikvm>=1.3.0"
 	certbot
 	platform-io-access
 	raspberrypi-utils
-	"ustreamer>=6.11"
+	"ustreamer>=6.26"
 
 	# Systemd UDEV bug
 	"systemd>=248.3-2"
@@ -131,6 +134,7 @@ conflicts=(
 	python-aiohttp-pikvm
 	platformio
 	avrdude-pikvm
+	kvmd-oled
 )
 makedepends=(
 	python-setuptools
@@ -164,7 +168,7 @@ package_kvmd() {
 	install -DTm644 configs/os/tmpfiles.conf "$pkgdir/usr/lib/tmpfiles.d/kvmd.conf"
 
 	mkdir -p "$pkgdir/usr/share/kvmd"
-	cp -r {hid,web,extras,contrib/keymaps} "$pkgdir/usr/share/kvmd"
+	cp -r {switch,hid,web,extras,contrib/keymaps} "$pkgdir/usr/share/kvmd"
 	find "$pkgdir/usr/share/kvmd/web" -name '*.pug' -exec rm -f '{}' \;
 
 	local _cfg_default="$pkgdir/usr/share/kvmd/configs.default"
@@ -206,7 +210,7 @@ for _variant in "${_variants[@]}"; do
 		cd \"kvmd-\$pkgver\"
 
 		pkgdesc=\"PiKVM platform configs - $_platform for $_board\"
-		depends=(kvmd=$pkgver-$pkgrel \"linux-rpi-pikvm>=6.6.21-3\")
+		depends=(kvmd=$pkgver-$pkgrel \"linux-rpi-pikvm>=6.6.45-10\" \"raspberrypi-bootloader-pikvm>=20240818-1\")
 
 		backup=(
 			etc/sysctl.d/99-kvmd.conf
@@ -250,8 +254,12 @@ for _variant in "${_variants[@]}"; do
 		fi
 
 		if [[ $_platform =~ ^.*-hdmi$ ]]; then
-			backup=(\"\${backup[@]}\" etc/kvmd/tc358743-edid.hex)
+			backup=(\"\${backup[@]}\" etc/kvmd/tc358743-edid.hex etc/kvmd/switch-edid.hex)
 			install -DTm444 configs/kvmd/edid/$_base.hex \"\$pkgdir/etc/kvmd/tc358743-edid.hex\"
+			ln -s tc358743-edid.hex \"\$pkgdir/etc/kvmd/switch-edid.hex\"
+		else
+			backup=(\"\${backup[@]}\" etc/kvmd/switch-edid.hex)
+			install -DTm444 configs/kvmd/edid/_no-1920x1200.hex \"\$pkgdir/etc/kvmd/switch-edid.hex\"
 		fi
 
 		mkdir -p \"\$pkgdir/usr/share/kvmd\"

README.md

@@ -6,17 +6,54 @@
 
 One-KVM 是基于廉价计算机硬件和 [PiKVM]((https://github.com/pikvm/pikvm)) 软件二次开发的 BIOS 级远程控制项目。可以实现远程管理服务器或工作站，无需在被控机安装软件调整设置，实现无侵入式控制，适用范围广泛。
 
+使用文档：[https://one-kvm.mofeng.run](https://one-kvm.mofeng.run)
+
 演示网站：[https://kvmd-demo.mofeng.run](https://kvmd-demo.mofeng.run)
 
 ![image-20240926220156381](https://github.com/user-attachments/assets/a7848bca-e43c-434e-b812-27a45fad7910)
 
+### 软件功能
+
+表格仅为 One-KVM 与其他基于 PiKVM 的项目的功能对比，无不良导向，如有错漏请联系更正。
+
+|         功能          |     One-KVM     |           PiKVM           |   ArmKVM    |   BLIKVM    |
+| :-------------------: | :-------------: | :-----------------------: | :---------: | :---------: |
+|       系统开源        |        √        |             √             |      √      |      √      |
+|    简体中文 WebUI     |        √        |             x             |      √      |      √      |
+|      远程视频流       |   MJPEG/H.264   |        MJPEG/H.264        | MJPEG/H.264 | MJPEG/H.264 |
+|    H.264 视频编码     |       CPU       |            GPU            |    未知     |     GPU     |
+|      远程音频流       |        √        |             √             |      √      |      √      |
+|   远程鼠键控制        |   OTG/CH9329    | OTG/CH9329/Pico/Bluetooth |     OTG     |     OTG     |
+|       VNC 控制        |        √        |             √             |      √      |      √      |
+|     ATX 电源控制      | GPIO/USB 继电器 |           GPIO            |    GPIO     |    GPIO     |
+| 虚拟存储驱动器挂载     |        √        |             √             |      √      |      √      |
+| 2.2G 以上 CD-ROM 挂载 |        x        |             x             |      √      |      √      |
+|     WOL 远程唤醒      |        √        |             √             |      √      |      √      |
+|      网页剪切板       |        √        |             √             |      √      |      √      |
+|     OCR 文字识别      |        √        |             √             |      √      |      √      |
+|       网页终端        |        √        |             √             |      √      |      √      |
+|     网络串口终端      |        x        |             x             |      √      |      √      |
+|    HDMI 切换器支持    |        √        |             √             |      √      |      √      |
+|       视频录制        |        √        |             x             |      x      |      x      |
+|      Docker 部署      |        √        |             x             |      x      |      x      |
+|    官方商业化成品     |        x        |             √             |      √      |      √      |
+|       技术支持        |        √        |             √             |      √      |      √      |
 
 ### 快速开始
 
+更多详细内容可以查阅 [One-KVM文档](https://one-kvm.mofeng.run/)。
+
 **方式一：Docker 镜像部署（推荐）**
 
 Docker 版本可以使用 OTG 或 CH9329 作为虚拟 HID ，支持 amd64、arm64、armv7 架构的 Linux 系统安装。
 
+**脚本部署**
+
+```bash
+curl -sSL https://one-kvm.mofeng.run/quick_start.sh -o quick_start.sh && bash quick_start.sh
+```
+
+**手动部署**
 
 如果使用 OTG 作为虚拟 HID，可以使用如下部署命令：
 ```bash
@@ -27,29 +64,34 @@ sudo docker run --name kvmd -itd --privileged=true \
     silentwind0/kvmd
 ```
 
-如果使用 CH9329，可以使用如下部署命令：
+如果使用 CH9329 作为虚拟 HID，可以使用如下部署命令：
 ```bash
 sudo docker run --name kvmd -itd \
     --device /dev/video0:/dev/video0 \
     --device /dev/ttyUSB0:/dev/ttyUSB0 \
+    --device /dev/snd:/dev/snd \
     -p 8080:8080 -p 4430:4430 -p 5900:5900 -p 623:623 \
     silentwind0/kvmd
 ```
 
-部署完成访问 https://IP:4430 ,点击信任自签证书，即可开始使用，默认账号密码：admin/admin。
+**方式二：直刷 One-KVM 整合包**
 
-如无法访问可以使用 `sudo docker logs kvmd` 命令查看日志尝试修复、提交 issue 或在 QQ 群内寻求帮助。
+对于部分平台硬件，本项目制作了深度适配的 One-KVM 打包镜像，开箱即用，刷好后启动设备就可以开始使用 One-KVM。免费 One-KVM 整合包也可以在本项目 Releases 页可以找到。
 
-详细内容可以查阅 [One-KVM文档](https://one-kvm.mofeng.run/)。
+| 整合包适配概况 | | | |
+| :-------------: | :-------------: | :-------------: | :-------------: |
+| **固件型号** | **固件代号** | **硬件情况** | **最新版本** |
+| 玩客云 | Onecloud | USB 采集卡、OTG | 241018 |
+| 私家云二代 | Cumebox2 | USB 采集卡、OTG | 241004 |
+| Vmare | Vmare-uefi | USB 采集卡、CH9329 | 241004 |
+| Virtualbox | Virtualbox-uefi | USB 采集卡、CH9329 | 241004 |
+| s905l3a  通用包 | E900v22c | USB 采集卡、OTG | 241004 |
+| 我家云 | Chainedbox | USB 采集卡、OTG | 241004 |
+| 龙芯久久派 | 2k0300 | USB 采集卡、CH9329 | 241025 |
 
-**方式二：直刷 One-KVM 镜像**
+### 赞助方式
 
-对于玩客云设备，本项目 Releases 页可以找到适配玩客云的 One-KVM 预编译镜像。镜像名称带 One-KVM 前缀、burn 后缀的为线刷镜像，可使用 USB_Burning_Tool 软件线刷至玩客云。预编译线刷镜像为开箱即用，刷好后启动设备就可以开始使用 One-KVM。
-
-
-**赞助**
-
-这个项目基于众多开源项目二次开发，作者为此花费了大量的时间和精力进行测试和维护。若此项目对您有用，您可以考虑通过 [为爱发电](https://afdian.com/a/silentwind) 赞助一笔小钱支持作者。作者将能够购买新的硬件（玩客云和周边设备）来测试和维护 One-KVM 的各种配置，并在项目上投入更多的时间。
+这个项目基于众多开源项目二次开发，作者为此花费了大量的时间和精力进行测试和维护。若此项目对您有用，您可以考虑通过 **[为爱发电](https://afdian.com/a/silentwind)** 赞助一笔小钱支持作者。作者将能有更多的金钱来测试和维护 One-KVM 的各种配置，并在项目上投入更多的时间和精力。
 
 **感谢名单**
 
@@ -79,19 +121,29 @@ Will
 
 霜序
 
-[远方](https://runyf.cn/)
+[远方](https://runyf.cn/)（闲鱼用户名：小远技术店铺）
 
 爱发电用户_399fc
 
 [斐斐の](https://www.mmuaa.com/)
 
+爱发电用户_09451
+
+超高校级的錆鱼
+
+爱发电用户_08cff
+
+guoke
+
+mgt
+
 ......
 </details>
 
 本项目使用了下列开源项目：
 1. [pikvm/pikvm: Open and inexpensive DIY IP-KVM based on Raspberry Pi (github.com)](https://github.com/pikvm/pikvm)
 
-**状态**
+### 项目状态
 
 [![Star History Chart](https://api.star-history.com/svg?repos=mofeng-git/One-KVM&type=Date)](https://star-history.com/#mofeng-git/One-KVM&Date)
 

babel.cfg

@@ -1 +0,0 @@
-[python: kvmd/**.py]

build/Dockerfile

@@ -1,6 +1,6 @@
-FROM silentwind0/kvmd-stage-0 AS builder
+FROM registry.cn-hangzhou.aliyuncs.com/silentwind/kvmd-stage-0 AS builder
 
-FROM python:3.12.0rc2-slim-bookworm
+FROM python:3.11.11-slim-bookworm
 
 LABEL maintainer="mofeng654321@hotmail.com"
 
@@ -12,30 +12,61 @@ COPY --from=builder /usr/lib/janus/transports/* /usr/lib/janus/transports/
 
 ARG TARGETARCH
 
-ENV PYTHONDONTWRITEBYTECODE=1
-ENV PYTHONUNBUFFERED=1
-ENV TZ=Asia/Shanghai
-
-RUN cp /tmp/lib/* /lib/*-linux-*/ \
-    && pip install --no-cache-dir --root-user-action=ignore --disable-pip-version-check /tmp/wheel/*.whl \
-    && rm -rf /tmp/lib /tmp/wheel
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    TZ=Asia/Shanghai
 
 RUN sed -i 's/deb.debian.org/mirrors.tuna.tsinghua.edu.cn/' /etc/apt/sources.list.d/debian.sources \
     && apt-get update \
-    && apt-get install -y --no-install-recommends libxkbcommon-x11-0 nginx tesseract-ocr tesseract-ocr-eng tesseract-ocr-chi-sim iptables sudo  curl kmod \
-        libmicrohttpd12 libjansson4 libssl3 libsofia-sip-ua0 libglib2.0-0 libopus0 libogg0 libcurl4 libconfig9 libusrsctp2 libwebsockets17 libnss3 libasound2 \
-    && rm -rf /var/lib/apt/lists/*
-
-RUN if [ ${TARGETARCH} = arm ]; then ARCH=armhf; elif [ ${TARGETARCH} = arm64 ]; then ARCH=aarch64; elif [ ${TARGETARCH} = amd64 ]; then ARCH=x86_64; fi \
+    && apt-get install -y --no-install-recommends \
+        libxkbcommon-x11-0 \
+        nginx \
+        tesseract-ocr \
+        tesseract-ocr-eng \
+        tesseract-ocr-chi-sim \
+        iptables \
+        sudo \
+        curl \
+        kmod \
+        libmicrohttpd12 \
+        libjansson4 \
+        libssl3 \
+        libsofia-sip-ua0 \
+        libglib2.0-0 \
+        libopus0 \
+        libogg0 \
+        libcurl4 \
+        libconfig9 \
+        libusrsctp2 \
+        libwebsockets17 \
+        libnss3 \
+        libasound2 \
+        nano \
+    && cp /tmp/lib/* /lib/*-linux-*/ \
+    && pip install --no-cache-dir --root-user-action=ignore --disable-pip-version-check /tmp/wheel/*.whl \
+    && pip install --no-cache-dir --root-user-action=ignore --disable-pip-version-check pyfatfs \
+    && if [ ${TARGETARCH} = arm ]; then ARCH=armhf; \
+       elif [ ${TARGETARCH} = arm64 ]; then ARCH=aarch64; \
+       elif [ ${TARGETARCH} = amd64 ]; then ARCH=x86_64; \
+       fi \
     && curl https://github.com/tsl0922/ttyd/releases/download/1.7.7/ttyd.$ARCH -L -o /usr/local/bin/ttyd \
     && chmod +x /usr/local/bin/ttyd \
     && adduser kvmd --gecos "" --disabled-password \
     && ln -sf /usr/share/tesseract-ocr/*/tessdata /usr/share/tessdata \
-    && mkdir -p /etc/kvmd_backup/override.d /var/lib/kvmd/msd/images /var/lib/kvmd/msd/meta /var/lib/kvmd/pst/data /opt/vc/bin /run/kvmd /tmp/kvmd-nginx \
-    && touch /run/kvmd/ustreamer.sock
+    && mkdir -p /etc/kvmd_backup/override.d \
+               /var/lib/kvmd/msd/images \
+               /var/lib/kvmd/msd/meta \
+               /var/lib/kvmd/pst/data \
+               /var/lib/kvmd/msd/NormalFiles \
+               /opt/vc/bin \
+               /run/kvmd \
+               /tmp/kvmd-nginx \
+    && touch /run/kvmd/ustreamer.sock \
+	&& apt clean \
+    && rm -rf /var/lib/apt/lists/* \
+    && rm -rf /tmp/lib /tmp/wheel
 
-
-COPY testenv/fakes/vcgencmd /usr/bin/
+COPY testenv/fakes/vcgencmd scripts/kvmd* /usr/bin/
 COPY extras/ /usr/share/kvmd/extras/
 COPY web/ /usr/share/kvmd/web/
 COPY scripts/kvmd-gencert /usr/share/kvmd/

build/Dockerfile-stage-0

@@ -1,70 +1,119 @@
 # syntax = docker/dockerfile:experimental
-FROM python:3.12.0rc2-slim-bookworm AS builder
+FROM debian:bookworm-slim AS builder
 
 ARG TARGETARCH
 
+# 设置环境变量
+ENV DEBIAN_FRONTEND=noninteractive \
+    PIP_NO_CACHE_DIR=1 \
+    RUSTUP_DIST_SERVER="https://mirrors.tuna.tsinghua.edu.cn/rustup"
+
+# 更新源并安装依赖
 RUN sed -i 's/deb.debian.org/mirrors.tuna.tsinghua.edu.cn/' /etc/apt/sources.list.d/debian.sources \
     && apt-get update \
-    && apt-get install -y --no-install-recommends build-essential libssl-dev libffi-dev python3-dev libevent-dev libjpeg-dev \
-        libbsd-dev libudev-dev git pkg-config wget curl libmicrohttpd-dev libjansson-dev libssl-dev libsofia-sip-ua-dev libglib2.0-dev \
-        libopus-dev libogg-dev libcurl4-openssl-dev liblua5.3-dev libconfig-dev libopus-dev libtool automake autoconf meson cmake \
-        libx264-dev libyuv-dev libasound2-dev  libspeex-dev libspeexdsp-dev libopus-dev \
+    && apt-get install -y --no-install-recommends \
+        python3-full \
+        python3-pip \
+        python3-dev \
+        build-essential \
+        libssl-dev \
+        libffi-dev \
+        python3-dev \
+        libevent-dev \
+        libjpeg-dev \
+        libbsd-dev \
+        libudev-dev \
+        git \
+        pkg-config \
+        wget \
+        curl \
+        libmicrohttpd-dev \
+        libjansson-dev \
+        libsofia-sip-ua-dev \
+        libglib2.0-dev \
+        libopus-dev \
+        libogg-dev \
+        libcurl4-openssl-dev \
+        liblua5.3-dev \
+        libconfig-dev \
+        libtool \
+        automake \
+        autoconf \
+        meson \
+        cmake \
+        libx264-dev \
+        libyuv-dev \
+        libasound2-dev \
+        libspeex-dev \
+        libspeexdsp-dev \
+        libusb-1.0-0-dev \
+	&& apt clean \
     && rm -rf /var/lib/apt/lists/*
 
 COPY build/cargo_config /tmp/config
 
+# 配置 pip 源并安装 Python 依赖
 RUN --security=insecure pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple \
     && if [ ${TARGETARCH} = arm ]; then \
         mkdir -p /root/.cargo \
         && chmod 777 /root/.cargo && mount -t tmpfs none /root/.cargo \
-        && export RUSTUP_DIST_SERVER="https://mirrors.tuna.tsinghua.edu.cn/rustup" \
-        #&& export RUSTUP_UPDATE_ROOT="https://mirrors.ustc.edu.cn/rust-static/rustup" \
-        && wget  https://sh.rustup.rs -O /root/rustup-init.sh \
+        && wget https://sh.rustup.rs -O /root/rustup-init.sh \
         && sh /root/rustup-init.sh -y \
         && export PATH=$PATH:/root/.cargo/bin \
         && cp /tmp/config /root/.cargo/config.toml; \
     fi \
-    && pip wheel --wheel-dir=/tmp/wheel/ cryptography
-
-RUN pip install --no-cache-dir --root-user-action=ignore --disable-pip-version-check build \
-    && pip wheel --wheel-dir=/tmp/wheel/ aiofiles aiohttp appdirs asn1crypto async_lru async-timeout bottle cffi chardet click colorama \
-        dbus_next gpiod hidapi idna mako marshmallow more-itertools multidict netifaces packaging passlib pillow ply psutil pycparser \
-        pyelftools pyghmi pygments pyparsing pyotp qrcode requests semantic-version setproctitle setuptools six spidev  \
-        tabulate urllib3 wrapt xlib yarl pyserial pyyaml zstandard supervisor
+    && pip install --root-user-action=ignore --disable-pip-version-check --upgrade --break-system-packages build setuptools pip \
+    && pip wheel --wheel-dir=/tmp/wheel/ cryptography \
+    && pip wheel --wheel-dir=/tmp/wheel/ \
+        aiofiles aiohttp appdirs asn1crypto async_lru async-timeout bottle cffi \
+        chardet click colorama dbus_next gpiod hidapi idna mako marshmallow \
+        more-itertools multidict netifaces packaging passlib pillow ply psutil \
+        pycparser pyelftools pyghmi pygments pyparsing pyotp qrcode requests \
+        semantic-version setproctitle six spidev tabulate urllib3 wrapt xlib \
+        yarl pyserial pyyaml zstandard supervisor pyfatfs
 
+# 编译安装 libnice、libsrtp、libwebsockets 和 janus-gateway
 RUN git clone --depth=1 https://gitlab.freedesktop.org/libnice/libnice /tmp/libnice \
     && cd /tmp/libnice \
-    && meson --prefix=/usr build && ninja -C build && ninja -C build install
-
-RUN curl https://github.com/cisco/libsrtp/archive/v2.2.0.tar.gz -L -o /tmp/libsrtp-2.2.0.tar.gz \
+    && meson --prefix=/usr build && ninja -C build && ninja -C build install \
+    && rm -rf /tmp/libnice \
+    && curl https://github.com/cisco/libsrtp/archive/v2.2.0.tar.gz -L -o /tmp/libsrtp-2.2.0.tar.gz \
     && cd /tmp \
-    && tar xfv libsrtp-2.2.0.tar.gz \
+    && tar xf libsrtp-2.2.0.tar.gz \
     && cd libsrtp-2.2.0 \
     && ./configure --prefix=/usr --enable-openssl \
-    && make shared_library && make install
-
-RUN git clone --depth=1 https://libwebsockets.org/repo/libwebsockets /tmp/libwebsockets \
+    && make shared_library && make install \
+    && cd /tmp \
+    && rm -rf /tmp/libsrtp* \
+    && git clone --depth=1 https://libwebsockets.org/repo/libwebsockets /tmp/libwebsockets \
     && cd /tmp/libwebsockets \
     && mkdir build && cd build \
     && cmake -DLWS_MAX_SMP=1 -DLWS_WITHOUT_EXTENSIONS=0 -DCMAKE_INSTALL_PREFIX:PATH=/usr -DCMAKE_C_FLAGS="-fpic" .. \
-    && make && make install
-
-RUN git clone --depth=1 https://github.com/meetecho/janus-gateway.git /tmp/janus-gateway \
+    && make && make install \
+    && cd /tmp \
+    && rm -rf /tmp/libwebsockets \
+    && git clone --depth=1 https://github.com/meetecho/janus-gateway.git /tmp/janus-gateway \
     && cd /tmp/janus-gateway \
     && sh autogen.sh \
-    && ./configure --enable-static --enable-websockets  --enable-plugin-audiobridge \
-        --disable-data-channels --disable-rabbitmq --disable-mqtt --disable-all-plugins --disable-all-loggers \
-        --prefix=/usr \
-    && make && make install
+    && ./configure --enable-static --enable-websockets --enable-plugin-audiobridge \
+        --disable-data-channels --disable-rabbitmq --disable-mqtt --disable-all-plugins \
+        --disable-all-loggers --prefix=/usr \
+    && make && make install \
+    && cd /tmp \
+    && rm -rf /tmp/janus-gateway
 
+# 编译 ustreamer
 RUN sed --in-place --expression 's|^#include "refcount.h"$|#include "../refcount.h"|g' /usr/include/janus/plugins/plugin.h \
     && git clone --depth=1 https://github.com/mofeng-git/ustreamer /tmp/ustreamer \
+    && sed -i '68s/-Wl,-Bstatic//' /tmp/ustreamer/src/Makefile \
     && make -j WITH_PYTHON=1 WITH_JANUS=1 WITH_LIBX264=1 -C /tmp/ustreamer \
-    && /tmp/ustreamer/ustreamer -v
+    && /tmp/ustreamer/ustreamer -v \
+    && cp /tmp/ustreamer/python/dist/*.whl /tmp/wheel/
 
+# 复制必要的库文件
 RUN mkdir /tmp/lib \
     && cd /lib/*-linux-*/ \
-    && cp libevent_core-*.so.7 libbsd.so.0 libevent_pthreads-*.so.7 libspeexdsp.so.1 libevent-*.so.7 libjpeg.so.62 libx264.so.164 libyuv.so.0 \
-        libnice.so.10 /usr/lib/libsrtp2.so.1 /usr/lib/libwebsockets.so.19 \
-        /tmp/lib/ \
-    && cp /tmp/ustreamer/python/dist/*.whl /tmp/wheel/
+    && cp libevent_core-*.so.7 libbsd.so.0 libevent_pthreads-*.so.7 libspeexdsp.so.1 \
+       libevent-*.so.7 libjpeg.so.62 libx264.so.164 libyuv.so.0 libnice.so.10 \
+       /usr/lib/libsrtp2.so.1 /usr/lib/libwebsockets.so.19 \
+       /tmp/lib/

build/build_img.sh

@@ -1,129 +1,367 @@
 #!/bin/bash
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2023-2025  SilentWind <mofeng654321@hotmail.com>         #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
 
-#File List
-#src
-#└── image
-#    ├── cumebox2
-#    │   └── Armbian_24.8.1_Khadas-vim1_bookworm_current_6.6.47_minimal.img
-#    └── onecloud
-#        ├── AmlImg_v0.3.1_linux_amd64
-#        ├── Armbian_by-SilentWind_24.5.0-trunk_Onecloud_bookworm_legacy_5.9.0-rc7_minimal.burn.img
-#        └── rc.local
-
-#预处理镜像文件
-SRCPATH=../src
+SRCPATH=/mnt/nas/src
+BOOTFS=/tmp/bootfs
 ROOTFS=/tmp/rootfs
-$SRCPATH/image/onecloud/AmlImg_v0.3.1_linux_amd64 unpack $SRCPATH/image/onecloud/Armbian_by-SilentWind_24.5.0-trunk_Onecloud_bookworm_legacy_5.9.0-rc7_minimal.burn.img $SRCPATH/tmp
-simg2img $SRCPATH/tmp/7.rootfs.PARTITION.sparse $SRCPATH/tmp/rootfs.img
-dd if=/dev/zero of=/tmp/add.img bs=1M count=800 && cat /tmp/add.img >> $SRCPATH/tmp/rootfs.img && rm /tmp/add.img
-e2fsck -f $SRCPATH/tmp/rootfs.img && resize2fs $SRCPATH/tmp/rootfs.img
+OUTPUTDIR=/mnt/nas/src/output
+LOOPDEV=/dev/loop10
+DATE=240303
+export LC_ALL=C
 
-#挂载镜像文件
-mkdir $ROOTFS
-sudo mount $SRCPATH/tmp/rootfs.img $ROOTFS || exit -1
-sudo mount -t proc proc $ROOTFS/proc || exit -1
-sudo mount -t sysfs sys $ROOTFS/sys || exit -1
-sudo mount -o bind /dev $ROOTFS/dev || exit -1
+write_meta() {
+    sudo chroot --userspec "root:root" $ROOTFS bash -c "sed -i 's/localhost.localdomain/$1/g' /etc/kvmd/meta.yaml"
+}
 
-#准备文件
-sudo mkdir -p $ROOTFS/etc/kvmd/override.d $ROOTFS/etc/kvmd/vnc $ROOTFS/var/lib/kvmd/msd $ROOTFS/opt/vc/bin $ROOTFS/usr/share/kvmd \
-    $ROOTFS/usr/share/janus/javascript $ROOTFS/usr/lib/ustreamer/janus $ROOTFS/run/kvmd $ROOTFS/var/lib/kvmd/msd/images $ROOTFS/var/lib/kvmd/msd/meta
-sudo cp -r ../One-KVM $ROOTFS/
-sudo cp $SRCPATH/image/onecloud/rc.local $ROOTFS/etc/
-sudo cp -r $ROOTFS/One-KVM/configs/kvmd/* $ROOTFS/One-KVM/configs/nginx $ROOTFS/One-KVM/configs/janus \
-    $ROOTFS/etc/kvmd
-sudo cp -r $ROOTFS/One-KVM/web $ROOTFS/One-KVM/extras $ROOTFS/One-KVM/contrib/keymaps $ROOTFS/usr/share/kvmd
-sudo cp $ROOTFS/One-KVM/build/platform/onecloud $ROOTFS/usr/share/kvmd/platform
-sudo cp $ROOTFS/One-KVM/testenv/fakes/vcgencmd $ROOTFS/usr/bin/
-sudo cp -r $ROOTFS/One-KVM/testenv/js/* $ROOTFS/usr/share/janus/javascript/
+mount_rootfs() {
+    mkdir $ROOTFS $SRCPATH/tmp/rootfs
+    sudo mount $LOOPDEV  $ROOTFS || exit -1
+    sudo mount -t proc proc $ROOTFS/proc || exit -1
+    sudo mount -t sysfs sys $ROOTFS/sys || exit -1
+    sudo mount -o bind /dev $ROOTFS/dev || exit -1
+}
 
-#安装依赖
-sudo chroot --userspec "root:root" $ROOTFS bash -c " \
-    apt update \
-    && apt install -y python3-aiofiles python3-aiohttp python3-appdirs python3-asn1crypto python3-async-timeout \
-        python3-bottle python3-cffi python3-chardet python3-click python3-colorama python3-cryptography python3-dateutil \
-        python3-dbus python3-dev python3-hidapi python3-idna python3-libgpiod python3-mako python3-marshmallow python3-more-itertools \
-        python3-multidict python3-netifaces python3-packaging python3-passlib python3-pillow python3-ply python3-psutil \
-        python3-pycparser python3-pyelftools python3-pyghmi python3-pygments python3-pyparsing python3-requests \
-        python3-semantic-version python3-setproctitle python3-setuptools python3-six python3-spidev python3-systemd \
-        python3-tabulate python3-urllib3 python3-wrapt python3-xlib python3-yaml python3-yarl python3-pyotp python3-qrcode \
-        python3-serial python3-zstandard python3-dbus-next \
-    && apt install -y nginx python3-pip python3-dev python3-build net-tools tesseract-ocr tesseract-ocr-eng tesseract-ocr-chi-sim \
-        git gpiod libxkbcommon0 build-essential janus-dev libssl-dev libffi-dev libevent-dev libjpeg-dev libbsd-dev libudev-dev \
-        pkg-config libx264-dev libyuv-dev libasound2-dev libsndfile-dev libspeexdsp-dev cpufrequtils iptables\
-    && apt clean "
+umount_rootfs() {
+    sudo umount  $ROOTFS/sys
+    sudo umount  $ROOTFS/dev
+    sudo umount  $ROOTFS/proc
+    sudo umount $ROOTFS
+	sudo zerofree $LOOPDEV
+    sudo losetup -d $LOOPDEV
+	sudo docker rm to_build_rootfs
+	sudo rm -rf $SRCPATH/tmp/rootfs/*
+}
 
-sudo chroot --userspec "root:root" $ROOTFS bash -c " \
-    pip3 config set global.index-url https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple \
-    && pip3 install --target=/usr/lib/python3/dist-packages --break-system-packages async-lru gpiod \
-    && pip3 cache purge "
+parpare_dns() {
+    sudo chroot --userspec "root:root" $ROOTFS bash -c " \
+    mkdir -p /run/systemd/resolve/ \
+    && touch /run/systemd/resolve/stub-resolv.conf \
+    && printf '%s\n' 'nameserver 1.1.1.1' 'nameserver 1.0.0.1' > /etc/resolv.conf \
+    && bash <(curl -sSL https://gitee.com/SuperManito/LinuxMirrors/raw/main/ChangeMirrors.sh) \
+        --source mirrors.tuna.tsinghua.edu.cn --updata-software false --web-protocol http "
+}
 
-sudo chroot --userspec "root:root" $ROOTFS sed --in-place --expression 's|^#include "refcount.h"$|#include "../refcount.h"|g' /usr/include/janus/plugins/plugin.h
+delete_armbain_verify(){
+    sudo chroot --userspec "root:root" $ROOTFS bash -c "echo 'deb  http://mirrors.ustc.edu.cn/armbian bullseye main bullseye-utils bullseye-desktop' > /etc/apt/sources.list.d/armbian.list "
+}
 
-sudo chroot --userspec "root:root" $ROOTFS bash -c " \
-    git clone --depth=1 https://github.com/mofeng-git/ustreamer /tmp/ustreamer \
-    && make -j WITH_PYTHON=1 WITH_JANUS=1 WITH_LIBX264=1 -C /tmp/ustreamer \
-    && mv /tmp/ustreamer/src/ustreamer.bin /usr/bin/ustreamer \
-    && mv /tmp/ustreamer/src/ustreamer-dump.bin /usr/bin/ustreamer-dump \
-    && chmod +x /usr/bin/ustreamer /usr/bin/ustreamer-dump \
-    && mv /tmp/ustreamer/janus/libjanus_ustreamer.so /usr/lib/ustreamer/janus \
-    && pip3 install --target=/usr/lib/python3/dist-packages --break-system-packages /tmp/ustreamer/python/dist/*.whl "
+config_file() {
+	
+    sudo mkdir -p $ROOTFS/etc/kvmd/override.d $ROOTFS/etc/kvmd/vnc $ROOTFS/var/lib/kvmd/msd $ROOTFS/opt/vc/bin $ROOTFS/usr/share/kvmd $ROOTFS/One-KVM \
+        $ROOTFS/usr/share/janus/javascript $ROOTFS/usr/lib/ustreamer/janus $ROOTFS/run/kvmd $ROOTFS/var/lib/kvmd/msd/images $ROOTFS/var/lib/kvmd/msd/meta \
+		$ROOTFS/tmp/wheel/ $ROOTFS/usr/lib/janus/transports/  $ROOTFS/usr/lib/janus/loggers
+    sudo rsync -a  --exclude={src,.github} . $ROOTFS/One-KVM
+    sudo cp -r configs/kvmd/* configs/nginx configs/janus $ROOTFS/etc/kvmd
+    sudo cp -r web extras contrib/keymaps $ROOTFS/usr/share/kvmd
+    sudo cp testenv/fakes/vcgencmd $ROOTFS/usr/bin/
+    sudo cp -r testenv/js/* $ROOTFS/usr/share/janus/javascript/
+    sudo cp build/platform/$1 $ROOTFS/usr/share/kvmd/platform
+    if [ -f "$SRCPATH/image/$1/rc.local" ]; then
+        sudo cp $SRCPATH/image/$1/rc.local $ROOTFS/etc/
+    fi
 
-#安装 kvmd 主程序
-sudo chroot --userspec "root:root" $ROOTFS bash -c " \
-    cd /One-KVM \
-    && python3 setup.py install \
-    && bash scripts/kvmd-gencert --do-the-thing \
-    && bash scripts/kvmd-gencert --do-the-thing --vnc \
-    && kvmd-nginx-mkconf /etc/kvmd/nginx/nginx.conf.mako /etc/kvmd/nginx/nginx.conf \
-    && kvmd -m "
+	sudo docker pull --platform linux/$2 registry.cn-hangzhou.aliyuncs.com/silentwind/kvmd-stage-0
+	sudo docker create --name to_build_rootfs registry.cn-hangzhou.aliyuncs.com/silentwind/kvmd-stage-0
+	sudo docker export to_build_rootfs  | sudo tar -xvf - -C $SRCPATH/tmp/rootfs
+	sudo cp $SRCPATH/tmp/rootfs/tmp/lib/*  $ROOTFS/lib/*-linux-*/
+	sudo cp $SRCPATH/tmp/rootfs/tmp/ustreamer/ustreamer $SRCPATH/tmp/rootfs/tmp/ustreamer/ustreamer-dump $SRCPATH/tmp/rootfs/usr/bin/janus $ROOTFS/usr/bin/
+	sudo cp $SRCPATH/tmp/rootfs/tmp/ustreamer/janus/libjanus_ustreamer.so $ROOTFS/usr/lib/ustreamer/janus/
+	sudo cp $SRCPATH/tmp/rootfs/tmp/wheel/*.whl $ROOTFS/tmp/wheel/
+	sudo cp $SRCPATH/tmp/rootfs/usr/lib/janus/transports/* $ROOTFS/usr/lib/janus/transports/
 
-sudo chroot --userspec "root:root" $ROOTFS bash -c " \
-    curl https://github.com/tsl0922/ttyd/releases/download/1.7.7/ttyd.armhf -L -o /usr/bin/ttyd \
-    && chmod +x /usr/bin/ttyd \
-    && systemd-sysusers /One-KVM/configs/os/kvmd-webterm.conf \
-    &&  mkdir -p /home/kvmd-webterm \
-    && chown kvmd-webterm /home/kvmd-webterm "
+	sudo mv $ROOTFS/etc/apt/apt.conf.d/50apt-file.conf{,.disabled}
+}
+
+pack_img() {
+    sudo mv $SRCPATH/tmp/rootfs.img  $OUTPUTDIR/One-KVM_by-SilentWind_$1_$DATE.img
+    if [ "$1" = "Vm" ]; then
+        sudo qemu-img convert -f raw -O vmdk $OUTPUTDIR/One-KVM_by-SilentWind_Vm_$DATE.img $OUTPUTDIR/One-KVM_by-SilentWind_Vmare-uefi_$DATE.vmdk
+        sudo qemu-img convert -f raw -O vdi $OUTPUTDIR/One-KVM_by-SilentWind_Vm_$DATE.img $OUTPUTDIR/One-KVM_by-SilentWind_Virtualbox-uefi_$DATE.vdi
+    fi
+}
+
+onecloud_rootfs() {
+    $SRCPATH/image/onecloud/AmlImg_v0.3.1_linux_amd64 unpack $SRCPATH/image/onecloud/Armbian_by-SilentWind_24.5.0-trunk_Onecloud_bookworm_legacy_5.9.0-rc7_minimal.burn.img $SRCPATH/tmp
+    simg2img $SRCPATH/tmp/6.boot.PARTITION.sparse $SRCPATH/tmp/bootfs.img
+    simg2img $SRCPATH/tmp/7.rootfs.PARTITION.sparse $SRCPATH/tmp/rootfs.img
+    mkdir $BOOTFS
+    sudo losetup $LOOPDEV $SRCPATH/tmp/bootfs.img  || exit -1
+    sudo mount $LOOPDEV $BOOTFS
+    sudo cp $SRCPATH/image/onecloud/meson8b-onecloud-fix.dtb $BOOTFS/dtb/meson8b-onecloud.dtb
+    sudo umount $BOOTFS
+    sudo losetup -d $LOOPDEV
+    dd if=/dev/zero of=/tmp/add.img bs=1M count=256 && cat /tmp/add.img >> $SRCPATH/tmp/rootfs.img && rm /tmp/add.img
+    e2fsck -f $SRCPATH/tmp/rootfs.img && resize2fs $SRCPATH/tmp/rootfs.img
+    sudo losetup $LOOPDEV $SRCPATH/tmp/rootfs.img
+}
+
+cumebox2_rootfs() {
+    cp $SRCPATH/image/cumebox2/Armbian_24.8.1_Khadas-vim1_bookworm_current_6.6.47_minimal.img $SRCPATH/tmp/rootfs.img
+    dd if=/dev/zero of=/tmp/add.img bs=1M count=1500 && cat /tmp/add.img >> $SRCPATH/tmp/rootfs.img && rm /tmp/add.img
+    sudo parted -s $SRCPATH/tmp/rootfs.img resizepart 1 100% || exit -1
+    sudo losetup --offset $((8192*512)) $LOOPDEV $SRCPATH/tmp/rootfs.img  || exit -1
+    sudo e2fsck -f $LOOPDEV && sudo resize2fs $LOOPDEV
+}
+
+chainedbox_rootfs_and_fix_dtb() {
+    cp $SRCPATH/image/chainedbox/Armbian_24.11.0_rockchip_chainedbox_bookworm_6.1.112_server_2024.10.02_add800m.img $SRCPATH/tmp/rootfs.img
+    mkdir $BOOTFS
+    sudo losetup --offset $((32768*512)) $LOOPDEV $SRCPATH/tmp/rootfs.img  || exit -1
+    sudo mount $LOOPDEV $BOOTFS
+    sudo cp $SRCPATH/image/chainedbox/rk3328-l1pro-1296mhz-fix.dtb $BOOTFS/dtb/rockchip/rk3328-l1pro-1296mhz.dtb
+    sudo umount $BOOTFS
+    sudo losetup -d $LOOPDEV
+    sudo losetup --offset $((1081344*512)) $LOOPDEV $SRCPATH/tmp/rootfs.img
+}
+
+vm_rootfs() {
+    cp $SRCPATH/image/vm/Armbian_24.8.1_Uefi-x86_bookworm_current_6.6.47_minimal_add1g.img $SRCPATH/tmp/rootfs.img
+    sudo losetup --offset $((540672*512)) $LOOPDEV $SRCPATH/tmp/rootfs.img  || exit -1
+}
+
+e900v22c_rootfs() {
+    cp $SRCPATH/image/e900v22c/Armbian_23.08.0_amlogic_s905l3a_bookworm_5.15.123_server_2023.08.01.img $SRCPATH/tmp/rootfs.img
+    dd if=/dev/zero of=/tmp/add.img bs=1M count=400 && cat /tmp/add.img >> $SRCPATH/tmp/rootfs.img && rm /tmp/add.img
+    sudo parted -s $SRCPATH/tmp/rootfs.img resizepart 2 100% || exit -1
+    sudo losetup --offset $((532480*512)) $LOOPDEV $SRCPATH/tmp/rootfs.img  || exit -1
+    sudo e2fsck -f $LOOPDEV && sudo resize2fs $LOOPDEV
+}
 
 
-#服务自启
-sudo chroot --userspec "root:root" $ROOTFS bash -c " \
-    cat /One-KVM/configs/os/sudoers/v2-hdmiusb >> /etc/sudoers \
-    && cat /One-KVM/configs/os/udev/v2-hdmiusb-generic.rules > /etc/udev/rules.d/99-kvmd.rules \
-    && echo 'libcomposite' >> /etc/modules \
-    && mv /usr/local/bin/kvmd* /usr/bin \
-    && cp /One-KVM/configs/os/services/* /etc/systemd/system/ \
-    && cp /One-KVM/configs/os/tmpfiles.conf /usr/lib/tmpfiles.d/ \
-    && chmod +x /etc/update-motd.d/* \
-    && echo 'kvmd ALL=(ALL) NOPASSWD: /etc/kvmd/custom_atx/gpio.sh' >>  /etc/sudoers \
-    && echo 'kvmd ALL=(ALL) NOPASSWD: /etc/kvmd/custom_atx/usbrelay_hid.sh' >>  /etc/sudoers \
-    && systemd-sysusers /One-KVM/configs/os/sysusers.conf \
-    && ln -sf /usr/share/tesseract-ocr/*/tessdata /usr/share/tessdata \
-    && sed -i 's/ch9329/otg/g' /etc/kvmd/override.yaml \
-    && sed -i 's/device: \/dev\/ttyUSB0//g' /etc/kvmd/override.yaml \
-    && sed -i 's/8080/80/g' /etc/kvmd/override.yaml \
-    && sed -i 's/4430/443/g' /etc/kvmd/override.yaml \
-    && sed -i 's/#type: otg/type: otg/g' /etc/kvmd/override.yaml \
-    && chown kvmd -R /var/lib/kvmd/msd/ \
-	&& sed -i 's/localhost.localdomain/onecloud/g' /etc/kvmd/meta.yaml \
-    && systemctl enable kvmd kvmd-otg kvmd-nginx kvmd-vnc kvmd-ipmi kvmd-webterm kvmd-janus \
-    && systemctl disable nginx janus \
-    && rm -r /One-KVM "
+octopus-flanet_rootfs() {
+    cp $SRCPATH/image/octopus-flanet/Armbian_24.11.0_amlogic_s912_bookworm_6.1.114_server_2024.11.01.img $SRCPATH/tmp/rootfs.img
+    mkdir $BOOTFS
+    sudo losetup --offset $((8192*512)) $LOOPDEV $SRCPATH/tmp/rootfs.img  || exit -1
+    sudo mount $LOOPDEV $BOOTFS
+    sudo sed -i "s/meson-gxm-octopus-planet.dtb/meson-gxm-khadas-vim2.dtb/g" $BOOTFS/uEnv.txt
+    sudo umount $BOOTFS
+    sudo losetup -d $LOOPDEV
+    dd if=/dev/zero of=/tmp/add.img bs=1M count=400 && cat /tmp/add.img >> $SRCPATH/tmp/rootfs.img && rm /tmp/add.img
+    sudo parted -s $SRCPATH/tmp/rootfs.img resizepart 2 100% || exit -1
+    sudo losetup --offset $((1056768*512)) $LOOPDEV $SRCPATH/tmp/rootfs.img  || exit -1
+    sudo e2fsck -f $LOOPDEV && sudo resize2fs $LOOPDEV
+}
 
 
-sudo chroot --userspec "root:root" $ROOTFS bash -c " \
-    sed -i '2c ATX=GPIO' /etc/kvmd/atx.sh \
-    && sed -i 's/SHUTDOWNPIN/gpiochip1 7/g' /etc/kvmd/custom_atx/gpio.sh \
-    && sed -i 's/REBOOTPIN/gpiochip0 11/g' /etc/kvmd/custom_atx/gpio.sh "
+config_cumebox2_file() {
+    sudo mkdir $ROOTFS/etc/oled
+    sudo cp $SRCPATH/image/cumebox2/v-fix.dtb $ROOTFS/boot/dtb/amlogic/meson-gxl-s905x-khadas-vim.dtb
+    sudo cp $SRCPATH/image/cumebox2/ssd $ROOTFS/usr/bin/
+    sudo cp $SRCPATH/image/cumebox2/config.json $ROOTFS/etc/oled/config.json
+}
 
-#卸载镜像
-sudo umount  $ROOTFS/sys
-sudo umount  $ROOTFS/dev
-sudo umount  $ROOTFS/proc
-sudo umount $ROOTFS
+config_octopus-flanet_file() {
+    sudo cp $SRCPATH/image/octopus-flanet/model_database.conf $ROOTFS/etc/model_database.conf
+}
 
-#打包镜像
-sudo rm $SRCPATH/tmp/7.rootfs.PARTITION.sparse
-sudo img2simg $SRCPATH/tmp/rootfs.img $SRCPATH/tmp/7.rootfs.PARTITION.sparse
-sudo $SRCPATH/image/onecloud/AmlImg_v0.3.1_linux_amd64 pack  $SRCPATH/output/One-KVM_by-SilentWind_Onecloud_241004.burn.img $SRCPATH/tmp/
-sudo rm $SRCPATH/tmp/*
+instal_one-kvm() {
+    #$1 arch; $2 deivce: "gpio" or "video1"; $3 network: "systemd-networkd",default is network-manager
+    sudo chroot --userspec "root:root" $ROOTFS bash -c " \
+        df -h \
+        && apt-get update \
+        && apt install -y --no-install-recommends libxkbcommon-x11-0 nginx tesseract-ocr tesseract-ocr-eng tesseract-ocr-chi-sim iptables \
+        	curl kmod libmicrohttpd12 libjansson4 libssl3 libsofia-sip-ua0 libglib2.0-0 libopus0 libogg0 libcurl4 libconfig9 python3-pip \
+        && apt clean \
+		&& rm -rf /var/lib/apt/lists/* "
+
+    if [ "$3" = "systemd-networkd" ]; then 
+        sudo chroot --userspec "root:root" $ROOTFS bash -c " \
+            echo -e '[Match]\nName=eth0\n\n[Network]\nDHCP=yes\n\n[Link]\nMACAddress=B6:AE:B3:21:42:0C' > /etc/systemd/network/99-eth0.network \
+            && systemctl mask NetworkManager \
+            && systemctl unmask systemd-networkd \
+            && systemctl enable systemd-networkd systemd-resolved "        
+    fi
+    sudo chroot --userspec "root:root" $ROOTFS bash -c " \
+        pip3 install --no-cache-dir --break-system-packages /tmp/wheel/*.whl \
+        && pip3 cache purge \
+		&& rm -r /tmp/wheel "
+
+#pip3 install --target=/usr/lib/python3/dist-packages --break-system-packages pyfatfs -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
+
+    sudo chroot --userspec "root:root" $ROOTFS bash -c " \
+        cd /One-KVM \
+        && python3 setup.py install \
+        && bash scripts/kvmd-gencert --do-the-thing \
+        && bash scripts/kvmd-gencert --do-the-thing --vnc \
+        && kvmd-nginx-mkconf /etc/kvmd/nginx/nginx.conf.mako /etc/kvmd/nginx/nginx.conf \
+        && kvmd -m "
+
+    sudo chroot --userspec "root:root" $ROOTFS bash -c " \
+        cat /One-KVM/configs/os/sudoers/v2-hdmiusb >> /etc/sudoers \
+        && cat /One-KVM/configs/os/udev/v2-hdmiusb-rpi4.rules > /etc/udev/rules.d/99-kvmd.rules \
+        && echo 'libcomposite' >> /etc/modules \
+        && mv /usr/local/bin/kvmd* /usr/bin \
+        && cp /One-KVM/configs/os/services/* /etc/systemd/system/ \
+        && cp /One-KVM/configs/os/tmpfiles.conf /usr/lib/tmpfiles.d/ \
+        && chmod +x /etc/update-motd.d/* \
+        && echo 'kvmd ALL=(ALL) NOPASSWD: /etc/kvmd/custom_atx/gpio.sh' >>  /etc/sudoers \
+        && echo 'kvmd ALL=(ALL) NOPASSWD: /etc/kvmd/custom_atx/usbrelay_hid.sh' >>  /etc/sudoers \
+        && systemd-sysusers /One-KVM/configs/os/sysusers.conf \
+        && systemd-sysusers /One-KVM/configs/os/kvmd-webterm.conf \
+        && ln -sf /usr/share/tesseract-ocr/*/tessdata /usr/share/tessdata \
+        && sed -i 's/8080/80/g' /etc/kvmd/override.yaml \
+        && sed -i 's/4430/443/g' /etc/kvmd/override.yaml \
+        && chown kvmd -R /var/lib/kvmd/msd/ \
+        && systemctl enable kvmd kvmd-otg kvmd-nginx kvmd-vnc kvmd-ipmi kvmd-webterm kvmd-janus kvmd-media \
+        && systemctl disable nginx \
+        && rm -r /One-KVM "
+
+    sudo chroot --userspec "root:root" $ROOTFS bash -c " \
+        curl https://gh.llkk.cc/https://github.com/tsl0922/ttyd/releases/download/1.7.7/ttyd.$1 -L -o /usr/bin/ttyd \
+        && chmod +x /usr/bin/ttyd \
+        && mkdir -p /home/kvmd-webterm \
+        && chown kvmd-webterm /home/kvmd-webterm "
+
+    if [ "$1" = "x86_64" ]; then
+        sudo chroot --userspec "root:root" $ROOTFS bash -c " \
+            systemctl disable kvmd-otg \
+            && sed -i '2c ATX=USBRELAY_HID' /etc/kvmd/atx.sh \
+            && sed -i 's/device: \/dev\/ttyUSB0/device: \/dev\/kvmd-hid/g' /etc/kvmd/override.yaml "
+    else
+        if [ "$2" = "gpio" ]; then
+            sudo chroot --userspec "root:root" $ROOTFS bash -c " \
+                sed -i '2c ATX=GPIO' /etc/kvmd/atx.sh \
+                && sed -i 's/SHUTDOWNPIN/gpiochip1 7/g' /etc/kvmd/custom_atx/gpio.sh \
+                && sed -i 's/REBOOTPIN/gpiochip0 11/g' /etc/kvmd/custom_atx/gpio.sh "
+        else
+            sudo chroot --userspec "root:root" $ROOTFS sed -i '2c ATX=USBRELAY_HID' /etc/kvmd/atx.sh
+            
+        fi
+        if [ "$2" = "video1" ]; then
+            sudo chroot --userspec "root:root" $ROOTFS sed -i 's/\/dev\/video0/\/dev\/video1/g' /etc/kvmd/override.yaml
+        fi
+        sudo chroot --userspec "root:root" $ROOTFS bash -c " \
+            sed -i 's/ch9329/otg/g' /etc/kvmd/override.yaml \
+            && sed -i 's/device: \/dev\/ttyUSB0//g' /etc/kvmd/override.yaml \
+            && sed -i 's/#type: otg/type: otg/g' /etc/kvmd/override.yaml "
+    fi
+
+	sudo chroot --userspec "root:root" $ROOTFS bash -c "df -h"
+}
+
+pack_img_onecloud() {
+    sudo rm $SRCPATH/tmp/7.rootfs.PARTITION.sparse
+    sudo img2simg $SRCPATH/tmp/rootfs.img $SRCPATH/tmp/7.rootfs.PARTITION.sparse
+    sudo $SRCPATH/image/onecloud/AmlImg_v0.3.1_linux_amd64 pack $OUTPUTDIR/One-KVM_by-SilentWind_Onecloud_$DATE.burn.img $SRCPATH/tmp/
+    sudo rm $SRCPATH/tmp/*
+}
+
+#build function
+
+onecloud() {
+    onecloud_rootfs
+    mount_rootfs
+    config_file "onecloud" "arm"
+    instal_one-kvm armhf gpio systemd-networkd
+    write_meta "onecloud"
+    umount_rootfs
+    pack_img_onecloud
+}
+
+cumebox2() {
+    cumebox2_rootfs
+    mount_rootfs
+    config_file "cumebox2" "aarch64"
+    config_cumebox2_file
+    parpare_dns
+    instal_one-kvm aarch64 video1
+    write_meta "cumebox2"
+    umount_rootfs
+    pack_img "Cumebox2"
+}
+
+chainedbox() {
+    chainedbox_rootfs_and_fix_dtb
+    mount_rootfs
+    config_file "chainedbox" "aarch64"
+    parpare_dns
+    instal_one-kvm aarch64 video1
+    write_meta "chainedbox"
+    umount_rootfs
+    pack_img "Chainedbox"
+}
+
+vm() {
+    vm_rootfs
+    mount_rootfs
+    config_file "vm" "amd64"
+    parpare_dns
+    instal_one-kvm x86_64
+    write_meta "vm"
+    umount_rootfs
+    pack_img "Vm"
+}
+
+e900v22c() {
+    e900v22c_rootfs
+    mount_rootfs
+    config_file "e900v22c" "aarch64"
+    instal_one-kvm aarch64 video1
+    write_meta "e900v22c"
+    umount_rootfs
+    pack_img "E900v22c"
+}
+
+octopus_flanet() {
+    octopus-flanet_rootfs
+    mount_rootfs
+    config_file "octopus-flanet" "aarch64"
+    config_octopus-flanet_file
+    parpare_dns
+    instal_one-kvm aarch64 video1
+    write_meta "octopus-flanet"
+    umount_rootfs
+    pack_img "Octopus-Flanet"
+}
+
+if [ "$1" = "all" ]; then
+    onecloud
+    cumebox2
+    chainedbox
+    vm
+    e900v22c
+    octopus_flanet
+else
+    case $1 in  
+        onecloud)  
+            onecloud
+            ;;
+        cumebox2)  
+            cumebox2
+            ;;
+        chainedbox) 
+            chainedbox
+            ;;
+        vm)  
+            vm
+            ;;
+        e900v22c)  
+            e900v22c
+            ;;
+        octopus-flanet)  
+            octopus_flanet
+            ;;
+        *)  
+            echo "Do no thing." 
+            ;;
+    esac
+fi

build/init.sh

@@ -1,41 +1,112 @@
 #!/bin/bash
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2023-2025  SilentWind <mofeng654321@hotmail.com>         #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
 
+# 定义颜色代码
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[0;33m'
 BLUE='\033[0;34m'
 NC='\033[0m'
 
-echo -e "${GREEN}One-KVM pre-starting...${NC}"
+# 输出日志的函数
+log_info() {
+    echo -e "${GREEN}[INFO] $1${NC}"
+}
 
+log_warn() {
+    echo -e "${YELLOW}[WARN] $1${NC}"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR] $1${NC}"
+}
+
+# 初始化检查
+log_info "One-KVM 正在启动..."
+
+# 首次初始化配置
 if [ ! -f /etc/kvmd/.init_flag ]; then
-    echo -e "${GREEN}One-KVM is initializing first...${NC}" \
-        && mkdir -p /etc/kvmd/ \
-        && mv /etc/kvmd_backup/* /etc/kvmd/ \
-        && touch /etc/kvmd/.docker_flag \
-        && sed -i 's/localhost.localdomain/docker/g' /etc/kvmd/meta.yaml \
-        && sed -i 's/localhost/localhost:4430/g' /etc/kvmd/kvm_input.sh \
-        && /usr/share/kvmd/kvmd-gencert --do-the-thing \
-        && /usr/share/kvmd/kvmd-gencert --do-the-thing --vnc \
-        || echo -e "${RED}One-KVM config moving and self-signed SSL certificates init failed.${NC}"
-   
-    if [ "$NOSSL" == 1 ]; then
-        echo -e "${GREEN}One-KVM self-signed SSL is disabled.${NC}" \
-        && python -m kvmd.apps.ngxmkconf /etc/kvmd/nginx/nginx.conf.mako /etc/kvmd/nginx/nginx.conf  -o nginx/https/enabled=false \
-        || echo -e "${RED}One-KVM nginx config init failed.${NC}"
+    log_info "首次初始化配置..."
+    
+    # 创建必要目录并移动配置文件
+    if mkdir -p /etc/kvmd/ && \
+       mv /etc/kvmd_backup/* /etc/kvmd/ && \
+       touch /etc/kvmd/.docker_flag && \
+       sed -i 's/localhost.localdomain/docker/g' /etc/kvmd/meta.yaml && \
+       sed -i 's/localhost/localhost:4430/g' /etc/kvmd/kvm_input.sh; then
+        log_info "移动配置文件完成"
     else
-        python -m kvmd.apps.ngxmkconf /etc/kvmd/nginx/nginx.conf.mako /etc/kvmd/nginx/nginx.conf \
-        || echo -e "${RED}One-KVM nginx config init failed.${NC}"
+        log_error "移动配置文件失败"
+        exit 1
     fi
-   
+
+    # SSL证书配置
+    if ! /usr/share/kvmd/kvmd-gencert --do-the-thing; then
+        log_error "Nginx SSL 证书生成失败"
+        exit 1
+    fi
+    if ! /usr/share/kvmd/kvmd-gencert --do-the-thing --vnc; then
+        log_error "VNC SSL 证书生成失败"
+        exit 1
+    fi
+
+    # 设置用户名和密码
+    if [ ! -z "$USERNAME" ] && [ ! -z "$PASSWORD" ]; then
+        if python -m kvmd.apps.htpasswd del admin \
+            && echo "$PASSWORD" | python -m kvmd.apps.htpasswd set -i "$USERNAME" \
+            && echo "$PASSWORD -> $USERNAME:$PASSWORD" > /etc/kvmd/vncpasswd \
+            && echo "$USERNAME:$PASSWORD -> $USERNAME:$PASSWORD" > /etc/kvmd/ipmipasswd; then
+            log_info "用户凭据设置成功"
+        else
+            log_error "用户凭据设置失败"
+            exit 1
+        fi
+    else
+        log_warn "未设置 USERNAME 和 PASSWORD 环境变量，使用默认值(admin/admin)"
+    fi
+
+    # SSL开关配置
+    if [ "$NOSSL" == 1 ]; then
+        log_info "已禁用SSL"
+        if ! python -m kvmd.apps.ngxmkconf /etc/kvmd/nginx/nginx.conf.mako /etc/kvmd/nginx/nginx.conf -o nginx/https/enabled=false; then
+            log_error "Nginx 配置失败"
+            exit 1
+        fi
+    else
+        if ! python -m kvmd.apps.ngxmkconf /etc/kvmd/nginx/nginx.conf.mako /etc/kvmd/nginx/nginx.conf; then
+            log_error "Nginx 配置失败"
+            exit 1
+        fi
+    fi
+
+    # 认证配置
     if [ "$NOAUTH" == "1" ]; then
-        sed -i "s/enabled: true/enabled: false/g" /etc/kvmd/override.yaml \
-        && echo -e "${GREEN}One-KVM auth is disabled.${NC}"
+        sed -i "s/enabled: true/enabled: false/g" /etc/kvmd/override.yaml
+        log_info "已禁用认证"
     fi
 
     #add supervisord conf
     if [ "$NOWEBTERM" == "1" ]; then
-        echo -e "${GREEN}One-KVM webterm is disabled.${NC}"
+        log_info "已禁用 WebTerm 功能"
         rm -r /usr/share/kvmd/extras/webterm
     else
         cat >> /etc/kvmd/supervisord.conf  << EOF
@@ -58,7 +129,7 @@ EOF
     fi
 
     if [  "$NOVNC" == "1" ]; then
-        echo -e "${GREEN}One-KVM VNC is disabled.${NC}"
+        log_info "已禁用 VNC 功能"
         rm -r /usr/share/kvmd/extras/vnc
     else
         cat >> /etc/kvmd/supervisord.conf << EOF
@@ -77,7 +148,7 @@ EOF
     fi
 
     if [  "$NOIPMI" == "1" ]; then
-        echo -e "${GREEN}One-KVM IPMI is disabled.${NC}"
+        log_info "已禁用IPMI功能"
         rm -r /usr/share/kvmd/extras/ipmi
     else
         cat >> /etc/kvmd/supervisord.conf << EOF
@@ -97,48 +168,77 @@ EOF
 
     #switch OTG config
     if [ "$OTG" == "1" ]; then
-        echo -e "${GREEN}One-KVM OTG is enabled.${NC}"
+        log_info "已启用 OTG 功能"
         sed -i "s/ch9329/otg/g" /etc/kvmd/override.yaml
-	    sed -i "s/device: \/dev\/ttyUSB0//g" /etc/kvmd/override.yaml
+        sed -i "s/device: \/dev\/ttyUSB0//g" /etc/kvmd/override.yaml
+        if [ "$NOMSD" == 1 ]; then
+            log_info "已禁用 MSD 功能"
+        else
+            sed -i "s/#type: otg/type: otg/g" /etc/kvmd/override.yaml
+        fi
     fi
 
-    #if [ ! -z "$SHUTDOWNPIN"  ! -z "$REBOOTPIN" ]; then
-
     if [ ! -z "$VIDEONUM" ]; then
-        sed -i "s/\/dev\/video0/\/dev\/video$VIDEONUM/g" /etc/kvmd/override.yaml \
-            && echo -e "${GREEN}One-KVM video device is set to /dev/video$VIDEONUM.${NC}"
+        if sed -i "s/\/dev\/video0/\/dev\/video$VIDEONUM/g" /etc/kvmd/override.yaml && \
+           sed -i "s/\/dev\/video0/\/dev\/video$VIDEONUM/g" /etc/kvmd/janus/janus.plugin.ustreamer.jcfg; then
+            log_info "视频设备已设置为 /dev/video$VIDEONUM"
+        fi
     fi
 
-    #set htpasswd
-    if [ ! -z "$USERNAME" ] && [ ! -z "$PASSWORD" ]; then
-        python -m kvmd.apps.htpasswd del admin \
-            && echo $PASSWORD | python -m kvmd.apps.htpasswd set -i  "$USERNAME" \
-            && echo "$PASSWORD -> $USERNAME:$PASSWORD" > /etc/kvmd/vncpasswd \
-            && echo "$USERNAME:$PASSWORD -> $USERNAME:$PASSWORD" > /etc/kvmd/ipmipasswd \
-            || echo -e "${RED}One-KVM htpasswd init failed.${NC}"
-    else
-        echo -e "${YELLOW} USERNAME and PASSWORD environment variables is not set, using defalut(admin/admin).${NC}"
+    if [ ! -z "$AUDIONUM" ]; then
+        if sed -i "s/hw:0/hw:$AUDIONUM/g" /etc/kvmd/janus/janus.plugin.ustreamer.jcfg; then
+            log_info "音频设备已设置为 hw:$AUDIONUM"
+        fi
     fi
 
-    if [ "$NOMSD" == 1 ]; then
-        echo -e "${GREEN}One-KVM MSD is disabled.${NC}"
-    else
-        sed -i "s/#type: otg/type: otg/g" /etc/kvmd/override.yaml
+    if [ ! -z "$CH9329SPEED" ]; then
+        if sed -i "s/speed: 9600/speed: $CH9329SPEED/g" /etc/kvmd/override.yaml; then
+            log_info "CH9329 串口速率已设置为 $CH9329SPEED"
+        fi
+    fi
+
+    if [ ! -z "$CH9329TIMEOUT" ]; then
+        if sed -i "s/read_timeout: 0.3/read_timeout: $CH9329TIMEOUT/g" /etc/kvmd/override.yaml; then
+            log_info "CH9329 超时已设置为 $CH9329TIMEOUT 秒"
+        fi
+    fi
+
+    if [ ! -z "$H264PRESET" ]; then
+        if sed -i "s/ultrafast/$H264PRESET/g" /etc/kvmd/override.yaml; then
+            log_info "H264 预设已设置为 $H264PRESET"
+        fi
+    fi
+
+    if [ ! -z "$VIDEOFORMAT" ]; then
+        if sed -i "s/format=mjpeg/format=$VIDFORMAT/g" /etc/kvmd/override.yaml; then
+            log_info "视频输入格式已设置为 $VIDFORMAT"
+        fi
     fi
     
     touch /etc/kvmd/.init_flag
+    log_info "初始化配置完成"
 fi
 
-#Trying usb_gadget
+# OTG设备配置
 if [ "$OTG" == "1" ]; then
-    echo "Trying OTG Port..."
+    log_info "正在配置 OTG 设备..."
     rm -r /run/kvmd/otg &> /dev/null
-    modprobe libcomposite || echo -e "${RED}Linux libcomposite module modprobe failed.${NC}"
-    python -m kvmd.apps.otg start \
-        && ln -s /dev/hidg1 /dev/kvmd-hid-mouse \
-        && ln -s /dev/hidg0 /dev/kvmd-hid-keyboard \
-        || echo -e "${RED}OTG Port mount failed.${NC}"
+    
+    if ! modprobe libcomposite; then
+        log_error "加载 libcomposite 模块失败"
+        exit 1
+    fi
+
+    if python -m kvmd.apps.otg start; then
+        ln -s /dev/hidg1 /dev/kvmd-hid-mouse
+        ln -s /dev/hidg0 /dev/kvmd-hid-keyboard
+        ln -s /dev/hidg2 /dev/kvmd-hid-mouse-alt
+        log_info "OTG 设备配置完成"
+    else
+        log_warn "OTG 设备挂载失败"
+        #exit 1
+    fi
 fi
 
-echo -e "${GREEN}One-KVM starting...${NC}"
+log_info "One-KVM 配置文件准备完成，正在启动服务..."
 exec supervisord -c /etc/kvmd/supervisord.conf

build/platform/chainedbox

@@ -0,0 +1,3 @@
+PIKVM_MODEL=v2_model
+PIKVM_VIDEO=usb_video
+PIKVM_BOARD=chainedbox

build/platform/cumebox2

@@ -0,0 +1,3 @@
+PIKVM_MODEL=v2_model
+PIKVM_VIDEO=usb_video
+PIKVM_BOARD=cumebox2

build/platform/e900v22c

@@ -0,0 +1,3 @@
+PIKVM_MODEL=v2_model
+PIKVM_VIDEO=usb_video
+PIKVM_BOARD=e900v22c

build/platform/octopus-flanet

@@ -0,0 +1,3 @@
+PIKVM_MODEL=v2_model
+PIKVM_VIDEO=usb_video
+PIKVM_BOARD=octopus-flanet

build/platform/vm

@@ -0,0 +1,3 @@
+PIKVM_MODEL=v2_model
+PIKVM_VIDEO=usb_video
+PIKVM_BOARD=vm

configs/janus/janus.jcfg

@@ -1,5 +1,5 @@
 general: {
-	debug_level = 4
+	debug_level = 2
 }
 nat: {
 	nice_debug = false

configs/janus/janus.plugin.ustreamer.jcfg

@@ -1,4 +1,7 @@
 video: {
 	sink = "kvmd::ustreamer::h264"
 }
-
+audio: {
+     device = "hw:0"
+     tc358743 = "/dev/video0"
+}

configs/kvmd/armbain-motd

@@ -1,4 +1,24 @@
-#!/bin/bash 
+#!/bin/bash
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2023-2025  SilentWind <mofeng654321@hotmail.com>         #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
  
 if [ -e /etc/update-motd.d/10-armbian-header ]; then /etc/update-motd.d/10-armbian-header; fi
 if [ -e /etc/update-motd.d/30-armbian-sysinfo ]; then /etc/update-motd.d/30-armbian-sysinfo; fi
@@ -15,8 +35,6 @@ printf "
 
 ____________________________________________________________________________
 
-欢迎使用 One-KVM，基于开源程序 PiKVM 的 IP-KVM 应用
-
 项目链接：
     * One-KVM：https://github.com/mofeng-git/One-KVM
 

configs/kvmd/atx.sh

@@ -1,4 +1,24 @@
 #!/bin/bash
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2023-2025  SilentWind <mofeng654321@hotmail.com>         #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
 
 echo $ATX
 case $ATX in

configs/kvmd/clean_when_exit.sh

@@ -1,4 +1,24 @@
 #!/bin/bash
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2023-2025  SilentWind <mofeng654321@hotmail.com>         #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
 
 RED='\033[0;31m'
 GREEN='\033[0;32m'

configs/kvmd/custom_atx/gpio.sh

@@ -1,4 +1,24 @@
 #!/bin/bash
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2023-2025  SilentWind <mofeng654321@hotmail.com>         #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
 case $1 in
     short)
     gpioset -m time -s 1 SHUTDOWNPIN=0

configs/kvmd/custom_atx/usbrelay_hid.py

@@ -1,3 +1,24 @@
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2023-2025  SilentWind <mofeng654321@hotmail.com>         #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
 import sys
 import hid
 

configs/kvmd/custom_atx/usbrelay_hid.sh

@@ -1,4 +1,24 @@
 #!/bin/bash
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2023-2025  SilentWind <mofeng654321@hotmail.com>         #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
 case $1 in
     short)
     python3 /etc/kvmd/custom_atx/usbrelay_hid.py 1 on

configs/kvmd/main/v4plus-hdmi-rpi4.yaml

@@ -0,0 +1,100 @@
+# Don't touch this file otherwise your device may stop working.
+# Use override.yaml to modify required settings.
+# You can find a working configuration in /usr/share/kvmd/configs.default/kvmd.
+
+override: !include [override.d, override.yaml]
+
+logging: !include logging.yaml
+
+kvmd:
+    auth: !include auth.yaml
+
+    info:
+        hw:
+            ignore_past: true
+        fan:
+            unix: /run/kvmd/fan.sock
+
+    hid:
+        type: otg
+        mouse_alt:
+            device: /dev/kvmd-hid-mouse-alt
+
+    atx:
+        type: gpio
+        power_led_pin: 4
+        hdd_led_pin: 5
+        power_switch_pin: 23
+        reset_switch_pin: 27
+
+    msd:
+        type: otg
+
+    streamer:
+        h264_bitrate:
+            default: 5000
+        cmd:
+            - "/usr/bin/ustreamer"
+            - "--device=/dev/kvmd-video"
+            - "--persistent"
+            - "--dv-timings"
+            - "--format=uyvy"
+            - "--format-swap-rgb"
+            - "--buffers=8"
+            - "--encoder=m2m-image"
+            - "--workers=3"
+            - "--quality={quality}"
+            - "--desired-fps={desired_fps}"
+            - "--drop-same-frames=30"
+            - "--unix={unix}"
+            - "--unix-rm"
+            - "--unix-mode=0660"
+            - "--exit-on-parent-death"
+            - "--process-name-prefix={process_name_prefix}"
+            - "--notify-parent"
+            - "--no-log-colors"
+            - "--jpeg-sink=kvmd::ustreamer::jpeg"
+            - "--jpeg-sink-mode=0660"
+            - "--h264-sink=kvmd::ustreamer::h264"
+            - "--h264-sink-mode=0660"
+            - "--h264-bitrate={h264_bitrate}"
+            - "--h264-gop={h264_gop}"
+
+    gpio:
+        drivers:
+            __v4_locator__:
+                type: locator
+
+        scheme:
+            __v3_usb_breaker__:
+                pin: 22
+                mode: output
+                initial: true
+                pulse: false
+
+            __v4_locator__:
+                driver: __v4_locator__
+                pin: 12
+                mode: output
+                pulse: false
+
+            __v4_const1__:
+                pin: 6
+                mode: output
+                initial: false
+                switch: false
+                pulse: false
+
+
+media:
+    memsink:
+        h264:
+            sink: "kvmd::ustreamer::h264"
+
+
+vnc:
+    memsink:
+        jpeg:
+            sink: "kvmd::ustreamer::jpeg"
+        h264:
+            sink: "kvmd::ustreamer::h264"

configs/kvmd/meta.yaml

@@ -6,4 +6,9 @@
 server:
     host: localhost.localdomain
 
-kvm: {}
+kvm: {
+    base_on: PiKVM,
+    app_name: One-KVM,
+    main_version: 241204,
+    author: SilentWind
+}

configs/kvmd/override.yaml

@@ -2,16 +2,14 @@ kvmd:
     auth:
         enabled: true
 
-    server:
-        unix_mode: 0666
-        access_log_format: '[%P / %{X-Real-IP}i] ''%r'' => 响应：%s；大小：%b；来源：''%{Referer}i''；用户代理：''%{User-Agent}i'''
-
     atx:
         type: disabled
 
     hid:
         type: ch9329
         device: /dev/ttyUSB0
+        speed: 9600
+        read_timeout: 0.3
 
         jiggler:
             active: false
@@ -23,6 +21,9 @@ kvmd:
     msd:
         #type: otg
         remount_cmd: /bin/true
+        msd_path: /var/lib/kvmd/msd
+        normalfiles_path: NormalFiles
+        normalfiles_size: 256
 
     ocr:
         langs:
@@ -31,7 +32,7 @@ kvmd:
 
     streamer:
         resolution:
-            default: 1280x720
+            default: 1920x1080
 
         forever: true
 
@@ -40,7 +41,7 @@ kvmd:
             max: 60
 
         h264_bitrate:
-            default: 2000
+            default: 8000
 
         cmd:
             - "/usr/bin/ustreamer"
@@ -65,6 +66,7 @@ kvmd:
             - "--jpeg-sink-mode=0660"
             - "--h264-bitrate={h264_bitrate}"
             - "--h264-gop={h264_gop}"
+            - "--h264-preset=ultrafast"
             - "--slowdown"
     gpio:
         drivers:
@@ -148,6 +150,18 @@ vnc:
         h264:
             sink: "kvmd::ustreamer::h264"
 
+media:
+    memsink:
+        h264:
+            sink: 'kvmd::ustreamer::h264'
+
+        jpeg:
+            sink: 'kvmd::ustreamer::jpeg'
+janus:
+    stun:
+        host: stun.cloudflare.com
+        port: 3478
+
 otgnet:
     commands:
         post_start_cmd:
@@ -159,9 +173,4 @@ nginx:
     http:
         port: 8080
     https:
-        port: 4430
-
-
-languages:
-    console: zh
-    web: zh
+        port: 4430

configs/kvmd/supervisord.conf

@@ -32,6 +32,16 @@ stdout_logfile=/dev/stdout
 stdout_logfile_maxbytes = 0
 redirect_stderr=true
 
+[program:kvmd-media]
+command=python -m kvmd.apps.media --run
+autostart=true
+autorestart=true
+priority=13
+stopasgroup=true
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes = 0
+redirect_stderr=true
+
 [program:kvmd-nginx]
 command=nginx -c /etc/kvmd/nginx/nginx.conf -g 'daemon off;user root; error_log stderr;'
 autostart=true

configs/os/services/kvmd-media.service

@@ -0,0 +1,16 @@
+[Unit]
+Description=PiKVM - Media proxy server
+After=kvmd.service
+
+[Service]
+User=kvmd-media
+Group=kvmd-media
+Type=simple
+Restart=always
+RestartSec=3
+
+ExecStart=/usr/bin/kvmd-media --run
+TimeoutStopSec=3
+
+[Install]
+WantedBy=multi-user.target

configs/os/services/kvmd-oled-reboot.service

@@ -0,0 +1,12 @@
+[Unit]
+Description=PiKVM - Display reboot message on the OLED
+DefaultDependencies=no
+
+[Service]
+Type=oneshot
+ExecStart=/bin/bash -c "kill -USR1 `systemctl show -P MainPID kvmd-oled`"
+ExecStop=/bin/true
+RemainAfterExit=yes
+
+[Install]
+WantedBy=reboot.target

configs/os/services/kvmd-oled-shutdown.service

@@ -0,0 +1,14 @@
+[Unit]
+Description=PiKVM - Display shutdown message on the OLED
+Conflicts=reboot.target
+Before=shutdown.target poweroff.target halt.target
+DefaultDependencies=no
+
+[Service]
+Type=oneshot
+ExecStart=/bin/bash -c "kill -USR2 `systemctl show -P MainPID kvmd-oled`"
+ExecStop=/bin/true
+RemainAfterExit=yes
+
+[Install]
+WantedBy=shutdown.target

configs/os/services/kvmd-oled.service

@@ -0,0 +1,15 @@
+[Unit]
+Description=PiKVM - A small OLED daemon
+After=systemd-modules-load.service
+ConditionPathExists=/dev/i2c-1
+
+[Service]
+Type=simple
+Restart=always
+RestartSec=3
+ExecStartPre=/usr/bin/kvmd-oled --interval=3 --clear-on-exit --image=@hello.ppm
+ExecStart=/usr/bin/kvmd-oled
+TimeoutStopSec=3
+
+[Install]
+WantedBy=multi-user.target

configs/os/services/kvmd-pass.service

@@ -1,15 +0,0 @@
-[Unit]
-Description=PiKVM - Video Passthrough on V4 Plus
-Wants=dev-kvmd\x2dvideo.device
-After=dev-kvmd\x2dvideo.device systemd-modules-load.service
-
-[Service]
-Type=simple
-Restart=always
-RestartSec=3
-
-ExecStart=/usr/bin/ustreamer-v4p --unix-follow /run/kvmd/ustreamer.sock
-TimeoutStopSec=10
-
-[Install]
-WantedBy=multi-user.target

configs/os/services/kvmd-tc358743.service

@@ -2,11 +2,11 @@
 Description=PiKVM - EDID loader for TC358743
 Wants=dev-kvmd\x2dvideo.device
 After=dev-kvmd\x2dvideo.device systemd-modules-load.service
-Before=kvmd.service kvmd-pass.service
+Before=kvmd.service
 
 [Service]
 Type=oneshot
-ExecStart=/usr/bin/v4l2-ctl --device=/dev/kvmd-video --set-edid=file=/etc/kvmd/tc358743-edid.hex --fix-edid-checksums --info-edid
+ExecStart=/usr/bin/v4l2-ctl --device=/dev/kvmd-video --set-edid=file=/etc/kvmd/tc358743-edid.hex --info-edid
 ExecStop=/usr/bin/v4l2-ctl --device=/dev/kvmd-video --clear-edid
 RemainAfterExit=true
 

configs/os/sysusers.conf

@@ -1,4 +1,5 @@
 g kvmd - -
+g kvmd-media - -
 g kvmd-pst - -
 g kvmd-ipmi - -
 g kvmd-vnc - -
@@ -7,6 +8,7 @@ g kvmd-janus - -
 g kvmd-certbot - -
 
 u kvmd - "PiKVM - The main daemon" -
+u kvmd-media - "PiKVM - The media proxy"
 u kvmd-pst - "PiKVM - Persistent storage" -
 u kvmd-ipmi - "PiKVM - IPMI to KVMD proxy" -
 u kvmd-vnc - "PiKVM - VNC to KVMD/Streamer proxy" -
@@ -19,6 +21,10 @@ m kvmd gpio
 m kvmd uucp
 m kvmd spi
 m kvmd systemd-journal
+m kvmd kvmd-media
+m kvmd kvmd-pst
+
+m kvmd-media kvmd
 
 m kvmd-pst kvmd
 
@@ -31,6 +37,7 @@ m kvmd-janus kvmd
 m kvmd-janus audio
 
 m kvmd-nginx kvmd
+m kvmd-nginx kvmd-media
 m kvmd-nginx kvmd-janus
 m kvmd-nginx kvmd-certbot
 

configs/os/udev/common.rules

@@ -1,3 +1,4 @@
 # Here are described some bindings for PiKVM devices.
 # Do not edit this file.
 KERNEL=="ttyACM[0-9]*", SUBSYSTEM=="tty", SUBSYSTEMS=="usb", ATTRS{idVendor}=="1209", ATTRS{idProduct}=="eda3", SYMLINK+="kvmd-hid-bridge"
+KERNEL=="ttyACM[0-9]*", SUBSYSTEM=="tty", SUBSYSTEMS=="usb", ATTRS{idVendor}=="2e8a", ATTRS{idProduct}=="1080", SYMLINK+="kvmd-switch"

configs/os/udev/v2-hdmiusb-generic.rules

@@ -1,7 +0,0 @@
-# https://unix.stackexchange.com/questions/66901/how-to-bind-usb-device-under-a-static-name
-# https://wiki.archlinux.org/index.php/Udev#Setting_static_device_names
-KERNEL=="video[0-9]*", SUBSYSTEM=="video4linux", SUBSYSTEMS=="usb", ATTR{index}=="0", GROUP="kvmd", SYMLINK+="kvmd-video"
-KERNEL=="hidg0", GROUP="kvmd", SYMLINK+="kvmd-hid-keyboard"
-KERNEL=="hidg1", GROUP="kvmd", SYMLINK+="kvmd-hid-mouse"
-KERNEL=="hidg2", GROUP="kvmd", SYMLINK+="kvmd-hid-mouse-alt"
-KERNEL=="ttyUSB0", GROUP="kvmd", SYMLINK+="kvmd-hid"

extras/media/manifest.yaml

@@ -0,0 +1,5 @@
+name: Media
+description: KVMD Media Proxy
+path: media
+daemon: kvmd-media
+place: -1

extras/media/nginx.ctx-http.conf

@@ -0,0 +1,3 @@
+upstream media {
+	server unix:/run/kvmd/media.sock fail_timeout=0s max_fails=0;
+}

extras/media/nginx.ctx-server.conf

@@ -0,0 +1,7 @@
+location /api/media/ws {
+	rewrite ^/api/media/ws$ /ws break;
+	rewrite ^/api/media/ws\?(.*)$ /ws?$1 break;
+	proxy_pass http://media;
+	include /etc/kvmd/nginx/loc-proxy.conf;
+	include /etc/kvmd/nginx/loc-websocket.conf;
+}

hid/pico/Makefile

@@ -31,7 +31,7 @@ endef
 .tinyusb:
 	$(call libdep,tinyusb,hathach/tinyusb,d713571cd44f05d2fc72efc09c670787b74106e0)
 .ps2x2pico:
-	$(call libdep,ps2x2pico,No0ne/ps2x2pico,404aaf02949d5bee8013e3b5d0b3239abf6e13bd)
+	$(call libdep,ps2x2pico,No0ne/ps2x2pico,26ce89d597e598bb0ac636622e064202d91a9efc)
 deps: .pico-sdk .tinyusb .ps2x2pico
 
 

hid/pico/src/CMakeLists.txt

@@ -19,7 +19,7 @@ target_sources(${target_name} PRIVATE
 	${PS2_PATH}/ps2in.c
 	${PS2_PATH}/ps2kb.c
 	${PS2_PATH}/ps2ms.c
-	${PS2_PATH}/scancodesets.c
+	${PS2_PATH}/scancodes.c
 )
 target_link_options(${target_name} PRIVATE -Xlinker --print-memory-usage)
 target_compile_options(${target_name} PRIVATE -Wall -Wextra)

hid/pico/src/ph_usb.c

@@ -53,7 +53,7 @@ static u8 _kbd_keys[6] = {0};
 static u8 _mouse_buttons = 0;
 static s16 _mouse_abs_x = 0;
 static s16 _mouse_abs_y = 0;
-#define _MOUSE_CLEAR { _mouse_buttons = 0; _mouse_abs_x = 0; _mouse_abs_y = 0; }
+#define _MOUSE_CLEAR { _mouse_buttons = 0; }
 
 
 static void _kbd_sync_report(bool new);
@@ -193,7 +193,7 @@ void ph_usb_send_clear(void) {
 	if (PH_O_IS_MOUSE_USB) {
 		_MOUSE_CLEAR;
 		if (PH_O_IS_MOUSE_USB_ABS) {
-			_mouse_abs_send_report(0, 0);
+			_mouse_abs_send_report(_mouse_abs_x, _mouse_abs_y);
 		} else { // PH_O_IS_MOUSE_USB_REL
 			_mouse_rel_send_report(0, 0, 0, 0);
 		}

kvmd.install

@@ -27,7 +27,8 @@ post_upgrade() {
 	done
 
 	chown kvmd /var/lib/kvmd/msd 2>/dev/null || true
-	chown kvmd-pst /var/lib/kvmd/pst 2>/dev/null || true
+	chown kvmd-pst:kvmd-pst /var/lib/kvmd/pst 2>/dev/null || true
+	chmod 1775 /var/lib/kvmd/pst 2>/dev/null || true
 
 	if [ ! -e /etc/kvmd/nginx/ssl/server.crt ]; then
 		echo "==> Generating KVMD-Nginx certificate ..."
@@ -92,6 +93,25 @@ disable_overscan=1
 EOF
 	fi
 
+	if [[ "$(vercmp "$2" 4.4)" -lt 0 ]]; then
+		systemctl disable kvmd-pass || true
+	fi
+
+	if [[ "$(vercmp "$2" 4.5)" -lt 0 ]]; then
+		sed -i 's/X-kvmd\.pst-user=kvmd-pst/X-kvmd.pst-user=kvmd-pst,X-kvmd.pst-group=kvmd-pst/g' /etc/fstab
+		touch -t 200701011000 /etc/fstab
+	fi
+
+	if [[ "$(vercmp "$2" 4.31)" -lt 0 ]]; then
+		if [[ "$(systemctl is-enabled kvmd-janus || true)" = enabled || "$(systemctl is-enabled kvmd-janus-static || true)" = enabled ]]; then
+			systemctl enable kvmd-media || true
+		fi
+	fi
+
+	if [[ "$(vercmp "$2" 4.47)" -lt 0 ]]; then
+		cp /usr/share/kvmd/configs.default/janus/janus.plugin.ustreamer.jcfg /etc/kvmd/janus || true
+	fi
+
 	# Some update deletes /etc/motd, WTF
 	# shellcheck disable=SC2015,SC2166
 	[ ! -f /etc/motd -a -f /etc/motd.pacsave ] && mv /etc/motd.pacsave /etc/motd || true

kvmd/__init__.py

@@ -20,4 +20,4 @@
 # ========================================================================== #
 
 
-__version__ = "4.3"
+__version__ = "4.49"

kvmd/aiogp.py

@@ -83,9 +83,9 @@ class AioReader:  # pylint: disable=too-many-instance-attributes
             self.__path,
             consumer=self.__consumer,
             config={tuple(pins): gpiod.LineSettings(edge_detection=gpiod.line.Edge.BOTH)},
-        ) as line_request:
+        ) as line_req:
 
-            line_request.wait_edge_events(0.1)
+            line_req.wait_edge_events(0.1)
             self.__values = {
                 pin: _DebouncedValue(
                     initial=bool(value.value),
@@ -93,14 +93,14 @@ class AioReader:  # pylint: disable=too-many-instance-attributes
                     notifier=self.__notifier,
                     loop=self.__loop,
                 )
-                for (pin, value) in zip(pins, line_request.get_values(pins))
+                for (pin, value) in zip(pins, line_req.get_values(pins))
             }
             self.__loop.call_soon_threadsafe(self.__notifier.notify)
 
             while not self.__stop_event.is_set():
-                if line_request.wait_edge_events(1):
+                if line_req.wait_edge_events(1):
                     new: dict[int, bool] = {}
-                    for event in line_request.read_edge_events():
+                    for event in line_req.read_edge_events():
                         (pin, value) = self.__parse_event(event)
                         new[pin] = value
                     for (pin, value) in new.items():
@@ -110,7 +110,7 @@ class AioReader:  # pylint: disable=too-many-instance-attributes
                     # Размер буфера ядра - 16 эвентов на линии. При превышении этого числа,
                     # новые эвенты потеряются. Это не баг, это фича, как мне объяснили в LKML.
                     # Штош. Будем с этим жить и синхронизировать состояния при таймауте.
-                    for (pin, value) in zip(pins, line_request.get_values(pins)):
+                    for (pin, value) in zip(pins, line_req.get_values(pins)):
                         self.__values[pin].set(bool(value.value))  # type: ignore
 
     def __parse_event(self, event: gpiod.EdgeEvent) -> tuple[int, bool]:

kvmd/aiohelpers.py

@@ -22,8 +22,6 @@
 
 import subprocess
 
-from .languages import Languages
-
 from .logging import get_logger
 
 from . import tools
@@ -38,13 +36,13 @@ async def remount(name: str, base_cmd: list[str], rw: bool) -> bool:
         part.format(mode=mode)
         for part in base_cmd
     ]
-    logger.info(Languages().gettext("Remounting %s storage to %s: %s ..."), name, mode.upper(), tools.cmdfmt(cmd))
+    logger.info("Remounting %s storage to %s: %s ...", name, mode.upper(), tools.cmdfmt(cmd))
     try:
         proc = await aioproc.log_process(cmd, logger)
         if proc.returncode != 0:
             assert proc.returncode is not None
             raise subprocess.CalledProcessError(proc.returncode, cmd)
-    except Exception as err:
-        logger.error(Languages().gettext("Can't remount %s storage: %s"), name, tools.efmt(err))
+    except Exception as ex:
+        logger.error("Can't remount %s storage: %s", name, tools.efmt(ex))
         return False
     return True

kvmd/aiomulti.py

@@ -59,14 +59,25 @@ def queue_get_last_sync(  # pylint: disable=invalid-name
 # =====
 class AioProcessNotifier:
     def __init__(self) -> None:
-        self.__queue: "multiprocessing.Queue[None]" = multiprocessing.Queue()
+        self.__queue: "multiprocessing.Queue[int]" = multiprocessing.Queue()
 
-    def notify(self) -> None:
-        self.__queue.put_nowait(None)
+    def notify(self, mask: int=0) -> None:
+        self.__queue.put_nowait(mask)
 
-    async def wait(self) -> None:
-        while not (await queue_get_last(self.__queue, 0.1))[0]:
-            pass
+    async def wait(self) -> int:
+        while True:
+            mask = await aiotools.run_async(self.__get)
+            if mask >= 0:
+                return mask
+
+    def __get(self) -> int:
+        try:
+            mask = self.__queue.get(timeout=0.1)
+            while not self.__queue.empty():
+                mask |= self.__queue.get()
+            return mask
+        except queue.Empty:
+            return -1
 
 
 # =====

kvmd/aioproc.py

@@ -26,7 +26,6 @@ import asyncio
 import asyncio.subprocess
 import logging
 
-from .languages import Languages
 import setproctitle
 
 from .logging import get_logger
@@ -86,7 +85,7 @@ async def log_stdout_infinite(proc: asyncio.subprocess.Process, logger: logging.
         else:
             empty += 1
             if empty == 100:  # asyncio bug
-                raise RuntimeError(Languages().gettext("Asyncio process: too many empty lines"))
+                raise RuntimeError("Asyncio process: too many empty lines")
 
 
 async def kill_process(proc: asyncio.subprocess.Process, wait: float, logger: logging.Logger) -> None:  # pylint: disable=no-member
@@ -101,14 +100,14 @@ async def kill_process(proc: asyncio.subprocess.Process, wait: float, logger: lo
                     if proc.returncode is not None:
                         raise
             await proc.wait()
-            logger.info(Languages().gettext("Process killed: retcode=%d"), proc.returncode)
+            logger.info("Process killed: retcode=%d", proc.returncode)
         except asyncio.CancelledError:
             pass
         except Exception:
             if proc.returncode is None:
-                logger.exception(Languages().gettext("Can't kill process pid=%d"), proc.pid)
+                logger.exception("Can't kill process pid=%d", proc.pid)
             else:
-                logger.info(Languages().gettext("Process killed: retcode=%d"), proc.returncode)
+                logger.info("Process killed: retcode=%d", proc.returncode)
 
 
 def rename_process(suffix: str, prefix: str="kvmd") -> None:
@@ -117,7 +116,7 @@ def rename_process(suffix: str, prefix: str="kvmd") -> None:
 
 def settle(name: str, suffix: str, prefix: str="kvmd") -> logging.Logger:
     logger = get_logger(1)
-    logger.info(Languages().gettext("Started %s pid=%d"), name, os.getpid())
+    logger.info("Started %s pid=%d", name, os.getpid())
     os.setpgrp()
     rename_process(suffix, prefix)
     return logger

kvmd/aiotools.py

@@ -45,6 +45,11 @@ async def read_file(path: str) -> str:
         return (await file.read())
 
 
+async def write_file(path: str, text: str) -> None:
+    async with aiofiles.open(path, "w") as file:
+        await file.write(text)
+
+
 # =====
 def run(coro: Coroutine, final: (Coroutine | None)=None) -> None:
     # https://github.com/aio-libs/aiohttp/blob/a1d4dac1d/aiohttp/web.py#L515
@@ -112,9 +117,9 @@ def shield_fg(aw: Awaitable):  # type: ignore
         if inner.cancelled():
             outer.forced_cancel()
         else:
-            err = inner.exception()
-            if err is not None:
-                outer.set_exception(err)
+            ex = inner.exception()
+            if ex is not None:
+                outer.set_exception(ex)
             else:
                 outer.set_result(inner.result())
 
@@ -166,7 +171,7 @@ def create_deadly_task(name: str, coro: Coroutine) -> asyncio.Task:
         except asyncio.CancelledError:
             pass
         except Exception:
-            logger.exception("Unhandled exception in deadly task, killing myself ...")
+            logger.exception("Unhandled exception in deadly task %r, killing myself ...", name)
             pid = os.getpid()
             if pid == 1:
                 os._exit(1)  # Docker workaround  # pylint: disable=protected-access
@@ -232,25 +237,26 @@ async def close_writer(writer: asyncio.StreamWriter) -> bool:
 # =====
 class AioNotifier:
     def __init__(self) -> None:
-        self.__queue: "asyncio.Queue[None]" = asyncio.Queue()
+        self.__queue: "asyncio.Queue[int]" = asyncio.Queue()
 
-    def notify(self) -> None:
-        self.__queue.put_nowait(None)
+    def notify(self, mask: int=0) -> None:
+        self.__queue.put_nowait(mask)
 
-    async def wait(self, timeout: (float | None)=None) -> None:
+    async def wait(self, timeout: (float | None)=None) -> int:
+        mask = 0
         if timeout is None:
-            await self.__queue.get()
+            mask = await self.__queue.get()
         else:
             try:
-                await asyncio.wait_for(
+                mask = await asyncio.wait_for(
                     asyncio.ensure_future(self.__queue.get()),
                     timeout=timeout,
                 )
             except asyncio.TimeoutError:
-                return  # False
+                return -1
         while not self.__queue.empty():
-            await self.__queue.get()
-        # return True
+            mask |= await self.__queue.get()
+        return mask
 
 
 # =====
@@ -296,7 +302,7 @@ class AioExclusiveRegion:
     def is_busy(self) -> bool:
         return self.__busy
 
-    async def enter(self) -> None:
+    def enter(self) -> None:
         if not self.__busy:
             self.__busy = True
             try:
@@ -308,22 +314,22 @@ class AioExclusiveRegion:
             return
         raise self.__exc_type()
 
-    async def exit(self) -> None:
+    def exit(self) -> None:
         self.__busy = False
         if self.__notifier:
             self.__notifier.notify()
 
-    async def __aenter__(self) -> None:
-        await self.enter()
+    def __enter__(self) -> None:
+        self.enter()
 
-    async def __aexit__(
+    def __exit__(
         self,
         _exc_type: type[BaseException],
         _exc: BaseException,
         _tb: types.TracebackType,
     ) -> None:
 
-        await self.exit()
+        self.exit()
 
 
 async def run_region_task(
@@ -338,7 +344,7 @@ async def run_region_task(
 
     async def wrapper() -> None:
         try:
-            async with region:
+            with region:
                 entered.set_result(None)
                 await func(*args, **kwargs)
         except region.get_exc_type():

kvmd/apps/__init__.py

@@ -31,12 +31,8 @@ import pygments
 import pygments.lexers.data
 import pygments.formatters
 
-from gettext import translation
-
 from .. import tools
 
-from ..mouse import MouseRange
-
 from ..plugins import UnknownPluginError
 from ..plugins.auth import get_auth_service_class
 from ..plugins.hid import get_hid_class
@@ -105,9 +101,6 @@ from ..validators.hw import valid_otg_gadget
 from ..validators.hw import valid_otg_id
 from ..validators.hw import valid_otg_ethernet
 
-from ..validators.languages import valid_languages
-
-from ..languages import Languages
 
 # =====
 def init(
@@ -129,7 +122,6 @@ def init(
         add_help=add_help,
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
-    
     parser.add_argument("-c", "--config", default="/etc/kvmd/main.yaml", type=valid_abs_file,
                         help="Set config file path", metavar="<file>")
     parser.add_argument("-o", "--set-options", default=[], nargs="+",
@@ -153,18 +145,9 @@ def init(
         ))
         raise SystemExit()
     config = _init_config(options.config, options.set_options, **load)
+
     logging.captureWarnings(True)
     logging.config.dictConfig(config.logging)
-
-    if isinstance(config.get("languages"), dict) and isinstance(config["languages"].get("console"), str):
-        i18n_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))+"/i18n"
-        Languages.init("message", i18n_path, config["languages"]["console"])
-        gettext = Languages().gettext
-
-        logging.addLevelName(20, gettext("INFO"))
-        logging.addLevelName(30, gettext("WARNING"))
-        logging.addLevelName(40, gettext("ERROR"))
-
     if cli_logging:
         logging.getLogger().handlers[0].setFormatter(logging.Formatter(
             "-- {levelname:>7} -- {message}",
@@ -173,7 +156,10 @@ def init(
 
     if check_run and not options.run:
         raise SystemExit(
-            gettext("To prevent accidental startup, you must specify the --run option to start.\n")+gettext("Try the --help option to find out what this service does.\n")+gettext("Make sure you understand exactly what you are doing!"))
+            "To prevent accidental startup, you must specify the --run option to start.\n"
+            "Try the --help option to find out what this service does.\n"
+            "Make sure you understand exactly what you are doing!"
+        )
 
     return (parser, remaining, config)
 
@@ -183,8 +169,8 @@ def _init_config(config_path: str, override_options: list[str], **load_flags: bo
     config_path = os.path.expanduser(config_path)
     try:
         raw_config: dict = load_yaml_file(config_path)
-    except Exception as err:
-        raise SystemExit(f"ConfigError: Can't read config file {config_path!r}:\n{tools.efmt(err)}")
+    except Exception as ex:
+        raise SystemExit(f"ConfigError: Can't read config file {config_path!r}:\n{tools.efmt(ex)}")
     if not isinstance(raw_config, dict):
         raise SystemExit(f"ConfigError: Top-level of the file {config_path!r} must be a dictionary")
 
@@ -199,8 +185,8 @@ def _init_config(config_path: str, override_options: list[str], **load_flags: bo
             config = make_config(raw_config, scheme)
 
         return config
-    except (ConfigError, UnknownPluginError) as err:
-        raise SystemExit(f"ConfigError: {err}")
+    except (ConfigError, UnknownPluginError) as ex:
+        raise SystemExit(f"ConfigError: {ex}")
 
 
 def _patch_raw(raw_config: dict) -> None:  # pylint: disable=too-many-branches
@@ -419,19 +405,7 @@ def _get_config_scheme() -> dict:
 
             "hid": {
                 "type": Option("", type=valid_stripped_string_not_empty),
-
-                "keymap":      Option("/usr/share/kvmd/keymaps/en-us", type=valid_abs_file),
-                "ignore_keys": Option([], type=functools.partial(valid_string_list, subval=valid_hid_key)),
-
-                "mouse_x_range": {
-                    "min": Option(MouseRange.MIN, type=valid_hid_mouse_move),
-                    "max": Option(MouseRange.MAX, type=valid_hid_mouse_move),
-                },
-                "mouse_y_range": {
-                    "min": Option(MouseRange.MIN, type=valid_hid_mouse_move),
-                    "max": Option(MouseRange.MAX, type=valid_hid_mouse_move),
-                },
-
+                "keymap": Option("/usr/share/kvmd/keymaps/en-us", type=valid_abs_file),
                 # Dynamic content
             },
 
@@ -528,6 +502,37 @@ def _get_config_scheme() -> dict:
                     "table": Option([], type=valid_ugpio_view_table),
                 },
             },
+
+            "switch": {
+                "device":       Option("/dev/kvmd-switch", type=valid_abs_path, unpack_as="device_path"),
+                "default_edid": Option("/etc/kvmd/switch-edid.hex", type=valid_abs_path, unpack_as="default_edid_path"),
+            },
+        },
+
+        "media": {
+            "server": {
+                "unix":              Option("/run/kvmd/media.sock", type=valid_abs_path, unpack_as="unix_path"),
+                "unix_rm":           Option(True,  type=valid_bool),
+                "unix_mode":         Option(0o660, type=valid_unix_mode),
+                "heartbeat":         Option(15.0,  type=valid_float_f01),
+                "access_log_format": Option("[%P / %{X-Real-IP}i] '%r' => %s; size=%b ---"
+                                            " referer='%{Referer}i'; user_agent='%{User-Agent}i'"),
+            },
+
+            "memsink": {
+                "jpeg": {
+                    "sink":             Option("",  unpack_as="obj"),
+                    "lock_timeout":     Option(1.0, type=valid_float_f01),
+                    "wait_timeout":     Option(1.0, type=valid_float_f01),
+                    "drop_same_frames": Option(0.0, type=valid_float_f0),
+                },
+                "h264": {
+                    "sink":             Option("",  unpack_as="obj"),
+                    "lock_timeout":     Option(1.0, type=valid_float_f01),
+                    "wait_timeout":     Option(1.0, type=valid_float_f01),
+                    "drop_same_frames": Option(0.0, type=valid_float_f0),
+                },
+            },
         },
 
         "pst": {
@@ -558,11 +563,12 @@ def _get_config_scheme() -> dict:
             "device_version": Option(-1,     type=functools.partial(valid_number, min=-1, max=0xFFFF)),
             "usb_version":    Option(0x0200, type=valid_otg_id),
             "max_power":      Option(250,    type=functools.partial(valid_number, min=50, max=500)),
-            "remote_wakeup":  Option(False,  type=valid_bool),
+            "remote_wakeup":  Option(True,   type=valid_bool),
 
             "gadget":     Option("kvmd", type=valid_otg_gadget),
             "config":     Option("PiKVM device", type=valid_stripped_string_not_empty),
             "udc":        Option("",     type=valid_stripped_string),
+            "endpoints":  Option(9,      type=valid_int_f0),
             "init_delay": Option(3.0,    type=valid_float_f01),
 
             "user": Option("kvmd", type=valid_user),
@@ -576,6 +582,9 @@ def _get_config_scheme() -> dict:
                     "mouse": {
                         "start": Option(True, type=valid_bool),
                     },
+                    "mouse_alt": {
+                        "start": Option(True, type=valid_bool),
+                    },
                 },
 
                 "msd": {
@@ -586,6 +595,18 @@ def _get_config_scheme() -> dict:
                         "rw":        Option(False, type=valid_bool),
                         "removable": Option(True,  type=valid_bool),
                         "fua":       Option(True,  type=valid_bool),
+                        "inquiry_string": {
+                            "cdrom": {
+                                "vendor":   Option("PiKVM", type=valid_stripped_string),
+                                "product":  Option("Optical Drive", type=valid_stripped_string),
+                                "revision": Option("1.00", type=valid_stripped_string),
+                            },
+                            "flash": {
+                                "vendor":   Option("PiKVM", type=valid_stripped_string),
+                                "product":  Option("Flash Drive", type=valid_stripped_string),
+                                "revision": Option("1.00", type=valid_stripped_string),
+                            },
+                        },
                     },
                 },
 
@@ -602,6 +623,11 @@ def _get_config_scheme() -> dict:
                     "kvm_mac":  Option("",    type=valid_mac, if_empty=""),
                 },
 
+                "audio": {
+                    "enabled":  Option(False, type=valid_bool),
+                    "start":    Option(True,  type=valid_bool),
+                },
+
                 "drives": {
                     "enabled": Option(False, type=valid_bool),
                     "start":   Option(True,  type=valid_bool),
@@ -612,6 +638,18 @@ def _get_config_scheme() -> dict:
                         "rw":        Option(True,  type=valid_bool),
                         "removable": Option(True,  type=valid_bool),
                         "fua":       Option(True,  type=valid_bool),
+                        "inquiry_string": {
+                            "cdrom": {
+                                "vendor":   Option("PiKVM", type=valid_stripped_string),
+                                "product":  Option("Optical Drive", type=valid_stripped_string),
+                                "revision": Option("1.00", type=valid_stripped_string),
+                            },
+                            "flash": {
+                                "vendor":   Option("PiKVM", type=valid_stripped_string),
+                                "product":  Option("Flash Drive", type=valid_stripped_string),
+                                "revision": Option("1.00", type=valid_stripped_string),
+                            },
+                        },
                     },
                 },
             },
@@ -693,9 +731,10 @@ def _get_config_scheme() -> dict:
         },
 
         "vnc": {
-            "desired_fps":  Option(30, type=valid_stream_fps),
-            "mouse_output": Option("usb", type=valid_hid_mouse_output),
-            "keymap":       Option("/usr/share/kvmd/keymaps/en-us", type=valid_abs_file),
+            "desired_fps":     Option(30, type=valid_stream_fps),
+            "mouse_output":    Option("usb", type=valid_hid_mouse_output),
+            "keymap":          Option("/usr/share/kvmd/keymaps/en-us", type=valid_abs_file),
+            "allow_cut_after": Option(3.0, type=valid_float_f0),
 
             "server": {
                 "host":        Option("",   type=valid_ip_or_host, if_empty=""),
@@ -798,9 +837,4 @@ def _get_config_scheme() -> dict:
             "timeout":  Option(300, type=valid_int_f1),
             "interval": Option(30,  type=valid_int_f1),
         },
-
-        "languages": {
-            "console": Option("default",   type=valid_languages),
-            "web":     Option("default", type=valid_languages),
-        },
     }

kvmd/apps/edidconf/__init__.py

@@ -22,259 +22,22 @@
 
 import sys
 import os
-import re
-import dataclasses
-import contextlib
 import subprocess
 import argparse
 import time
 
-from typing import IO
-from typing import Generator
 from typing import Callable
 
 from ...validators.basic import valid_bool
 from ...validators.basic import valid_int_f0
 
+from ...edid import EdidNoBlockError
+from ...edid import Edid
+
 # from .. import init
 
 
 # =====
-class NoBlockError(Exception):
-    pass
-
-
-@contextlib.contextmanager
-def _smart_open(path: str, mode: str) -> Generator[IO, None, None]:
-    fd = (0 if "r" in mode else 1)
-    with (os.fdopen(fd, mode, closefd=False) if path == "-" else open(path, mode)) as file:
-        yield file
-        if "w" in mode:
-            file.flush()
-
-
-@dataclasses.dataclass(frozen=True)
-class _CeaBlock:
-    tag:  int
-    data: bytes
-
-    def __post_init__(self) -> None:
-        assert 0 < self.tag <= 0b111
-        assert 0 < len(self.data) <= 0b11111
-
-    @property
-    def size(self) -> int:
-        return len(self.data) + 1
-
-    def pack(self) -> bytes:
-        header = (self.tag << 5) | len(self.data)
-        return header.to_bytes() + self.data
-
-    @classmethod
-    def first_from_raw(cls, raw: (bytes | list[int])) -> "_CeaBlock":
-        assert 0 < raw[0] <= 0xFF
-        tag = (raw[0] & 0b11100000) >> 5
-        data_size = (raw[0] & 0b00011111)
-        data = bytes(raw[1:data_size + 1])
-        return _CeaBlock(tag, data)
-
-
-_CEA = 128
-_CEA_AUDIO = 1
-_CEA_SPEAKERS = 4
-
-
-class _Edid:
-    # https://en.wikipedia.org/wiki/Extended_Display_Identification_Data
-
-    def __init__(self, path: str) -> None:
-        with _smart_open(path, "rb") as file:
-            data = file.read()
-            if data.startswith(b"\x00\xFF\xFF\xFF\xFF\xFF\xFF\x00"):
-                self.__data = list(data)
-            else:
-                text = re.sub(r"\s", "", data.decode())
-                self.__data = [
-                    int(text[index:index + 2], 16)
-                    for index in range(0, len(text), 2)
-                ]
-            assert len(self.__data) == 256, f"Invalid EDID length: {len(self.__data)}, should be 256 bytes"
-            assert self.__data[126] == 1, "Zero extensions number"
-            assert (self.__data[_CEA + 0], self.__data[_CEA + 1]) == (0x02, 0x03), "Can't find CEA extension"
-
-    def write_hex(self, path: str) -> None:
-        self.__update_checksums()
-        text = "\n".join(
-            "".join(
-                f"{item:0{2}X}"
-                for item in self.__data[index:index + 16]
-            )
-            for index in range(0, len(self.__data), 16)
-        ) + "\n"
-        with _smart_open(path, "w") as file:
-            file.write(text)
-
-    def write_bin(self, path: str) -> None:
-        self.__update_checksums()
-        with _smart_open(path, "wb") as file:
-            file.write(bytes(self.__data))
-
-    def __update_checksums(self) -> None:
-        self.__data[127] = 256 - (sum(self.__data[:127]) % 256)
-        self.__data[255] = 256 - (sum(self.__data[128:255]) % 256)
-
-    # =====
-
-    def get_mfc_id(self) -> str:
-        raw = self.__data[8] << 8 | self.__data[9]
-        return bytes([
-            ((raw >> 10) & 0b11111) + 0x40,
-            ((raw >> 5) & 0b11111) + 0x40,
-            (raw & 0b11111) + 0x40,
-        ]).decode("ascii")
-
-    def set_mfc_id(self, mfc_id: str) -> None:
-        assert len(mfc_id) == 3, "Mfc ID must be 3 characters long"
-        data = mfc_id.upper().encode("ascii")
-        for ch in data:
-            assert 0x41 <= ch <= 0x5A, "Mfc ID must contain only A-Z characters"
-        raw = (
-            (data[2] - 0x40)
-            | ((data[1] - 0x40) << 5)
-            | ((data[0] - 0x40) << 10)
-        )
-        self.__data[8] = (raw >> 8) & 0xFF
-        self.__data[9] = raw & 0xFF
-
-    # =====
-
-    def get_product_id(self) -> int:
-        return (self.__data[10] | self.__data[11] << 8)
-
-    def set_product_id(self, product_id: int) -> None:
-        assert 0 <= product_id <= 0xFFFF, f"Product ID should be from 0 to {0xFFFF}"
-        self.__data[10] = product_id & 0xFF
-        self.__data[11] = (product_id >> 8) & 0xFF
-
-    # =====
-
-    def get_serial(self) -> int:
-        return (
-            self.__data[12]
-            | self.__data[13] << 8
-            | self.__data[14] << 16
-            | self.__data[15] << 24
-        )
-
-    def set_serial(self, serial: int) -> None:
-        assert 0 <= serial <= 0xFFFFFFFF, f"Serial should be from 0 to {0xFFFFFFFF}"
-        self.__data[12] = serial & 0xFF
-        self.__data[13] = (serial >> 8) & 0xFF
-        self.__data[14] = (serial >> 16) & 0xFF
-        self.__data[15] = (serial >> 24) & 0xFF
-
-    # =====
-
-    def get_monitor_name(self) -> str:
-        return self.__get_dtd_text(0xFC, "Monitor Name")
-
-    def set_monitor_name(self, text: str) -> None:
-        self.__set_dtd_text(0xFC, "Monitor Name", text)
-
-    def get_monitor_serial(self) -> str:
-        return self.__get_dtd_text(0xFF, "Monitor Serial")
-
-    def set_monitor_serial(self, text: str) -> None:
-        self.__set_dtd_text(0xFF, "Monitor Serial", text)
-
-    def __get_dtd_text(self, d_type: int, name: str) -> str:
-        index = self.__find_dtd_text(d_type, name)
-        return bytes(self.__data[index:index + 13]).decode("cp437").strip()
-
-    def __set_dtd_text(self, d_type: int, name: str, text: str) -> None:
-        index = self.__find_dtd_text(d_type, name)
-        encoded = (text[:13] + "\n" + " " * 12)[:13].encode("cp437")
-        for (offset, ch) in enumerate(encoded):
-            self.__data[index + offset] = ch
-
-    def __find_dtd_text(self, d_type: int, name: str) -> int:
-        for index in [54, 72, 90, 108]:
-            if self.__data[index + 3] == d_type:
-                return index + 5
-        raise NoBlockError(f"Can't find DTD {name}")
-
-    # ===== CEA =====
-
-    def get_audio(self) -> bool:
-        (cbs, _) = self.__parse_cea()
-        audio = False
-        speakers = False
-        for cb in cbs:
-            if cb.tag == _CEA_AUDIO:
-                audio = True
-            elif cb.tag == _CEA_SPEAKERS:
-                speakers = True
-        return (audio and speakers and self.__get_basic_audio())
-
-    def set_audio(self, enabled: bool) -> None:
-        (cbs, dtds) = self.__parse_cea()
-        cbs = [cb for cb in cbs if cb.tag not in [_CEA_AUDIO, _CEA_SPEAKERS]]
-        if enabled:
-            cbs.append(_CeaBlock(_CEA_AUDIO, b"\x09\x7f\x07"))
-            cbs.append(_CeaBlock(_CEA_SPEAKERS, b"\x01\x00\x00"))
-        self.__replace_cea(cbs, dtds)
-        self.__set_basic_audio(enabled)
-
-    def __get_basic_audio(self) -> bool:
-        return bool(self.__data[_CEA + 3] & 0b01000000)
-
-    def __set_basic_audio(self, enabled: bool) -> None:
-        if enabled:
-            self.__data[_CEA + 3] |= 0b01000000
-        else:
-            self.__data[_CEA + 3] &= (0xFF - 0b01000000)  # ~X
-
-    def __parse_cea(self) -> tuple[list[_CeaBlock], bytes]:
-        cea = self.__data[_CEA:]
-        dtd_begin = cea[2]
-        if dtd_begin == 0:
-            return ([], b"")
-
-        cbs: list[_CeaBlock] = []
-        if dtd_begin > 4:
-            raw = cea[4:dtd_begin]
-            while len(raw) != 0:
-                cb = _CeaBlock.first_from_raw(raw)
-                cbs.append(cb)
-                raw = raw[cb.size:]
-
-        dtds = b""
-        assert dtd_begin >= 4
-        raw = cea[dtd_begin:]
-        while len(raw) > (18 + 1) and raw[0] != 0:
-            dtds += bytes(raw[:18])
-            raw = raw[18:]
-
-        return (cbs, dtds)
-
-    def __replace_cea(self, cbs: list[_CeaBlock], dtds: bytes) -> None:
-        cbs_packed = b""
-        for cb in cbs:
-            cbs_packed += cb.pack()
-
-        raw = cbs_packed + dtds
-        assert len(raw) <= (128 - 4 - 1), "Too many CEA blocks or DTDs"
-
-        self.__data[_CEA + 2] = (0 if len(raw) == 0 else (len(cbs_packed) + 4))
-
-        for index in range(4, 127):
-            try:
-                ch = raw[index - 4]
-            except IndexError:
-                ch = 0
-            self.__data[_CEA + index] = ch
-
-
 def _format_bool(value: bool) -> str:
     return ("yes" if value else "no")
 
@@ -283,7 +46,7 @@ def _make_format_hex(size: int) -> Callable[[int], str]:
     return (lambda value: ("0x{:0%dX} ({})" % (size * 2)).format(value, value))
 
 
-def _print_edid(edid: _Edid) -> None:
+def _print_edid(edid: Edid) -> None:
     for (key, get, fmt) in [
         ("Manufacturer ID:", edid.get_mfc_id,         str),
         ("Product ID:     ", edid.get_product_id,     _make_format_hex(2)),
@@ -294,7 +57,7 @@ def _print_edid(edid: _Edid) -> None:
     ]:
         try:
             print(key, fmt(get()), file=sys.stderr)  # type: ignore
-        except NoBlockError:
+        except EdidNoBlockError:
             pass
 
 
@@ -348,12 +111,12 @@ def main(argv: (list[str] | None)=None) -> None:  # pylint: disable=too-many-bra
                         help="Presets directory", metavar="<dir>")
     options = parser.parse_args(argv[1:])
 
-    base: (_Edid | None) = None
+    base: (Edid | None) = None
     if options.import_preset:
         imp = options.import_preset
         if "." in imp:
             (base_name, imp) = imp.split(".", 1)  # v3.1080p-by-default
-            base = _Edid(os.path.join(options.presets_path, f"{base_name}.hex"))
+            base = Edid.from_file(os.path.join(options.presets_path, f"{base_name}.hex"))
             imp = f"_{imp}"
         options.imp = os.path.join(options.presets_path, f"{imp}.hex")
 
@@ -362,16 +125,16 @@ def main(argv: (list[str] | None)=None) -> None:  # pylint: disable=too-many-bra
         options.export_hex = options.edid_path
         options.edid_path = options.imp
 
-    edid = _Edid(options.edid_path)
+    edid = Edid.from_file(options.edid_path)
     changed = False
 
-    for cmd in dir(_Edid):
+    for cmd in dir(Edid):
         if cmd.startswith("set_"):
             value = getattr(options, cmd)
             if value is None and base is not None:
                 try:
                     value = getattr(base, cmd.replace("set_", "get_"))()
-                except NoBlockError:
+                except EdidNoBlockError:
                     pass
             if value is not None:
                 getattr(edid, cmd)(value)
@@ -400,8 +163,7 @@ def main(argv: (list[str] | None)=None) -> None:  # pylint: disable=too-many-bra
                 "/usr/bin/v4l2-ctl",
                 f"--device={options.device_path}",
                 f"--set-edid=file={orig_edid_path}",
-                "--fix-edid-checksums",
                 "--info-edid",
             ], stdout=sys.stderr, check=True)
-    except subprocess.CalledProcessError as err:
-        raise SystemExit(str(err))
+    except subprocess.CalledProcessError as ex:
+        raise SystemExit(str(ex))

kvmd/apps/htpasswd/__init__.py

@@ -155,5 +155,5 @@ def main(argv: (list[str] | None)=None) -> None:
     options = parser.parse_args(argv[1:])
     try:
         options.cmd(config, options)
-    except ValidatorError as err:
-        raise SystemExit(str(err))
+    except ValidatorError as ex:
+        raise SystemExit(str(ex))

kvmd/apps/ipmi/server.py

@@ -101,6 +101,7 @@ class IpmiServer(BaseIpmiServer):  # pylint: disable=too-many-instance-attribute
     # =====
 
     def handle_raw_request(self, request: dict, session: IpmiServerSession) -> None:
+        # Parameter 'request' has been renamed to 'req' in overriding method
         handler = {
             (6, 1): (lambda _, session: self.send_device_id(session)),  # Get device ID
             (6, 7): self.__get_power_state_handler,  # Power state
@@ -145,13 +146,13 @@ class IpmiServer(BaseIpmiServer):  # pylint: disable=too-many-instance-attribute
         data = [int(result["leds"]["power"]), 0, 0]
         session.send_ipmi_response(data=data)
 
-    def __chassis_control_handler(self, request: dict, session: IpmiServerSession) -> None:
+    def __chassis_control_handler(self, req: dict, session: IpmiServerSession) -> None:
         action = {
             0: "off_hard",
             1: "on",
             3: "reset_hard",
             5: "off",
-        }.get(request["data"][0], "")
+        }.get(req["data"][0], "")
         if action:
             if not self.__make_request(session, f"atx.switch_power({action})", "atx.switch_power", action=action):
                 code = 0xC0  # Try again later
@@ -171,8 +172,8 @@ class IpmiServer(BaseIpmiServer):  # pylint: disable=too-many-instance-attribute
                 async with self.__kvmd.make_session(credentials.kvmd_user, credentials.kvmd_passwd) as kvmd_session:
                     func = functools.reduce(getattr, func_path.split("."), kvmd_session)
                     return (await func(**kwargs))
-            except (aiohttp.ClientError, asyncio.TimeoutError) as err:
-                logger.error("[%s]: Can't perform request %s: %s", session.sockaddr[0], name, err)
+            except (aiohttp.ClientError, asyncio.TimeoutError) as ex:
+                logger.error("[%s]: Can't perform request %s: %s", session.sockaddr[0], name, ex)
                 raise
 
         return aiotools.run_sync(runner())

kvmd/apps/janus/runner.py

@@ -11,16 +11,17 @@ from ... import aioproc
 
 from ...logging import get_logger
 
+from .stun import StunNatType
 from .stun import Stun
 
 
 # =====
 @dataclasses.dataclass(frozen=True)
 class _Netcfg:
-    nat_type: str = dataclasses.field(default="")
-    src_ip: str = dataclasses.field(default="")
-    ext_ip: str = dataclasses.field(default="")
-    stun_host: str = dataclasses.field(default="")
+    nat_type:  StunNatType = dataclasses.field(default=StunNatType.ERROR)
+    src_ip:    str = dataclasses.field(default="")
+    ext_ip:    str = dataclasses.field(default="")
+    stun_ip:   str = dataclasses.field(default="")
     stun_port: int = dataclasses.field(default=0)
 
 
@@ -92,8 +93,9 @@ class JanusRunner:  # pylint: disable=too-many-instance-attributes
 
     async def __get_netcfg(self) -> _Netcfg:
         src_ip = (self.__get_default_ip() or "0.0.0.0")
-        (stun, (nat_type, ext_ip)) = await self.__get_stun_info(src_ip)
-        return _Netcfg(nat_type, src_ip, ext_ip, stun.host, stun.port)
+        info = await self.__stun.get_info(src_ip, 0)
+        # В текущей реализации _Netcfg() это копия StunInfo()
+        return _Netcfg(**dataclasses.asdict(info))
 
     def __get_default_ip(self) -> str:
         try:
@@ -111,17 +113,10 @@ class JanusRunner:  # pylint: disable=too-many-instance-attributes
                     for proto in [socket.AF_INET, socket.AF_INET6]:
                         if proto in addrs:
                             return addrs[proto][0]["addr"]
-        except Exception as err:
-            get_logger().error("Can't get default IP: %s", tools.efmt(err))
+        except Exception as ex:
+            get_logger().error("Can't get default IP: %s", tools.efmt(ex))
         return ""
 
-    async def __get_stun_info(self, src_ip: str) -> tuple[Stun, tuple[str, str]]:
-        try:
-            return (self.__stun, (await self.__stun.get_info(src_ip, 0)))
-        except Exception as err:
-            get_logger().error("Can't get STUN info: %s", tools.efmt(err))
-            return (self.__stun, ("", ""))
-
     # =====
 
     @aiotools.atomic_fg
@@ -162,7 +157,7 @@ class JanusRunner:  # pylint: disable=too-many-instance-attributes
     async def __start_janus_proc(self, netcfg: _Netcfg) -> None:
         assert self.__janus_proc is None
         placeholders = {
-            "o_stun_server": f"--stun-server={netcfg.stun_host}:{netcfg.stun_port}",
+            "o_stun_server": f"--stun-server={netcfg.stun_ip}:{netcfg.stun_port}",
             **{
                 key: str(value)
                 for (key, value) in dataclasses.asdict(netcfg).items()

kvmd/apps/janus/stun.py

@@ -4,6 +4,7 @@ import ipaddress
 import struct
 import secrets
 import dataclasses
+import enum
 
 from ... import tools
 from ... import aiotools
@@ -12,29 +13,39 @@ from ...logging import get_logger
 
 
 # =====
+class StunNatType(enum.Enum):
+    ERROR               = ""
+    BLOCKED             = "Blocked"
+    OPEN_INTERNET       = "Open Internet"
+    SYMMETRIC_UDP_FW    = "Symmetric UDP Firewall"
+    FULL_CONE_NAT       = "Full Cone NAT"
+    RESTRICTED_NAT      = "Restricted NAT"
+    RESTRICTED_PORT_NAT = "Restricted Port NAT"
+    SYMMETRIC_NAT       = "Symmetric NAT"
+    CHANGED_ADDR_ERROR  = "Error when testing on Changed-IP and Port"
+
+
 @dataclasses.dataclass(frozen=True)
-class StunAddress:
-    ip: str
+class StunInfo:
+    nat_type:  StunNatType
+    src_ip:    str
+    ext_ip:    str
+    stun_ip:   str
+    stun_port: int
+
+
+@dataclasses.dataclass(frozen=True)
+class _StunAddress:
+    ip:   str
     port: int
 
 
 @dataclasses.dataclass(frozen=True)
-class StunResponse:
-    ok: bool
-    ext: (StunAddress | None) = dataclasses.field(default=None)
-    src: (StunAddress | None) = dataclasses.field(default=None)
-    changed: (StunAddress | None) = dataclasses.field(default=None)
-
-
-class StunNatType:
-    BLOCKED = "Blocked"
-    OPEN_INTERNET = "Open Internet"
-    SYMMETRIC_UDP_FW = "Symmetric UDP Firewall"
-    FULL_CONE_NAT = "Full Cone NAT"
-    RESTRICTED_NAT = "Restricted NAT"
-    RESTRICTED_PORT_NAT = "Restricted Port NAT"
-    SYMMETRIC_NAT = "Symmetric NAT"
-    CHANGED_ADDR_ERROR = "Error when testing on Changed-IP and Port"
+class _StunResponse:
+    ok:      bool
+    ext:     (_StunAddress | None) = dataclasses.field(default=None)
+    src:     (_StunAddress | None) = dataclasses.field(default=None)
+    changed: (_StunAddress | None) = dataclasses.field(default=None)
 
 
 # =====
@@ -50,58 +61,94 @@ class Stun:
         retries_delay: float,
     ) -> None:
 
-        self.host = host
-        self.port = port
+        self.__host = host
+        self.__port = port
         self.__timeout = timeout
         self.__retries = retries
         self.__retries_delay = retries_delay
 
+        self.__stun_ip = ""
         self.__sock: (socket.socket | None) = None
 
-    async def get_info(self, src_ip: str, src_port: int) -> tuple[str, str]:
-        (family, _, _, _, addr) = socket.getaddrinfo(src_ip, src_port, type=socket.SOCK_DGRAM)[0]
+    async def get_info(self, src_ip: str, src_port: int) -> StunInfo:
+        nat_type = StunNatType.ERROR
+        ext_ip = ""
         try:
-            with socket.socket(family, socket.SOCK_DGRAM) as self.__sock:
+            (src_fam, _, _, _, src_addr) = (await self.__retried_getaddrinfo_udp(src_ip, src_port))[0]
+
+            stun_ips = [
+                stun_addr[0]
+                for (stun_fam, _, _, _, stun_addr) in (await self.__retried_getaddrinfo_udp(self.__host, self.__port))
+                if stun_fam == src_fam
+            ]
+            if not stun_ips:
+                raise RuntimeError(f"Can't resolve {src_fam.name} address for STUN")
+            if not self.__stun_ip or self.__stun_ip not in stun_ips:
+                # On new IP, changed family, etc.
+                self.__stun_ip = stun_ips[0]
+
+            with socket.socket(src_fam, socket.SOCK_DGRAM) as self.__sock:
                 self.__sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
                 self.__sock.settimeout(self.__timeout)
-                self.__sock.bind(addr)
-                (nat_type, response) = await self.__get_nat_type(src_ip)
-                return (nat_type, (response.ext.ip if response.ext is not None else ""))
+                self.__sock.bind(src_addr)
+                (nat_type, resp) = await self.__get_nat_type(src_ip)
+                ext_ip = (resp.ext.ip if resp.ext is not None else "")
+        except Exception as ex:
+            get_logger(0).error("Can't get STUN info: %s", tools.efmt(ex))
         finally:
             self.__sock = None
 
-    async def __get_nat_type(self, src_ip: str) -> tuple[str, StunResponse]:  # pylint: disable=too-many-return-statements
-        first = await self.__make_request("First probe")
+        return StunInfo(
+            nat_type=nat_type,
+            src_ip=src_ip,
+            ext_ip=ext_ip,
+            stun_ip=self.__stun_ip,
+            stun_port=self.__port,
+        )
+
+    async def __retried_getaddrinfo_udp(self, host: str, port: int) -> list:
+        retries = self.__retries
+        while True:
+            try:
+                return socket.getaddrinfo(host, port, type=socket.SOCK_DGRAM)
+            except Exception:
+                retries -= 1
+                if retries == 0:
+                    raise
+            await asyncio.sleep(self.__retries_delay)
+
+    async def __get_nat_type(self, src_ip: str) -> tuple[StunNatType, _StunResponse]:  # pylint: disable=too-many-return-statements
+        first = await self.__make_request("First probe", self.__stun_ip, b"")
         if not first.ok:
             return (StunNatType.BLOCKED, first)
 
-        request = struct.pack(">HHI", 0x0003, 0x0004, 0x00000006)  # Change-Request
-        response = await self.__make_request("Change request [ext_ip == src_ip]", request)
+        req = struct.pack(">HHI", 0x0003, 0x0004, 0x00000006)  # Change-Request
+        resp = await self.__make_request("Change request [ext_ip == src_ip]", self.__stun_ip, req)
 
         if first.ext is not None and first.ext.ip == src_ip:
-            if response.ok:
-                return (StunNatType.OPEN_INTERNET, response)
-            return (StunNatType.SYMMETRIC_UDP_FW, response)
+            if resp.ok:
+                return (StunNatType.OPEN_INTERNET, resp)
+            return (StunNatType.SYMMETRIC_UDP_FW, resp)
 
-        if response.ok:
-            return (StunNatType.FULL_CONE_NAT, response)
+        if resp.ok:
+            return (StunNatType.FULL_CONE_NAT, resp)
 
         if first.changed is None:
             raise RuntimeError(f"Changed addr is None: {first}")
-        response = await self.__make_request("Change request [ext_ip != src_ip]", addr=first.changed)
-        if not response.ok:
-            return (StunNatType.CHANGED_ADDR_ERROR, response)
+        resp = await self.__make_request("Change request [ext_ip != src_ip]", first.changed, b"")
+        if not resp.ok:
+            return (StunNatType.CHANGED_ADDR_ERROR, resp)
 
-        if response.ext == first.ext:
-            request = struct.pack(">HHI", 0x0003, 0x0004, 0x00000002)
-            response = await self.__make_request("Change port", request, addr=first.changed.ip)
-            if response.ok:
-                return (StunNatType.RESTRICTED_NAT, response)
-            return (StunNatType.RESTRICTED_PORT_NAT, response)
+        if resp.ext == first.ext:
+            req = struct.pack(">HHI", 0x0003, 0x0004, 0x00000002)
+            resp = await self.__make_request("Change port", first.changed.ip, req)
+            if resp.ok:
+                return (StunNatType.RESTRICTED_NAT, resp)
+            return (StunNatType.RESTRICTED_PORT_NAT, resp)
 
-        return (StunNatType.SYMMETRIC_NAT, response)
+        return (StunNatType.SYMMETRIC_NAT, resp)
 
-    async def __make_request(self, ctx: str, request: bytes=b"", addr: (StunAddress | str | None)=None) -> StunResponse:
+    async def __make_request(self, ctx: str, addr: (_StunAddress | str), req: bytes) -> _StunResponse:
         # TODO: Support IPv6 and RFC 5389
         # The first 4 bytes of the response are the Type (2) and Length (2)
         # The 5th byte is Reserved
@@ -111,32 +158,29 @@ class Stun:
         # More info at: https://tools.ietf.org/html/rfc3489#section-11.2.1
         # And at: https://tools.ietf.org/html/rfc5389#section-15.1
 
-        if isinstance(addr, StunAddress):
+        if isinstance(addr, _StunAddress):
             addr_t = (addr.ip, addr.port)
-        elif isinstance(addr, str):
-            addr_t = (addr, self.port)
-        else:
-            assert addr is None
-            addr_t = (self.host, self.port)
+        else:  # str
+            addr_t = (addr, self.__port)
 
         # https://datatracker.ietf.org/doc/html/rfc5389#section-6
         trans_id = b"\x21\x12\xA4\x42" + secrets.token_bytes(12)
-        (response, error) = (b"", "")
+        (resp, error) = (b"", "")
         for _ in range(self.__retries):
-            (response, error) = await self.__inner_make_request(trans_id, request, addr_t)
+            (resp, error) = await self.__inner_make_request(trans_id, req, addr_t)
             if not error:
                 break
             await asyncio.sleep(self.__retries_delay)
         if error:
             get_logger(0).error("%s: Can't perform STUN request after %d retries; last error: %s",
                                 ctx, self.__retries, error)
-            return StunResponse(ok=False)
+            return _StunResponse(ok=False)
 
-        parsed: dict[str, StunAddress] = {}
+        parsed: dict[str, _StunAddress] = {}
         offset = 0
-        remaining = len(response)
+        remaining = len(resp)
         while remaining > 0:
-            (attr_type, attr_len) = struct.unpack(">HH", response[offset : offset + 4])  # noqa: E203
+            (attr_type, attr_len) = struct.unpack(">HH", resp[offset : offset + 4])  # noqa: E203
             offset += 4
             field = {
                 0x0001: "ext",      # MAPPED-ADDRESS
@@ -145,40 +189,40 @@ class Stun:
                 0x0005: "changed",  # CHANGED-ADDRESS
             }.get(attr_type)
             if field is not None:
-                parsed[field] = self.__parse_address(response[offset:], (trans_id if attr_type == 0x0020 else b""))
+                parsed[field] = self.__parse_address(resp[offset:], (trans_id if attr_type == 0x0020 else b""))
             offset += attr_len
             remaining -= (4 + attr_len)
-        return StunResponse(ok=True, **parsed)
+        return _StunResponse(ok=True, **parsed)
 
-    async def __inner_make_request(self, trans_id: bytes, request: bytes, addr: tuple[str, int]) -> tuple[bytes, str]:
+    async def __inner_make_request(self, trans_id: bytes, req: bytes, addr: tuple[str, int]) -> tuple[bytes, str]:
         assert self.__sock is not None
 
-        request = struct.pack(">HH", 0x0001, len(request)) + trans_id + request  # Bind Request
+        req = struct.pack(">HH", 0x0001, len(req)) + trans_id + req  # Bind Request
 
         try:
-            await aiotools.run_async(self.__sock.sendto, request, addr)
-        except Exception as err:
-            return (b"", f"Send error: {tools.efmt(err)}")
+            await aiotools.run_async(self.__sock.sendto, req, addr)
+        except Exception as ex:
+            return (b"", f"Send error: {tools.efmt(ex)}")
         try:
-            response = (await aiotools.run_async(self.__sock.recvfrom, 2048))[0]
-        except Exception as err:
-            return (b"", f"Recv error: {tools.efmt(err)}")
+            resp = (await aiotools.run_async(self.__sock.recvfrom, 2048))[0]
+        except Exception as ex:
+            return (b"", f"Recv error: {tools.efmt(ex)}")
 
-        (response_type, payload_len) = struct.unpack(">HH", response[:4])
-        if response_type != 0x0101:
-            return (b"", f"Invalid response type: {response_type:#06x}")
-        if trans_id != response[4:20]:
+        (resp_type, payload_len) = struct.unpack(">HH", resp[:4])
+        if resp_type != 0x0101:
+            return (b"", f"Invalid response type: {resp_type:#06x}")
+        if trans_id != resp[4:20]:
             return (b"", "Transaction ID mismatch")
 
-        return (response[20 : 20 + payload_len], "")  # noqa: E203
+        return (resp[20 : 20 + payload_len], "")  # noqa: E203
 
-    def __parse_address(self, data: bytes, trans_id: bytes) -> StunAddress:
+    def __parse_address(self, data: bytes, trans_id: bytes) -> _StunAddress:
         family = data[1]
         port = struct.unpack(">H", self.__trans_xor(data[2:4], trans_id))[0]
         if family == 0x01:
-            return StunAddress(str(ipaddress.IPv4Address(self.__trans_xor(data[4:8], trans_id))), port)
+            return _StunAddress(str(ipaddress.IPv4Address(self.__trans_xor(data[4:8], trans_id))), port)
         elif family == 0x02:
-            return StunAddress(str(ipaddress.IPv6Address(self.__trans_xor(data[4:20], trans_id))), port)
+            return _StunAddress(str(ipaddress.IPv6Address(self.__trans_xor(data[4:20], trans_id))), port)
         raise RuntimeError(f"Unknown family; received: {family}")
 
     def __trans_xor(self, data: bytes, trans_id: bytes) -> bytes:

kvmd/apps/kvmd/__init__.py

@@ -26,8 +26,6 @@ from ...plugins.hid import get_hid_class
 from ...plugins.atx import get_atx_class
 from ...plugins.msd import get_msd_class
 
-from ...languages import Languages
-
 from .. import init
 
 from .auth import AuthManager
@@ -37,6 +35,7 @@ from .ugpio import UserGpio
 from .streamer import Streamer
 from .snapshoter import Snapshoter
 from .ocr import Ocr
+from .switch import Switch
 from .server import KvmdServer
 
 
@@ -58,7 +57,7 @@ def main(argv: (list[str] | None)=None) -> None:
     if config.kvmd.msd.type == "otg":
         msd_kwargs["gadget"] = config.otg.gadget  # XXX: Small crutch to pass gadget name to the plugin
 
-    hid_kwargs = config.kvmd.hid._unpack(ignore=["type", "keymap", "ignore_keys", "mouse_x_range", "mouse_y_range"])
+    hid_kwargs = config.kvmd.hid._unpack(ignore=["type", "keymap"])
     if config.kvmd.hid.type == "otg":
         hid_kwargs["udc"] = config.otg.udc  # XXX: Small crutch to pass UDC to the plugin
 
@@ -92,6 +91,10 @@ def main(argv: (list[str] | None)=None) -> None:
         log_reader=(LogReader() if config.log_reader.enabled else None),
         user_gpio=UserGpio(config.gpio, global_config.otg),
         ocr=Ocr(**config.ocr._unpack()),
+        switch=Switch(
+            pst_unix_path=global_config.pst.server.unix,
+            **config.switch._unpack(),
+        ),
 
         hid=hid,
         atx=get_atx_class(config.atx.type)(**config.atx._unpack(ignore=["type"])),
@@ -105,11 +108,8 @@ def main(argv: (list[str] | None)=None) -> None:
         ),
 
         keymap_path=config.hid.keymap,
-        ignore_keys=config.hid.ignore_keys,
-        mouse_x_range=(config.hid.mouse_x_range.min, config.hid.mouse_x_range.max),
-        mouse_y_range=(config.hid.mouse_y_range.min, config.hid.mouse_y_range.max),
 
         stream_forever=config.streamer.forever,
     ).run(**config.server._unpack())
 
-    get_logger(0).info(Languages().gettext("Bye-bye"))
+    get_logger(0).info("Bye-bye")

kvmd/apps/kvmd/api/atx.py

@@ -45,9 +45,9 @@ class AtxApi:
         return make_json_response(await self.__atx.get_state())
 
     @exposed_http("POST", "/atx/power")
-    async def __power_handler(self, request: Request) -> Response:
-        action = valid_atx_power_action(request.query.get("action"))
-        wait = valid_bool(request.query.get("wait", False))
+    async def __power_handler(self, req: Request) -> Response:
+        action = valid_atx_power_action(req.query.get("action"))
+        wait = valid_bool(req.query.get("wait", False))
         await ({
             "on": self.__atx.power_on,
             "off": self.__atx.power_off,
@@ -57,9 +57,9 @@ class AtxApi:
         return make_json_response()
 
     @exposed_http("POST", "/atx/click")
-    async def __click_handler(self, request: Request) -> Response:
-        button = valid_atx_button(request.query.get("button"))
-        wait = valid_bool(request.query.get("wait", False))
+    async def __click_handler(self, req: Request) -> Response:
+        button = valid_atx_button(req.query.get("button"))
+        wait = valid_bool(req.query.get("wait", False))
         await ({
             "power": self.__atx.click_power,
             "power_long": self.__atx.click_power_long,

kvmd/apps/kvmd/api/auth.py

@@ -43,34 +43,34 @@ from ..auth import AuthManager
 _COOKIE_AUTH_TOKEN = "auth_token"
 
 
-async def check_request_auth(auth_manager: AuthManager, exposed: HttpExposed, request: Request) -> None:
+async def check_request_auth(auth_manager: AuthManager, exposed: HttpExposed, req: Request) -> None:
     if auth_manager.is_auth_required(exposed):
-        user = request.headers.get("X-KVMD-User", "")
+        user = req.headers.get("X-KVMD-User", "")
         if user:
             user = valid_user(user)
-            passwd = request.headers.get("X-KVMD-Passwd", "")
-            set_request_auth_info(request, f"{user} (xhdr)")
+            passwd = req.headers.get("X-KVMD-Passwd", "")
+            set_request_auth_info(req, f"{user} (xhdr)")
             if not (await auth_manager.authorize(user, valid_passwd(passwd))):
                 raise ForbiddenError()
             return
 
-        token = request.cookies.get(_COOKIE_AUTH_TOKEN, "")
+        token = req.cookies.get(_COOKIE_AUTH_TOKEN, "")
         if token:
             user = auth_manager.check(valid_auth_token(token))  # type: ignore
             if not user:
-                set_request_auth_info(request, "- (token)")
+                set_request_auth_info(req, "- (token)")
                 raise ForbiddenError()
-            set_request_auth_info(request, f"{user} (token)")
+            set_request_auth_info(req, f"{user} (token)")
             return
 
-        basic_auth = request.headers.get("Authorization", "")
+        basic_auth = req.headers.get("Authorization", "")
         if basic_auth and basic_auth[:6].lower() == "basic ":
             try:
                 (user, passwd) = base64.b64decode(basic_auth[6:]).decode("utf-8").split(":")
             except Exception:
                 raise UnauthorizedError()
             user = valid_user(user)
-            set_request_auth_info(request, f"{user} (basic)")
+            set_request_auth_info(req, f"{user} (basic)")
             if not (await auth_manager.authorize(user, valid_passwd(passwd))):
                 raise ForbiddenError()
             return
@@ -85,9 +85,9 @@ class AuthApi:
     # =====
 
     @exposed_http("POST", "/auth/login", auth_required=False)
-    async def __login_handler(self, request: Request) -> Response:
+    async def __login_handler(self, req: Request) -> Response:
         if self.__auth_manager.is_auth_enabled():
-            credentials = await request.post()
+            credentials = await req.post()
             token = await self.__auth_manager.login(
                 user=valid_user(credentials.get("user", "")),
                 passwd=valid_passwd(credentials.get("passwd", "")),
@@ -98,9 +98,9 @@ class AuthApi:
         return make_json_response()
 
     @exposed_http("POST", "/auth/logout")
-    async def __logout_handler(self, request: Request) -> Response:
+    async def __logout_handler(self, req: Request) -> Response:
         if self.__auth_manager.is_auth_enabled():
-            token = valid_auth_token(request.cookies.get(_COOKIE_AUTH_TOKEN, ""))
+            token = valid_auth_token(req.cookies.get(_COOKIE_AUTH_TOKEN, ""))
             self.__auth_manager.logout(token)
         return make_json_response()
 

kvmd/apps/kvmd/api/export.py

@@ -55,10 +55,9 @@ class ExportApi:
 
     @async_lru.alru_cache(maxsize=1, ttl=5)
     async def __get_prometheus_metrics(self) -> str:
-        (atx_state, hw_state, fan_state, gpio_state) = await asyncio.gather(*[
+        (atx_state, info_state, gpio_state) = await asyncio.gather(*[
             self.__atx.get_state(),
-            self.__info_manager.get_submanager("hw").get_state(),
-            self.__info_manager.get_submanager("fan").get_state(),
+            self.__info_manager.get_state(["hw", "fan"]),
             self.__user_gpio.get_state(),
         ])
         rows: list[str] = []
@@ -67,13 +66,13 @@ class ExportApi:
         self.__append_prometheus_rows(rows, atx_state["leds"]["power"], "pikvm_atx_power")  # type: ignore
 
         for mode in sorted(UserGpioModes.ALL):
-            for (channel, ch_state) in gpio_state[f"{mode}s"].items():  # type: ignore
+            for (channel, ch_state) in gpio_state["state"][f"{mode}s"].items():  # type: ignore
                 if not channel.startswith("__"):  # Hide special GPIOs
                     for key in ["online", "state"]:
                         self.__append_prometheus_rows(rows, ch_state["state"], f"pikvm_gpio_{mode}_{key}_{channel}")
 
-        self.__append_prometheus_rows(rows, hw_state["health"], "pikvm_hw")  # type: ignore
-        self.__append_prometheus_rows(rows, fan_state, "pikvm_fan")
+        self.__append_prometheus_rows(rows, info_state["hw"]["health"], "pikvm_hw")  # type: ignore
+        self.__append_prometheus_rows(rows, info_state["fan"], "pikvm_fan")
 
         return "\n".join(rows)
 

kvmd/apps/kvmd/api/hid.py

@@ -25,13 +25,12 @@ import stat
 import functools
 import struct
 
+from typing import Iterable
 from typing import Callable
 
 from aiohttp.web import Request
 from aiohttp.web import Response
 
-from ....mouse import MouseRange
-
 from ....keyboard.keysym import build_symmap
 from ....keyboard.printer import text_to_web_keys
 
@@ -59,12 +58,7 @@ class HidApi:
     def __init__(
         self,
         hid: BaseHid,
-
         keymap_path: str,
-        ignore_keys: list[str],
-
-        mouse_x_range: tuple[int, int],
-        mouse_y_range: tuple[int, int],
     ) -> None:
 
         self.__hid = hid
@@ -73,11 +67,6 @@ class HidApi:
         self.__default_keymap_name = os.path.basename(keymap_path)
         self.__ensure_symmap(self.__default_keymap_name)
 
-        self.__ignore_keys = ignore_keys
-
-        self.__mouse_x_range = mouse_x_range
-        self.__mouse_y_range = mouse_y_range
-
     # =====
 
     @exposed_http("GET", "/hid")
@@ -85,22 +74,22 @@ class HidApi:
         return make_json_response(await self.__hid.get_state())
 
     @exposed_http("POST", "/hid/set_params")
-    async def __set_params_handler(self, request: Request) -> Response:
+    async def __set_params_handler(self, req: Request) -> Response:
         params = {
-            key: validator(request.query.get(key))
+            key: validator(req.query.get(key))
             for (key, validator) in [
                 ("keyboard_output", valid_hid_keyboard_output),
                 ("mouse_output", valid_hid_mouse_output),
                 ("jiggler", valid_bool),
             ]
-            if request.query.get(key) is not None
+            if req.query.get(key) is not None
         }
         self.__hid.set_params(**params)  # type: ignore
         return make_json_response()
 
     @exposed_http("POST", "/hid/set_connected")
-    async def __set_connected_handler(self, request: Request) -> Response:
-        self.__hid.set_connected(valid_bool(request.query.get("connected")))
+    async def __set_connected_handler(self, req: Request) -> Response:
+        self.__hid.set_connected(valid_bool(req.query.get("connected")))
         return make_json_response()
 
     @exposed_http("POST", "/hid/reset")
@@ -128,13 +117,14 @@ class HidApi:
         return make_json_response(await self.get_keymaps())
 
     @exposed_http("POST", "/hid/print")
-    async def __print_handler(self, request: Request) -> Response:
-        text = await request.text()
-        limit = int(valid_int_f0(request.query.get("limit", 1024)))
+    async def __print_handler(self, req: Request) -> Response:
+        text = await req.text()
+        limit = int(valid_int_f0(req.query.get("limit", 1024)))
         if limit > 0:
             text = text[:limit]
-        symmap = self.__ensure_symmap(request.query.get("keymap", self.__default_keymap_name))
-        self.__hid.send_key_events(text_to_web_keys(text, symmap))
+        symmap = self.__ensure_symmap(req.query.get("keymap", self.__default_keymap_name))
+        slow = valid_bool(req.query.get("slow", False))
+        await self.__hid.send_key_events(text_to_web_keys(text, symmap), no_ignore_keys=True, slow=slow)
         return make_json_response()
 
     def __ensure_symmap(self, keymap_name: str) -> dict[int, dict[int, str]]:
@@ -159,17 +149,17 @@ class HidApi:
     async def __ws_bin_key_handler(self, _: WsSession, data: bytes) -> None:
         try:
             key = valid_hid_key(data[1:].decode("ascii"))
-            state = valid_bool(data[0])
+            state = bool(data[0] & 0b01)
+            finish = bool(data[0] & 0b10)
         except Exception:
             return
-        if key not in self.__ignore_keys:
-            self.__hid.send_key_events([(key, state)])
+        self.__hid.send_key_event(key, state, finish)
 
     @exposed_ws(2)
     async def __ws_bin_mouse_button_handler(self, _: WsSession, data: bytes) -> None:
         try:
             button = valid_hid_mouse_button(data[1:].decode("ascii"))
-            state = valid_bool(data[0])
+            state = bool(data[0] & 0b01)
         except Exception:
             return
         self.__hid.send_mouse_button_event(button, state)
@@ -182,19 +172,19 @@ class HidApi:
             to_y = valid_hid_mouse_move(to_y)
         except Exception:
             return
-        self.__send_mouse_move_event(to_x, to_y)
+        self.__hid.send_mouse_move_event(to_x, to_y)
 
     @exposed_ws(4)
     async def __ws_bin_mouse_relative_handler(self, _: WsSession, data: bytes) -> None:
-        self.__process_ws_bin_delta_request(data, self.__hid.send_mouse_relative_event)
+        self.__process_ws_bin_delta_request(data, self.__hid.send_mouse_relative_events)
 
     @exposed_ws(5)
     async def __ws_bin_mouse_wheel_handler(self, _: WsSession, data: bytes) -> None:
-        self.__process_ws_bin_delta_request(data, self.__hid.send_mouse_wheel_event)
+        self.__process_ws_bin_delta_request(data, self.__hid.send_mouse_wheel_events)
 
-    def __process_ws_bin_delta_request(self, data: bytes, handler: Callable[[int, int], None]) -> None:
+    def __process_ws_bin_delta_request(self, data: bytes, handler: Callable[[Iterable[tuple[int, int]], bool], None]) -> None:
         try:
-            squash = valid_bool(data[0])
+            squash = bool(data[0] & 0b01)
             data = data[1:]
             deltas: list[tuple[int, int]] = []
             for index in range(0, len(data), 2):
@@ -202,7 +192,7 @@ class HidApi:
                 deltas.append((valid_hid_mouse_delta(delta_x), valid_hid_mouse_delta(delta_y)))
         except Exception:
             return
-        self.__send_mouse_delta_event(deltas, squash, handler)
+        handler(deltas, squash)
 
     # =====
 
@@ -211,10 +201,10 @@ class HidApi:
         try:
             key = valid_hid_key(event["key"])
             state = valid_bool(event["state"])
+            finish = valid_bool(event.get("finish", False))
         except Exception:
             return
-        if key not in self.__ignore_keys:
-            self.__hid.send_key_events([(key, state)])
+        self.__hid.send_key_event(key, state, finish)
 
     @exposed_ws("mouse_button")
     async def __ws_mouse_button_handler(self, _: WsSession, event: dict) -> None:
@@ -232,17 +222,17 @@ class HidApi:
             to_y = valid_hid_mouse_move(event["to"]["y"])
         except Exception:
             return
-        self.__send_mouse_move_event(to_x, to_y)
+        self.__hid.send_mouse_move_event(to_x, to_y)
 
     @exposed_ws("mouse_relative")
     async def __ws_mouse_relative_handler(self, _: WsSession, event: dict) -> None:
-        self.__process_ws_delta_event(event, self.__hid.send_mouse_relative_event)
+        self.__process_ws_delta_event(event, self.__hid.send_mouse_relative_events)
 
     @exposed_ws("mouse_wheel")
     async def __ws_mouse_wheel_handler(self, _: WsSession, event: dict) -> None:
-        self.__process_ws_delta_event(event, self.__hid.send_mouse_wheel_event)
+        self.__process_ws_delta_event(event, self.__hid.send_mouse_wheel_events)
 
-    def __process_ws_delta_event(self, event: dict, handler: Callable[[int, int], None]) -> None:
+    def __process_ws_delta_event(self, event: dict, handler: Callable[[Iterable[tuple[int, int]], bool], None]) -> None:
         try:
             raw_delta = event["delta"]
             deltas = [
@@ -252,26 +242,26 @@ class HidApi:
             squash = valid_bool(event.get("squash", False))
         except Exception:
             return
-        self.__send_mouse_delta_event(deltas, squash, handler)
+        handler(deltas, squash)
 
     # =====
 
     @exposed_http("POST", "/hid/events/send_key")
-    async def __events_send_key_handler(self, request: Request) -> Response:
-        key = valid_hid_key(request.query.get("key"))
-        if key not in self.__ignore_keys:
-            if "state" in request.query:
-                state = valid_bool(request.query["state"])
-                self.__hid.send_key_events([(key, state)])
-            else:
-                self.__hid.send_key_events([(key, True), (key, False)])
+    async def __events_send_key_handler(self, req: Request) -> Response:
+        key = valid_hid_key(req.query.get("key"))
+        if "state" in req.query:
+            state = valid_bool(req.query["state"])
+            finish = valid_bool(req.query.get("finish", False))
+            self.__hid.send_key_event(key, state, finish)
+        else:
+            self.__hid.send_key_event(key, True, True)
         return make_json_response()
 
     @exposed_http("POST", "/hid/events/send_mouse_button")
-    async def __events_send_mouse_button_handler(self, request: Request) -> Response:
-        button = valid_hid_mouse_button(request.query.get("button"))
-        if "state" in request.query:
-            state = valid_bool(request.query["state"])
+    async def __events_send_mouse_button_handler(self, req: Request) -> Response:
+        button = valid_hid_mouse_button(req.query.get("button"))
+        if "state" in req.query:
+            state = valid_bool(req.query["state"])
             self.__hid.send_mouse_button_event(button, state)
         else:
             self.__hid.send_mouse_button_event(button, True)
@@ -279,52 +269,22 @@ class HidApi:
         return make_json_response()
 
     @exposed_http("POST", "/hid/events/send_mouse_move")
-    async def __events_send_mouse_move_handler(self, request: Request) -> Response:
-        to_x = valid_hid_mouse_move(request.query.get("to_x"))
-        to_y = valid_hid_mouse_move(request.query.get("to_y"))
-        self.__send_mouse_move_event(to_x, to_y)
+    async def __events_send_mouse_move_handler(self, req: Request) -> Response:
+        to_x = valid_hid_mouse_move(req.query.get("to_x"))
+        to_y = valid_hid_mouse_move(req.query.get("to_y"))
+        self.__hid.send_mouse_move_event(to_x, to_y)
         return make_json_response()
 
     @exposed_http("POST", "/hid/events/send_mouse_relative")
-    async def __events_send_mouse_relative_handler(self, request: Request) -> Response:
-        return self.__process_http_delta_event(request, self.__hid.send_mouse_relative_event)
+    async def __events_send_mouse_relative_handler(self, req: Request) -> Response:
+        return self.__process_http_delta_event(req, self.__hid.send_mouse_relative_event)
 
     @exposed_http("POST", "/hid/events/send_mouse_wheel")
-    async def __events_send_mouse_wheel_handler(self, request: Request) -> Response:
-        return self.__process_http_delta_event(request, self.__hid.send_mouse_wheel_event)
+    async def __events_send_mouse_wheel_handler(self, req: Request) -> Response:
+        return self.__process_http_delta_event(req, self.__hid.send_mouse_wheel_event)
 
-    def __process_http_delta_event(self, request: Request, handler: Callable[[int, int], None]) -> Response:
-        delta_x = valid_hid_mouse_delta(request.query.get("delta_x"))
-        delta_y = valid_hid_mouse_delta(request.query.get("delta_y"))
+    def __process_http_delta_event(self, req: Request, handler: Callable[[int, int], None]) -> Response:
+        delta_x = valid_hid_mouse_delta(req.query.get("delta_x"))
+        delta_y = valid_hid_mouse_delta(req.query.get("delta_y"))
         handler(delta_x, delta_y)
         return make_json_response()
-
-    # =====
-
-    def __send_mouse_move_event(self, to_x: int, to_y: int) -> None:
-        if self.__mouse_x_range != MouseRange.RANGE:
-            to_x = MouseRange.remap(to_x, *self.__mouse_x_range)
-        if self.__mouse_y_range != MouseRange.RANGE:
-            to_y = MouseRange.remap(to_y, *self.__mouse_y_range)
-        self.__hid.send_mouse_move_event(to_x, to_y)
-
-    def __send_mouse_delta_event(
-        self,
-        deltas: list[tuple[int, int]],
-        squash: bool,
-        handler: Callable[[int, int], None],
-    ) -> None:
-
-        if squash:
-            prev = (0, 0)
-            for cur in deltas:
-                if abs(prev[0] + cur[0]) > 127 or abs(prev[1] + cur[1]) > 127:
-                    handler(*prev)
-                    prev = cur
-                else:
-                    prev = (prev[0] + cur[0], prev[1] + cur[1])
-            if prev[0] or prev[1]:
-                handler(*prev)
-        else:
-            for xy in deltas:
-                handler(*xy)

kvmd/apps/kvmd/api/info.py

@@ -20,8 +20,6 @@
 # ========================================================================== #
 
 
-import asyncio
-
 from aiohttp.web import Request
 from aiohttp.web import Response
 
@@ -41,17 +39,13 @@ class InfoApi:
     # =====
 
     @exposed_http("GET", "/info")
-    async def __common_state_handler(self, request: Request) -> Response:
-        fields = self.__valid_info_fields(request)
-        results = dict(zip(fields, await asyncio.gather(*[
-            self.__info_manager.get_submanager(field).get_state()
-            for field in fields
-        ])))
-        return make_json_response(results)
+    async def __common_state_handler(self, req: Request) -> Response:
+        fields = self.__valid_info_fields(req)
+        return make_json_response(await self.__info_manager.get_state(fields))
 
-    def __valid_info_fields(self, request: Request) -> list[str]:
-        subs = self.__info_manager.get_subs()
+    def __valid_info_fields(self, req: Request) -> list[str]:
+        available = self.__info_manager.get_subs()
         return sorted(valid_info_fields(
-            arg=request.query.get("fields", ",".join(subs)),
-            variants=subs,
-        ) or subs)
+            arg=req.query.get("fields", ",".join(available)),
+            variants=available,
+        ) or available)

kvmd/apps/kvmd/api/log.py

@@ -3,6 +3,7 @@
 #    KVMD - The main PiKVM daemon.                                           #
 #                                                                            #
 #    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2023-2025  SilentWind <mofeng654321@hotmail.com>          #
 #                                                                            #
 #    This program is free software: you can redistribute it and/or modify    #
 #    it under the terms of the GNU General Public License as published by    #
@@ -19,7 +20,6 @@
 #                                                                            #
 # ========================================================================== #
 
-
 from aiohttp.web import Request
 from aiohttp.web import StreamResponse
 
@@ -47,12 +47,12 @@ class LogApi:
     # =====
 
     @exposed_http("GET", "/log")
-    async def __log_handler(self, request: Request) -> StreamResponse:
+    async def __log_handler(self, req: Request) -> StreamResponse:
         if self.__log_reader is None:
             raise LogReaderDisabledError()
-        seek = valid_log_seek(request.query.get("seek", 0))
-        follow = valid_bool(request.query.get("follow", False))
-        response = await start_streaming(request, "text/plain")
+        seek = valid_log_seek(req.query.get("seek", 0))
+        follow = valid_bool(req.query.get("follow", False))
+        response = await start_streaming(req, "text/plain")
         try:
             async for record in self.__log_reader.poll_log(seek, follow):
                 await response.write(("[%s %s] --- %s" % (

kvmd/apps/kvmd/api/msd.py

@@ -3,6 +3,7 @@
 #    KVMD - The main PiKVM daemon.                                           #
 #                                                                            #
 #    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2023-2025  SilentWind <mofeng654321@hotmail.com>          #
 #                                                                            #
 #    This program is free software: you can redistribute it and/or modify    #
 #    it under the terms of the GNU General Public License as published by    #
@@ -66,29 +67,34 @@ class MsdApi:
         return make_json_response(await self.__msd.get_state())
 
     @exposed_http("POST", "/msd/set_params")
-    async def __set_params_handler(self, request: Request) -> Response:
+    async def __set_params_handler(self, req: Request) -> Response:
         params = {
-            key: validator(request.query.get(param))
+            key: validator(req.query.get(param))
             for (param, key, validator) in [
                 ("image", "name", (lambda arg: str(arg).strip() and valid_msd_image_name(arg))),
                 ("cdrom", "cdrom", valid_bool),
                 ("rw", "rw", valid_bool),
             ]
-            if request.query.get(param) is not None
+            if req.query.get(param) is not None
         }
         await self.__msd.set_params(**params)  # type: ignore
         return make_json_response()
 
     @exposed_http("POST", "/msd/set_connected")
-    async def __set_connected_handler(self, request: Request) -> Response:
-        await self.__msd.set_connected(valid_bool(request.query.get("connected")))
+    async def __set_connected_handler(self, req: Request) -> Response:
+        await self.__msd.set_connected(valid_bool(req.query.get("connected")))
+        return make_json_response()
+    
+    @exposed_http("POST", "/msd/make_image")
+    async def __set_zipped_handler(self, req: Request) -> Response:
+        await self.__msd.make_image(valid_bool(req.query.get("zipped")))
         return make_json_response()
 
     # =====
 
     @exposed_http("GET", "/msd/read")
-    async def __read_handler(self, request: Request) -> StreamResponse:
-        name = valid_msd_image_name(request.query.get("image"))
+    async def __read_handler(self, req: Request) -> StreamResponse:
+        name = valid_msd_image_name(req.query.get("image"))
         compressors = {
             "": ("", None),
             "none": ("", None),
@@ -96,7 +102,7 @@ class MsdApi:
             "zstd": (".zst", (lambda: zstandard.ZstdCompressor().compressobj())),  # pylint: disable=unnecessary-lambda
         }
         (suffix, make_compressor) = compressors[check_string_in_list(
-            arg=request.query.get("compress", ""),
+            arg=req.query.get("compress", ""),
             name="Compression mode",
             variants=set(compressors),
         )]
@@ -127,7 +133,7 @@ class MsdApi:
                 src = compressed()
                 size = -1
 
-            response = await start_streaming(request, "application/octet-stream", size, name + suffix)
+            response = await start_streaming(req, "application/octet-stream", size, name + suffix)
             async for chunk in src:
                 await response.write(chunk)
             return response
@@ -135,28 +141,28 @@ class MsdApi:
     # =====
 
     @exposed_http("POST", "/msd/write")
-    async def __write_handler(self, request: Request) -> Response:
-        unsafe_prefix = request.query.get("prefix", "") + "/"
-        name = valid_msd_image_name(unsafe_prefix + request.query.get("image", ""))
-        size = valid_int_f0(request.content_length)
-        remove_incomplete = self.__get_remove_incomplete(request)
+    async def __write_handler(self, req: Request) -> Response:
+        unsafe_prefix = req.query.get("prefix", "") + "/"
+        name = valid_msd_image_name(unsafe_prefix + req.query.get("image", ""))
+        size = valid_int_f0(req.content_length)
+        remove_incomplete = self.__get_remove_incomplete(req)
         written = 0
         async with self.__msd.write_image(name, size, remove_incomplete) as writer:
             chunk_size = writer.get_chunk_size()
             while True:
-                chunk = await request.content.read(chunk_size)
+                chunk = await req.content.read(chunk_size)
                 if not chunk:
                     break
                 written = await writer.write_chunk(chunk)
         return make_json_response(self.__make_write_info(name, size, written))
 
     @exposed_http("POST", "/msd/write_remote")
-    async def __write_remote_handler(self, request: Request) -> (Response | StreamResponse):  # pylint: disable=too-many-locals
-        unsafe_prefix = request.query.get("prefix", "") + "/"
-        url = valid_url(request.query.get("url"))
-        insecure = valid_bool(request.query.get("insecure", False))
-        timeout = valid_float_f01(request.query.get("timeout", 10.0))
-        remove_incomplete = self.__get_remove_incomplete(request)
+    async def __write_remote_handler(self, req: Request) -> (Response | StreamResponse):  # pylint: disable=too-many-locals
+        unsafe_prefix = req.query.get("prefix", "") + "/"
+        url = valid_url(req.query.get("url"))
+        insecure = valid_bool(req.query.get("insecure", False))
+        timeout = valid_float_f01(req.query.get("timeout", 10.0))
+        remove_incomplete = self.__get_remove_incomplete(req)
 
         name = ""
         size = written = 0
@@ -174,7 +180,7 @@ class MsdApi:
                 read_timeout=(7 * 24 * 3600),
             ) as remote:
 
-                name = str(request.query.get("image", "")).strip()
+                name = str(req.query.get("image", "")).strip()
                 if len(name) == 0:
                     name = htclient.get_filename(remote)
                 name = valid_msd_image_name(unsafe_prefix + name)
@@ -184,7 +190,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(request, "application/x-ndjson")
+                    response = 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):
@@ -197,16 +203,16 @@ class MsdApi:
                 await stream_write_info()
                 return response
 
-        except Exception as err:
+        except Exception as ex:
             if response is not None:
                 await stream_write_info()
-                await stream_json_exception(response, err)
-            elif isinstance(err, aiohttp.ClientError):
-                return make_json_exception(err, 400)
+                await stream_json_exception(response, ex)
+            elif isinstance(ex, aiohttp.ClientError):
+                return make_json_exception(ex, 400)
             raise
 
-    def __get_remove_incomplete(self, request: Request) -> (bool | None):
-        flag: (str | None) = request.query.get("remove_incomplete")
+    def __get_remove_incomplete(self, req: Request) -> (bool | None):
+        flag: (str | None) = req.query.get("remove_incomplete")
         return (valid_bool(flag) if flag is not None else None)
 
     def __make_write_info(self, name: str, size: int, written: int) -> dict:
@@ -215,8 +221,8 @@ class MsdApi:
     # =====
 
     @exposed_http("POST", "/msd/remove")
-    async def __remove_handler(self, request: Request) -> Response:
-        await self.__msd.remove(valid_msd_image_name(request.query.get("image")))
+    async def __remove_handler(self, req: Request) -> Response:
+        await self.__msd.remove(valid_msd_image_name(req.query.get("image")))
         return make_json_response()
 
     @exposed_http("POST", "/msd/reset")

kvmd/apps/kvmd/api/redfish.py

@@ -88,12 +88,12 @@ class RedfishApi:
 
     @exposed_http("GET", "/redfish/v1/Systems/0")
     async def __server_handler(self, _: Request) -> Response:
-        (atx_state, meta_state) = await asyncio.gather(*[
+        (atx_state, info_state) = await asyncio.gather(*[
             self.__atx.get_state(),
-            self.__info_manager.get_submanager("meta").get_state(),
+            self.__info_manager.get_state(["meta"]),
         ])
         try:
-            host = str(meta_state.get("server", {})["host"])  # type: ignore
+            host = str(info_state["meta"].get("server", {})["host"])  # type: ignore
         except Exception:
             host = ""
         return make_json_response({
@@ -111,10 +111,10 @@ class RedfishApi:
         }, wrap_result=False)
 
     @exposed_http("POST", "/redfish/v1/Systems/0/Actions/ComputerSystem.Reset")
-    async def __power_handler(self, request: Request) -> Response:
+    async def __power_handler(self, req: Request) -> Response:
         try:
             action = check_string_in_list(
-                arg=(await request.json())["ResetType"],
+                arg=(await req.json()).get("ResetType"),
                 name="Redfish ResetType",
                 variants=set(self.__actions),
                 lower=False,

kvmd/apps/kvmd/api/streamer.py

@@ -52,36 +52,36 @@ class StreamerApi:
         return make_json_response(await self.__streamer.get_state())
 
     @exposed_http("GET", "/streamer/snapshot")
-    async def __take_snapshot_handler(self, request: Request) -> Response:
+    async def __take_snapshot_handler(self, req: Request) -> Response:
         snapshot = await self.__streamer.take_snapshot(
-            save=valid_bool(request.query.get("save", False)),
-            load=valid_bool(request.query.get("load", False)),
-            allow_offline=valid_bool(request.query.get("allow_offline", False)),
+            save=valid_bool(req.query.get("save", False)),
+            load=valid_bool(req.query.get("load", False)),
+            allow_offline=valid_bool(req.query.get("allow_offline", False)),
         )
         if snapshot:
-            if valid_bool(request.query.get("ocr", False)):
+            if valid_bool(req.query.get("ocr", False)):
                 langs = self.__ocr.get_available_langs()
                 return Response(
                     body=(await self.__ocr.recognize(
                         data=snapshot.data,
                         langs=valid_string_list(
-                            arg=str(request.query.get("ocr_langs", "")).strip(),
+                            arg=str(req.query.get("ocr_langs", "")).strip(),
                             subval=(lambda lang: check_string_in_list(lang, "OCR lang", langs)),
                             name="OCR langs list",
                         ),
-                        left=int(valid_number(request.query.get("ocr_left", -1))),
-                        top=int(valid_number(request.query.get("ocr_top", -1))),
-                        right=int(valid_number(request.query.get("ocr_right", -1))),
-                        bottom=int(valid_number(request.query.get("ocr_bottom", -1))),
+                        left=int(valid_number(req.query.get("ocr_left", -1))),
+                        top=int(valid_number(req.query.get("ocr_top", -1))),
+                        right=int(valid_number(req.query.get("ocr_right", -1))),
+                        bottom=int(valid_number(req.query.get("ocr_bottom", -1))),
                     )),
                     headers=dict(snapshot.headers),
                     content_type="text/plain",
                 )
-            elif valid_bool(request.query.get("preview", False)):
+            elif valid_bool(req.query.get("preview", False)):
                 data = await snapshot.make_preview(
-                    max_width=valid_int_f0(request.query.get("preview_max_width", 0)),
-                    max_height=valid_int_f0(request.query.get("preview_max_height", 0)),
-                    quality=valid_stream_quality(request.query.get("preview_quality", 80)),
+                    max_width=valid_int_f0(req.query.get("preview_max_width", 0)),
+                    max_height=valid_int_f0(req.query.get("preview_max_height", 0)),
+                    quality=valid_stream_quality(req.query.get("preview_quality", 80)),
                 )
             else:
                 data = snapshot.data
@@ -97,25 +97,6 @@ class StreamerApi:
         self.__streamer.remove_snapshot()
         return make_json_response()
 
-    # =====
-
-    async def get_ocr(self) -> dict:  # XXX: Ugly hack
-        enabled = self.__ocr.is_available()
-        default: list[str] = []
-        available: list[str] = []
-        if enabled:
-            default = self.__ocr.get_default_langs()
-            available = self.__ocr.get_available_langs()
-        return {
-            "ocr": {
-                "enabled": enabled,
-                "langs": {
-                    "default": default,
-                    "available": available,
-                },
-            },
-        }
-
     @exposed_http("GET", "/streamer/ocr")
     async def __ocr_handler(self, _: Request) -> Response:
-        return make_json_response(await self.get_ocr())
+        return make_json_response({"ocr": (await self.__ocr.get_state())})

kvmd/apps/kvmd/api/switch.py

@@ -0,0 +1,164 @@
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+from aiohttp.web import Request
+from aiohttp.web import Response
+
+from ....htserver import exposed_http
+from ....htserver import make_json_response
+
+from ....validators.basic import valid_bool
+from ....validators.basic import valid_int_f0
+from ....validators.basic import valid_stripped_string_not_empty
+from ....validators.kvm import valid_atx_power_action
+from ....validators.kvm import valid_atx_button
+from ....validators.switch import valid_switch_port_name
+from ....validators.switch import valid_switch_edid_id
+from ....validators.switch import valid_switch_edid_data
+from ....validators.switch import valid_switch_color
+from ....validators.switch import valid_switch_atx_click_delay
+
+from ..switch import Switch
+from ..switch import Colors
+
+
+# =====
+class SwitchApi:
+    def __init__(self, switch: Switch) -> None:
+        self.__switch = switch
+
+    # =====
+
+    @exposed_http("GET", "/switch")
+    async def __state_handler(self, _: Request) -> Response:
+        return make_json_response(await self.__switch.get_state())
+
+    @exposed_http("POST", "/switch/set_active")
+    async def __set_active_port_handler(self, req: Request) -> Response:
+        port = valid_int_f0(req.query.get("port"))
+        await self.__switch.set_active_port(port)
+        return make_json_response()
+
+    @exposed_http("POST", "/switch/set_beacon")
+    async def __set_beacon_handler(self, req: Request) -> Response:
+        on = valid_bool(req.query.get("state"))
+        if "port" in req.query:
+            port = valid_int_f0(req.query.get("port"))
+            await self.__switch.set_port_beacon(port, on)
+        elif "uplink" in req.query:
+            unit = valid_int_f0(req.query.get("uplink"))
+            await self.__switch.set_uplink_beacon(unit, on)
+        else:  # Downlink
+            unit = valid_int_f0(req.query.get("downlink"))
+            await self.__switch.set_downlink_beacon(unit, on)
+        return make_json_response()
+
+    @exposed_http("POST", "/switch/set_port_params")
+    async def __set_port_params(self, req: Request) -> Response:
+        port = valid_int_f0(req.query.get("port"))
+        params = {
+            param: validator(req.query.get(param))
+            for (param, validator) in [
+                ("edid_id", (lambda arg: valid_switch_edid_id(arg, allow_default=True))),
+                ("name",    valid_switch_port_name),
+                ("atx_click_power_delay",      valid_switch_atx_click_delay),
+                ("atx_click_power_long_delay", valid_switch_atx_click_delay),
+                ("atx_click_reset_delay",      valid_switch_atx_click_delay),
+            ]
+            if req.query.get(param) is not None
+        }
+        await self.__switch.set_port_params(port, **params)  # type: ignore
+        return make_json_response()
+
+    @exposed_http("POST", "/switch/set_colors")
+    async def __set_colors(self, req: Request) -> Response:
+        params = {
+            param: valid_switch_color(req.query.get(param), allow_default=True)
+            for param in Colors.ROLES
+            if req.query.get(param) is not None
+        }
+        await self.__switch.set_colors(**params)
+        return make_json_response()
+
+    # =====
+
+    @exposed_http("POST", "/switch/reset")
+    async def __reset(self, req: Request) -> Response:
+        unit = valid_int_f0(req.query.get("unit"))
+        bootloader = valid_bool(req.query.get("bootloader", False))
+        await self.__switch.reboot_unit(unit, bootloader)
+        return make_json_response()
+
+    # =====
+
+    @exposed_http("POST", "/switch/edids/create")
+    async def __create_edid(self, req: Request) -> Response:
+        name = valid_stripped_string_not_empty(req.query.get("name"))
+        data_hex = valid_switch_edid_data(req.query.get("data"))
+        edid_id = await self.__switch.create_edid(name, data_hex)
+        return make_json_response({"id": edid_id})
+
+    @exposed_http("POST", "/switch/edids/change")
+    async def __change_edid(self, req: Request) -> Response:
+        edid_id = valid_switch_edid_id(req.query.get("id"), allow_default=False)
+        params = {
+            param: validator(req.query.get(param))
+            for (param, validator) in [
+                ("name", valid_switch_port_name),
+                ("data", valid_switch_edid_data),
+            ]
+            if req.query.get(param) is not None
+        }
+        if params:
+            await self.__switch.change_edid(edid_id, **params)
+        return make_json_response()
+
+    @exposed_http("POST", "/switch/edids/remove")
+    async def __remove_edid(self, req: Request) -> Response:
+        edid_id = valid_switch_edid_id(req.query.get("id"), allow_default=False)
+        await self.__switch.remove_edid(edid_id)
+        return make_json_response()
+
+    # =====
+
+    @exposed_http("POST", "/switch/atx/power")
+    async def __power_handler(self, req: Request) -> Response:
+        port = valid_int_f0(req.query.get("port"))
+        action = valid_atx_power_action(req.query.get("action"))
+        await ({
+            "on":         self.__switch.atx_power_on,
+            "off":        self.__switch.atx_power_off,
+            "off_hard":   self.__switch.atx_power_off_hard,
+            "reset_hard": self.__switch.atx_power_reset_hard,
+        }[action])(port)
+        return make_json_response()
+
+    @exposed_http("POST", "/switch/atx/click")
+    async def __click_handler(self, req: Request) -> Response:
+        port = valid_int_f0(req.query.get("port"))
+        button = valid_atx_button(req.query.get("button"))
+        await ({
+            "power":      self.__switch.atx_click_power,
+            "power_long": self.__switch.atx_click_power_long,
+            "reset":      self.__switch.atx_click_reset,
+        }[button])(port)
+        return make_json_response()

kvmd/apps/kvmd/api/ugpio.py

@@ -42,23 +42,20 @@ class UserGpioApi:
 
     @exposed_http("GET", "/gpio")
     async def __state_handler(self, _: Request) -> Response:
-        return make_json_response({
-            "model": (await self.__user_gpio.get_model()),
-            "state": (await self.__user_gpio.get_state()),
-        })
+        return make_json_response(await self.__user_gpio.get_state())
 
     @exposed_http("POST", "/gpio/switch")
-    async def __switch_handler(self, request: Request) -> Response:
-        channel = valid_ugpio_channel(request.query.get("channel"))
-        state = valid_bool(request.query.get("state"))
-        wait = valid_bool(request.query.get("wait", False))
+    async def __switch_handler(self, req: Request) -> Response:
+        channel = valid_ugpio_channel(req.query.get("channel"))
+        state = valid_bool(req.query.get("state"))
+        wait = valid_bool(req.query.get("wait", False))
         await self.__user_gpio.switch(channel, state, wait)
         return make_json_response()
 
     @exposed_http("POST", "/gpio/pulse")
-    async def __pulse_handler(self, request: Request) -> Response:
-        channel = valid_ugpio_channel(request.query.get("channel"))
-        delay = valid_float_f0(request.query.get("delay", 0.0))
-        wait = valid_bool(request.query.get("wait", False))
+    async def __pulse_handler(self, req: Request) -> Response:
+        channel = valid_ugpio_channel(req.query.get("channel"))
+        delay = valid_float_f0(req.query.get("delay", 0.0))
+        wait = valid_bool(req.query.get("wait", False))
         await self.__user_gpio.pulse(channel, delay, wait)
         return make_json_response()

kvmd/apps/kvmd/auth.py

@@ -23,8 +23,6 @@
 import secrets
 import pyotp
 
-from gettext import translation
-
 from ...logging import get_logger
 
 from ... import aiotools
@@ -34,7 +32,6 @@ from ...plugins.auth import get_auth_service_class
 
 from ...htserver import HttpExposed
 
-from ...languages import Languages
 
 # =====
 class AuthManager:
@@ -52,32 +49,31 @@ class AuthManager:
 
         totp_secret_path: str,
     ) -> None:
-        self.gettext=Languages().gettext
+
         self.__enabled = enabled
         if not enabled:
-            get_logger().warning(self.gettext("AUTHORIZATION IS DISABLED"))
+            get_logger().warning("AUTHORIZATION IS DISABLED")
 
         self.__unauth_paths = frozenset(unauth_paths)  # To speed up
         for path in self.__unauth_paths:
-            get_logger().warning(self.gettext("Authorization is disabled for API %r"), path)
+            get_logger().warning("Authorization is disabled for API %r", path)
 
         self.__internal_service: (BaseAuthService | None) = None
         if enabled:
             self.__internal_service = get_auth_service_class(internal_type)(**internal_kwargs)
-            get_logger().info(self.gettext("Using internal auth service %r"), self.__internal_service.get_plugin_name())
+            get_logger().info("Using internal auth service %r", self.__internal_service.get_plugin_name())
 
         self.__force_internal_users = force_internal_users
 
         self.__external_service: (BaseAuthService | None) = None
         if enabled and external_type:
             self.__external_service = get_auth_service_class(external_type)(**external_kwargs)
-            get_logger().info(self.gettext("Using external auth service %r"), self.__external_service.get_plugin_name())
+            get_logger().info("Using external auth service %r", self.__external_service.get_plugin_name())
 
         self.__totp_secret_path = totp_secret_path
 
         self.__tokens: dict[str, str] = {}  # {token: user}
 
-
     def is_auth_enabled(self) -> bool:
         return self.__enabled
 
@@ -99,8 +95,8 @@ class AuthManager:
                 secret = file.read().strip()
             if secret:
                 code = passwd[-6:]
-                if not pyotp.TOTP(secret).verify(code):
-                    get_logger().error(self.gettext("Got access denied for user %r by TOTP"), user)
+                if not pyotp.TOTP(secret).verify(code, valid_window=1):
+                    get_logger().error("Got access denied for user %r by TOTP", user)
                     return False
                 passwd = passwd[:-6]
 
@@ -111,9 +107,9 @@ class AuthManager:
 
         ok = (await service.authorize(user, passwd))
         if ok:
-            get_logger().info(self.gettext("Authorized user %r via auth service %r"), user, service.get_plugin_name())
+            get_logger().info("Authorized user %r via auth service %r", user, service.get_plugin_name())
         else:
-            get_logger().error(self.gettext("Got access denied for user %r from auth service %r"), user, service.get_plugin_name())
+            get_logger().error("Got access denied for user %r from auth service %r", user, service.get_plugin_name())
         return ok
 
     async def login(self, user: str, passwd: str) -> (str | None):
@@ -123,7 +119,7 @@ class AuthManager:
         if (await self.authorize(user, passwd)):
             token = self.__make_new_token()
             self.__tokens[token] = user
-            get_logger().info(self.gettext("Logged in user %r"), user)
+            get_logger().info("Logged in user %r", user)
             return token
         else:
             return None
@@ -133,7 +129,7 @@ class AuthManager:
             token = secrets.token_hex(32)
             if token not in self.__tokens:
                 return token
-        raise AssertionError(self.gettext("Can't generate new unique token"))
+        raise AssertionError("Can't generate new unique token")
 
     def logout(self, token: str) -> None:
         assert self.__enabled
@@ -144,7 +140,7 @@ class AuthManager:
                 if r_user == user:
                     count += 1
                     del self.__tokens[r_token]
-            get_logger().info(self.gettext("Logged out user %r (%d)"), user, count)
+            get_logger().info("Logged out user %r (%d)", user, count)
 
     def check(self, token: str) -> (str | None):
         assert self.__enabled

kvmd/apps/kvmd/info/__init__.py

@@ -20,6 +20,10 @@
 # ========================================================================== #
 
 
+import asyncio
+
+from typing import AsyncGenerator
+
 from ....yamlconf import Section
 
 from .base import BaseInfoSubmanager
@@ -34,17 +38,59 @@ from .fan import FanInfoSubmanager
 # =====
 class InfoManager:
     def __init__(self, config: Section) -> None:
-        self.__subs = {
+        self.__subs: dict[str, BaseInfoSubmanager] = {
             "system": SystemInfoSubmanager(config.kvmd.streamer.cmd),
-            "auth": AuthInfoSubmanager(config.kvmd.auth.enabled),
-            "meta": MetaInfoSubmanager(config.kvmd.info.meta),
+            "auth":   AuthInfoSubmanager(config.kvmd.auth.enabled),
+            "meta":   MetaInfoSubmanager(config.kvmd.info.meta),
             "extras": ExtrasInfoSubmanager(config),
-            "hw": HwInfoSubmanager(**config.kvmd.info.hw._unpack()),
-            "fan": FanInfoSubmanager(**config.kvmd.info.fan._unpack()),
+            "hw":     HwInfoSubmanager(**config.kvmd.info.hw._unpack()),
+            "fan":    FanInfoSubmanager(**config.kvmd.info.fan._unpack()),
         }
+        self.__queue: "asyncio.Queue[tuple[str, (dict | None)]]" = asyncio.Queue()
 
     def get_subs(self) -> set[str]:
         return set(self.__subs)
 
-    def get_submanager(self, name: str) -> BaseInfoSubmanager:
-        return self.__subs[name]
+    async def get_state(self, fields: (list[str] | None)=None) -> dict:
+        fields = (fields or list(self.__subs))
+        return dict(zip(fields, await asyncio.gather(*[
+            self.__subs[field].get_state()
+            for field in fields
+        ])))
+
+    async def trigger_state(self) -> None:
+        await asyncio.gather(*[
+            sub.trigger_state()
+            for sub in self.__subs.values()
+        ])
+
+    async def poll_state(self) -> AsyncGenerator[dict, None]:
+        # ==== Granularity table ====
+        #   - system -- Partial
+        #   - auth   -- Partial
+        #   - meta   -- Partial, nullable
+        #   - extras -- Partial, nullable
+        #   - hw     -- Partial
+        #   - fan    -- Partial
+        # ===========================
+
+        while True:
+            (field, value) = await self.__queue.get()
+            yield {field: value}
+
+    async def systask(self) -> None:
+        tasks = [
+            asyncio.create_task(self.__poller(field))
+            for field in self.__subs
+        ]
+        try:
+            await asyncio.gather(*tasks)
+        except Exception:
+            for task in tasks:
+                task.cancel()
+            await asyncio.gather(*tasks, return_exceptions=True)
+            raise
+
+    async def __poller(self, field: str) -> None:
+        async for state in self.__subs[field].poll_state():
+            self.__queue.put_nowait((field, state))

kvmd/apps/kvmd/info/auth.py

@@ -20,6 +20,10 @@
 # ========================================================================== #
 
 
+from typing import AsyncGenerator
+
+from .... import aiotools
+
 from .base import BaseInfoSubmanager
 
 
@@ -27,6 +31,15 @@ from .base import BaseInfoSubmanager
 class AuthInfoSubmanager(BaseInfoSubmanager):
     def __init__(self, enabled: bool) -> None:
         self.__enabled = enabled
+        self.__notifier = aiotools.AioNotifier()
 
     async def get_state(self) -> dict:
         return {"enabled": self.__enabled}
+
+    async def trigger_state(self) -> None:
+        self.__notifier.notify()
+
+    async def poll_state(self) -> AsyncGenerator[(dict | None), None]:
+        while True:
+            await self.__notifier.wait()
+            yield (await self.get_state())

kvmd/apps/kvmd/info/base.py

@@ -20,7 +20,17 @@
 # ========================================================================== #
 
 
+from typing import AsyncGenerator
+
+
 # =====
 class BaseInfoSubmanager:
     async def get_state(self) -> (dict | None):
         raise NotImplementedError
+
+    async def trigger_state(self) -> None:
+        raise NotImplementedError
+
+    async def poll_state(self) -> AsyncGenerator[(dict | None), None]:
+        yield None
+        raise NotImplementedError

kvmd/apps/kvmd/info/extras.py

@@ -3,6 +3,7 @@
 #    KVMD - The main PiKVM daemon.                                           #
 #                                                                            #
 #    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2023-2025  SilentWind <mofeng654321@hotmail.com>          #
 #                                                                            #
 #    This program is free software: you can redistribute it and/or modify    #
 #    it under the terms of the GNU General Public License as published by    #
@@ -24,6 +25,8 @@ import os
 import re
 import asyncio
 
+from typing import AsyncGenerator
+
 from ....logging import get_logger
 
 from ....yamlconf import Section
@@ -42,13 +45,15 @@ from .base import BaseInfoSubmanager
 class ExtrasInfoSubmanager(BaseInfoSubmanager):
     def __init__(self, global_config: Section) -> None:
         self.__global_config = global_config
+        self.__notifier = aiotools.AioNotifier()
 
     async def get_state(self) -> (dict | None):
         try:
             sui = sysunit.SystemdUnitInfo()
             await sui.open()
-        except Exception as err:
-            get_logger(0).error("Can't open systemd bus to get extras state: %s", tools.efmt(err))
+        except Exception as ex:
+            if not os.path.exists("/etc/kvmd/.docker_flag"):
+                get_logger(0).error("Can't open systemd bus to get extras state: %s", tools.efmt(ex))
             sui = None
         try:
             extras: dict[str, dict] = {}
@@ -66,6 +71,14 @@ class ExtrasInfoSubmanager(BaseInfoSubmanager):
             if sui is not None:
                 await aiotools.shield_fg(sui.close())
 
+    async def trigger_state(self) -> None:
+        self.__notifier.notify()
+
+    async def poll_state(self) -> AsyncGenerator[(dict | None), None]:
+        while True:
+            await self.__notifier.wait()
+            yield (await self.get_state())
+
     def __get_extras_path(self, *parts: str) -> str:
         return os.path.join(self.__global_config.kvmd.info.extras, *parts)
 

kvmd/apps/kvmd/info/fan.py

@@ -21,7 +21,6 @@
 
 
 import copy
-import asyncio
 
 from typing import AsyncGenerator
 
@@ -53,6 +52,8 @@ class FanInfoSubmanager(BaseInfoSubmanager):
         self.__timeout = timeout
         self.__state_poll = state_poll
 
+        self.__notifier = aiotools.AioNotifier()
+
     async def get_state(self) -> dict:
         monitored = await self.__get_monitored()
         return {
@@ -60,24 +61,28 @@ class FanInfoSubmanager(BaseInfoSubmanager):
             "state": ((await self.__get_fan_state() if monitored else None)),
         }
 
-    async def poll_state(self) -> AsyncGenerator[dict, None]:
-        prev_state: dict = {}
+    async def trigger_state(self) -> None:
+        self.__notifier.notify(1)
+
+    async def poll_state(self) -> AsyncGenerator[(dict | None), None]:
+        prev: dict = {}
         while True:
             if self.__unix_path:
-                pure = state = await self.get_state()
+                if (await self.__notifier.wait(timeout=self.__state_poll)) > 0:
+                    prev = {}
+                new = await self.get_state()
+                pure = copy.deepcopy(new)
                 if pure["state"] is not None:
                     try:
-                        pure = copy.deepcopy(state)
                         pure["state"]["service"]["now_ts"] = 0
                     except Exception:
                         pass
-                if pure != prev_state:
-                    yield state
-                    prev_state = pure
-                await asyncio.sleep(self.__state_poll)
+                if pure != prev:
+                    prev = pure
+                    yield new
             else:
+                await self.__notifier.wait()
                 yield (await self.get_state())
-                await aiotools.wait_infinite()
 
     # =====
 
@@ -87,8 +92,8 @@ class FanInfoSubmanager(BaseInfoSubmanager):
                 async with sysunit.SystemdUnitInfo() as sui:
                     status = await sui.get_status(self.__daemon)
                     return (status[0] or status[1])
-            except Exception as err:
-                get_logger(0).error("Can't get info about the service %r: %s", self.__daemon, tools.efmt(err))
+            except Exception as ex:
+                get_logger(0).error("Can't get info about the service %r: %s", self.__daemon, tools.efmt(ex))
         return False
 
     async def __get_fan_state(self) -> (dict | None):
@@ -97,8 +102,8 @@ class FanInfoSubmanager(BaseInfoSubmanager):
                 async with session.get("http://localhost/state") as response:
                     htclient.raise_not_200(response)
                     return (await response.json())["result"]
-        except Exception as err:
-            get_logger(0).error("Can't read fan state: %s", err)
+        except Exception as ex:
+            get_logger(0).error("Can't read fan state: %s", ex)
             return None
 
     def __make_http_session(self) -> aiohttp.ClientSession:

kvmd/apps/kvmd/info/hw.py

@@ -22,6 +22,7 @@
 
 import os
 import asyncio
+import copy
 
 from typing import Callable
 from typing import AsyncGenerator
@@ -60,6 +61,8 @@ class HwInfoSubmanager(BaseInfoSubmanager):
 
         self.__dt_cache: dict[str, str] = {}
 
+        self.__notifier = aiotools.AioNotifier()
+
     async def get_state(self) -> dict:
         (
             base,
@@ -70,8 +73,8 @@ class HwInfoSubmanager(BaseInfoSubmanager):
             cpu_temp,
             mem,
         ) = await asyncio.gather(
-            self.__read_dt_file("model"),
-            self.__read_dt_file("serial-number"),
+            self.__read_dt_file("model", upper=False),
+            self.__read_dt_file("serial-number", upper=True),
             self.__read_platform_file(),
             self.__get_throttling(),
             self.__get_cpu_percent(),
@@ -97,18 +100,22 @@ class HwInfoSubmanager(BaseInfoSubmanager):
             },
         }
 
+    async def trigger_state(self) -> None:
+        self.__notifier.notify(1)
+
     async def poll_state(self) -> AsyncGenerator[dict, None]:
-        prev_state: dict = {}
+        prev: dict = {}
         while True:
-            state = await self.get_state()
-            if state != prev_state:
-                yield state
-                prev_state = state
-            await asyncio.sleep(self.__state_poll)
+            if (await self.__notifier.wait(timeout=self.__state_poll)) > 0:
+                prev = {}
+            new = await self.get_state()
+            if new != prev:
+                prev = copy.deepcopy(new)
+                yield new
 
     # =====
 
-    async def __read_dt_file(self, name: str) -> (str | None):
+    async def __read_dt_file(self, name: str, upper: bool) -> (str | None):
         if name not in self.__dt_cache:
             path = os.path.join(f"{env.PROCFS_PREFIX}/proc/device-tree", name)
             if not os.path.exists(path):
@@ -161,8 +168,8 @@ class HwInfoSubmanager(BaseInfoSubmanager):
                 + system_all / total * 100
                 + (st.steal + st.guest) / total * 100
             )
-        except Exception as err:
-            get_logger(0).error("Can't get CPU percent: %s", err)
+        except Exception as ex:
+            get_logger(0).error("Can't get CPU percent: %s", ex)
             return None
 
     async def __get_mem(self) -> dict:
@@ -173,8 +180,8 @@ class HwInfoSubmanager(BaseInfoSubmanager):
                 "total": st.total,
                 "available": st.available,
             }
-        except Exception as err:
-            get_logger(0).error("Can't get memory info: %s", err)
+        except Exception as ex:
+            get_logger(0).error("Can't get memory info: %s", ex)
             return {
                 "percent": None,
                 "total": None,
@@ -217,6 +224,6 @@ class HwInfoSubmanager(BaseInfoSubmanager):
             return None
         try:
             return parser(text)
-        except Exception as err:
-            get_logger(0).error("Can't parse [ %s ] output: %r: %s", tools.cmdfmt(cmd), text, tools.efmt(err))
+        except Exception as ex:
+            get_logger(0).error("Can't parse [ %s ] output: %r: %s", tools.cmdfmt(cmd), text, tools.efmt(ex))
             return None

kvmd/apps/kvmd/info/meta.py

@@ -20,6 +20,8 @@
 # ========================================================================== #
 
 
+from typing import AsyncGenerator
+
 from ....logging import get_logger
 
 from ....yamlconf.loader import load_yaml_file
@@ -33,6 +35,7 @@ from .base import BaseInfoSubmanager
 class MetaInfoSubmanager(BaseInfoSubmanager):
     def __init__(self, meta_path: str) -> None:
         self.__meta_path = meta_path
+        self.__notifier = aiotools.AioNotifier()
 
     async def get_state(self) -> (dict | None):
         try:
@@ -40,3 +43,11 @@ class MetaInfoSubmanager(BaseInfoSubmanager):
         except Exception:
             get_logger(0).exception("Can't parse meta")
         return None
+
+    async def trigger_state(self) -> None:
+        self.__notifier.notify()
+
+    async def poll_state(self) -> AsyncGenerator[(dict | None), None]:
+        while True:
+            await self.__notifier.wait()
+            yield (await self.get_state())

kvmd/apps/kvmd/info/system.py

@@ -24,8 +24,11 @@ import os
 import asyncio
 import platform
 
+from typing import AsyncGenerator
+
 from ....logging import get_logger
 
+from .... import aiotools
 from .... import aioproc
 
 from .... import __version__
@@ -37,6 +40,7 @@ from .base import BaseInfoSubmanager
 class SystemInfoSubmanager(BaseInfoSubmanager):
     def __init__(self, streamer_cmd: list[str]) -> None:
         self.__streamer_cmd = streamer_cmd
+        self.__notifier = aiotools.AioNotifier()
 
     async def get_state(self) -> dict:
         streamer_info = await self.__get_streamer_info()
@@ -50,6 +54,14 @@ class SystemInfoSubmanager(BaseInfoSubmanager):
             },
         }
 
+    async def trigger_state(self) -> None:
+        self.__notifier.notify()
+
+    async def poll_state(self) -> AsyncGenerator[(dict | None), None]:
+        while True:
+            await self.__notifier.wait()
+            yield (await self.get_state())
+
     # =====
 
     async def __get_streamer_info(self) -> dict:

kvmd/apps/kvmd/logreader.py

@@ -3,6 +3,7 @@
 #    KVMD - The main PiKVM daemon.                                           #
 #                                                                            #
 #    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2023-2025  SilentWind <mofeng654321@hotmail.com>          #
 #                                                                            #
 #    This program is free software: you can redistribute it and/or modify    #
 #    it under the terms of the GNU General Public License as published by    #
@@ -30,17 +31,12 @@ from xmlrpc.client import ServerProxy
 
 from ...logging import get_logger
 
+us_systemd_journal = True
 try:
     import systemd.journal
-except ImportError as e:
-    get_logger(0).error("Failed to import module: %s", "systemd.journal")
-    us_systemd_journal = False
-
-try:
+except ImportError:
     import supervisor.xmlrpc
-except ImportError as e:
-    get_logger(0).info("Failed to import module: %s", "supervisor.xmlrpc")
-    us_systemd_journal = True
+    us_systemd_journal = False
 
 
 # =====

kvmd/apps/kvmd/ocr.py

@@ -37,6 +37,7 @@ from ctypes import c_void_p
 from ctypes import c_char
 
 from typing import Generator
+from typing import AsyncGenerator
 
 from PIL import ImageOps
 from PIL import Image as PilImage
@@ -76,8 +77,8 @@ def _load_libtesseract() -> (ctypes.CDLL | None):
             setattr(func, "restype", restype)
             setattr(func, "argtypes", argtypes)
         return lib
-    except Exception as err:
-        warnings.warn(f"Can't load libtesseract: {err}", RuntimeWarning)
+    except Exception as ex:
+        warnings.warn(f"Can't load libtesseract: {ex}", RuntimeWarning)
         return None
 
 
@@ -107,9 +108,37 @@ class Ocr:
     def __init__(self, data_dir_path: str, default_langs: list[str]) -> None:
         self.__data_dir_path = data_dir_path
         self.__default_langs = default_langs
+        self.__notifier = aiotools.AioNotifier()
 
-    def is_available(self) -> bool:
-        return bool(_libtess)
+    async def get_state(self) -> dict:
+        enabled = bool(_libtess)
+        default: list[str] = []
+        available: list[str] = []
+        if enabled:
+            default = self.get_default_langs()
+            available = self.get_available_langs()
+        return {
+            "enabled": enabled,
+            "langs": {
+                "default": default,
+                "available": available,
+            },
+        }
+
+    async def trigger_state(self) -> None:
+        self.__notifier.notify()
+
+    async def poll_state(self) -> AsyncGenerator[dict, None]:
+        # ===== Granularity table =====
+        #   - enabled -- Full
+        #   - langs   -- Partial
+        # =============================
+
+        while True:
+            await self.__notifier.wait()
+            yield (await self.get_state())
+
+    # =====
 
     def get_default_langs(self) -> list[str]:
         return list(self.__default_langs)

kvmd/apps/kvmd/server.py

@@ -20,8 +20,6 @@
 # ========================================================================== #
 
 
-import asyncio
-import operator
 import dataclasses
 
 from typing import Callable
@@ -33,7 +31,7 @@ from aiohttp.web import Request
 from aiohttp.web import Response
 from aiohttp.web import WebSocketResponse
 
-from ...languages import Languages
+from ... import __version__
 
 from ...logging import get_logger
 
@@ -68,6 +66,7 @@ from .ugpio import UserGpio
 from .streamer import Streamer
 from .snapshoter import Snapshoter
 from .ocr import Ocr
+from .switch import Switch
 
 from .api.auth import AuthApi
 from .api.auth import check_request_auth
@@ -79,6 +78,7 @@ from .api.hid import HidApi
 from .api.atx import AtxApi
 from .api.msd import MsdApi
 from .api.streamer import StreamerApi
+from .api.switch import SwitchApi
 from .api.export import ExportApi
 from .api.redfish import RedfishApi
 
@@ -86,68 +86,61 @@ from .api.redfish import RedfishApi
 # =====
 class StreamerQualityNotSupported(OperationError):
     def __init__(self) -> None:
-        super().__init__(Languages().gettext("This streamer does not support quality settings"))
+        super().__init__("This streamer does not support quality settings")
 
 
 class StreamerResolutionNotSupported(OperationError):
     def __init__(self) -> None:
-        super().__init__(Languages().gettext("This streamer does not support resolution settings"))
+        super().__init__("This streamer does not support resolution settings")
 
 
 class StreamerH264NotSupported(OperationError):
     def __init__(self) -> None:
-        super().__init__(Languages().gettext("This streamer does not support H264"))
+        super().__init__("This streamer does not support H264")
 
 
 # =====
-@dataclasses.dataclass(frozen=True)
-class _SubsystemEventSource:
-    get_state:  (Callable[[], Coroutine[Any, Any, dict]] | None) = None
-    poll_state: (Callable[[], AsyncGenerator[dict, None]] | None) = None
-
-
 @dataclasses.dataclass
 class _Subsystem:
-    name:    str
-    sysprep: (Callable[[], None] | None)
-    systask: (Callable[[], Coroutine[Any, Any, None]] | None)
-    cleanup: (Callable[[], Coroutine[Any, Any, dict]] | None)
-    sources: dict[str, _SubsystemEventSource]
+    name:          str
+    event_type:    str
+    sysprep:       (Callable[[], None] | None)
+    systask:       (Callable[[], Coroutine[Any, Any, None]] | None)
+    cleanup:       (Callable[[], Coroutine[Any, Any, dict]] | None)
+    trigger_state: (Callable[[], Coroutine[Any, Any, None]] | None) = None
+    poll_state:    (Callable[[], AsyncGenerator[dict, None]] | None) = None
+
+    def __post_init__(self) -> None:
+        if self.event_type:
+            assert self.trigger_state
+            assert self.poll_state
 
     @classmethod
     def make(cls, obj: object, name: str, event_type: str="") -> "_Subsystem":
         if isinstance(obj, BasePlugin):
             name = f"{name} ({obj.get_plugin_name()})"
-        sub = _Subsystem(
+        return _Subsystem(
             name=name,
+            event_type=event_type,
             sysprep=getattr(obj, "sysprep", None),
             systask=getattr(obj, "systask", None),
             cleanup=getattr(obj, "cleanup", None),
-            sources={},
+            trigger_state=getattr(obj, "trigger_state", None),
+            poll_state=getattr(obj, "poll_state", None),
         )
-        if event_type:
-            sub.add_source(
-                event_type=event_type,
-                get_state=getattr(obj, "get_state", None),
-                poll_state=getattr(obj, "poll_state", None),
-            )
-        return sub
-
-    def add_source(
-        self,
-        event_type: str,
-        get_state: (Callable[[], Coroutine[Any, Any, dict]] | None),
-        poll_state: (Callable[[], AsyncGenerator[dict, None]] | None),
-    ) -> "_Subsystem":
-
-        assert event_type
-        assert event_type not in self.sources, (self, event_type)
-        assert get_state or poll_state, (self, event_type)
-        self.sources[event_type] = _SubsystemEventSource(get_state, poll_state)
-        return self
 
 
 class KvmdServer(HttpServer):  # pylint: disable=too-many-arguments,too-many-instance-attributes
+    __EV_GPIO_STATE = "gpio"
+    __EV_HID_STATE = "hid"
+    __EV_HID_KEYMAPS_STATE = "hid_keymaps"  # FIXME
+    __EV_ATX_STATE = "atx"
+    __EV_MSD_STATE = "msd"
+    __EV_STREAMER_STATE = "streamer"
+    __EV_OCR_STATE = "ocr"
+    __EV_INFO_STATE = "info"
+    __EV_SWITCH_STATE = "switch"
+
     def __init__(  # pylint: disable=too-many-arguments,too-many-locals
         self,
         auth_manager: AuthManager,
@@ -155,6 +148,7 @@ class KvmdServer(HttpServer):  # pylint: disable=too-many-arguments,too-many-ins
         log_reader: (LogReader | None),
         user_gpio: UserGpio,
         ocr: Ocr,
+        switch: Switch,
 
         hid: BaseHid,
         atx: BaseAtx,
@@ -163,9 +157,6 @@ class KvmdServer(HttpServer):  # pylint: disable=too-many-arguments,too-many-ins
         snapshoter: Snapshoter,
 
         keymap_path: str,
-        ignore_keys: list[str],
-        mouse_x_range: tuple[int, int],
-        mouse_y_range: tuple[int, int],
 
         stream_forever: bool,
     ) -> None:
@@ -179,8 +170,7 @@ class KvmdServer(HttpServer):  # pylint: disable=too-many-arguments,too-many-ins
 
         self.__stream_forever = stream_forever
 
-        self.__hid_api = HidApi(hid, keymap_path, ignore_keys, mouse_x_range, mouse_y_range)  # Ugly hack to get keymaps state
-        self.__streamer_api = StreamerApi(streamer, ocr)  # Same hack to get ocr langs state
+        self.__hid_api = HidApi(hid, keymap_path)  # Ugly hack to get keymaps state
         self.__apis: list[object] = [
             self,
             AuthApi(auth_manager),
@@ -190,43 +180,40 @@ class KvmdServer(HttpServer):  # pylint: disable=too-many-arguments,too-many-ins
             self.__hid_api,
             AtxApi(atx),
             MsdApi(msd),
-            self.__streamer_api,
+            StreamerApi(streamer, ocr),
+            SwitchApi(switch),
             ExportApi(info_manager, atx, user_gpio),
             RedfishApi(info_manager, atx),
         ]
-
         self.__subsystems = [
             _Subsystem.make(auth_manager, "Auth manager"),
-            _Subsystem.make(user_gpio,    "User-GPIO", "gpio_state").add_source("gpio_model_state", user_gpio.get_model, None),
-            _Subsystem.make(hid,          "HID",       "hid_state").add_source("hid_keymaps_state", self.__hid_api.get_keymaps, None),
-            _Subsystem.make(atx,          "ATX",       "atx_state"),
-            _Subsystem.make(msd,          "MSD",       "msd_state"),
-            _Subsystem.make(streamer,     "Streamer",  "streamer_state").add_source("streamer_ocr_state", self.__streamer_api.get_ocr, None),
-            *[
-                _Subsystem.make(info_manager.get_submanager(sub), f"Info manager ({sub})", f"info_{sub}_state",)
-                for sub in sorted(info_manager.get_subs())
-            ],
+            _Subsystem.make(user_gpio,    "User-GPIO",    self.__EV_GPIO_STATE),
+            _Subsystem.make(hid,          "HID",          self.__EV_HID_STATE),
+            _Subsystem.make(atx,          "ATX",          self.__EV_ATX_STATE),
+            _Subsystem.make(msd,          "MSD",          self.__EV_MSD_STATE),
+            _Subsystem.make(streamer,     "Streamer",     self.__EV_STREAMER_STATE),
+            _Subsystem.make(ocr,          "OCR",          self.__EV_OCR_STATE),
+            _Subsystem.make(info_manager, "Info manager", self.__EV_INFO_STATE),
+            _Subsystem.make(switch,       "Switch",       self.__EV_SWITCH_STATE),
         ]
 
         self.__streamer_notifier = aiotools.AioNotifier()
         self.__reset_streamer = False
         self.__new_streamer_params: dict = {}
 
-        self.gettext=Languages().gettext
-
     # ===== STREAMER CONTROLLER
 
     @exposed_http("POST", "/streamer/set_params")
-    async def __streamer_set_params_handler(self, request: Request) -> Response:
+    async def __streamer_set_params_handler(self, req: Request) -> Response:
         current_params = self.__streamer.get_params()
         for (name, validator, exc_cls) in [
-            ("quality", valid_stream_quality, StreamerQualityNotSupported),
-            ("desired_fps", valid_stream_fps, None),
-            ("resolution", valid_stream_resolution, StreamerResolutionNotSupported),
+            ("quality",      valid_stream_quality,      StreamerQualityNotSupported),
+            ("desired_fps",  valid_stream_fps,          None),
+            ("resolution",   valid_stream_resolution,   StreamerResolutionNotSupported),
             ("h264_bitrate", valid_stream_h264_bitrate, StreamerH264NotSupported),
-            ("h264_gop", valid_stream_h264_gop, StreamerH264NotSupported),
+            ("h264_gop",     valid_stream_h264_gop,     StreamerH264NotSupported),
         ]:
-            value = request.query.get(name)
+            value = req.query.get(name)
             if value:
                 if name not in current_params:
                     assert exc_cls is not None, name
@@ -246,24 +233,21 @@ class KvmdServer(HttpServer):  # pylint: disable=too-many-arguments,too-many-ins
     # ===== WEBSOCKET
 
     @exposed_http("GET", "/ws")
-    async def __ws_handler(self, request: Request) -> WebSocketResponse:
-        stream = valid_bool(request.query.get("stream", True))
-        async with self._ws_session(request, stream=stream) as ws:
-            states = [
-                (event_type, src.get_state())
-                for sub in self.__subsystems
-                for (event_type, src) in sub.sources.items()
-                if src.get_state
-            ]
-            events = dict(zip(
-                map(operator.itemgetter(0), states),
-                await asyncio.gather(*map(operator.itemgetter(1), states)),
-            ))
-            await asyncio.gather(*[
-                ws.send_event(event_type, events.pop(event_type))
-                for (event_type, _) in states
-            ])
-            await ws.send_event("loop", {})
+    async def __ws_handler(self, req: Request) -> WebSocketResponse:
+        stream = valid_bool(req.query.get("stream", True))
+        async with self._ws_session(req, stream=stream) as ws:
+            (major, minor) = __version__.split(".")
+            await ws.send_event("loop", {
+                "version": {
+                    "major": int(major),
+                    "minor": int(minor),
+                },
+            })
+            for sub in self.__subsystems:
+                if sub.event_type:
+                    assert sub.trigger_state
+                    await sub.trigger_state()
+            await self._broadcast_ws_event(self.__EV_HID_KEYMAPS_STATE, await self.__hid_api.get_keymaps())  # FIXME
             return (await self._ws_loop(ws))
 
     @exposed_ws("ping")
@@ -279,45 +263,45 @@ class KvmdServer(HttpServer):  # pylint: disable=too-many-arguments,too-many-ins
         aioproc.rename_process("main")
         super().run(**kwargs)
 
-    async def _check_request_auth(self, exposed: HttpExposed, request: Request) -> None:
-        await check_request_auth(self.__auth_manager, exposed, request)
+    async def _check_request_auth(self, exposed: HttpExposed, req: Request) -> None:
+        await check_request_auth(self.__auth_manager, exposed, req)
 
     async def _init_app(self) -> None:
         aiotools.create_deadly_task("Stream controller", self.__stream_controller())
         for sub in self.__subsystems:
             if sub.systask:
                 aiotools.create_deadly_task(sub.name, sub.systask())
-            for (event_type, src) in sub.sources.items():
-                if src.poll_state:
-                    aiotools.create_deadly_task(f"{sub.name} [poller]", self.__poll_state(event_type, src.poll_state()))
+            if sub.event_type:
+                assert sub.poll_state
+                aiotools.create_deadly_task(f"{sub.name} [poller]", self.__poll_state(sub.event_type, sub.poll_state()))
         aiotools.create_deadly_task("Stream snapshoter", self.__stream_snapshoter())
         self._add_exposed(*self.__apis)
 
     async def _on_shutdown(self) -> None:
         logger = get_logger(0)
-        logger.info(self.gettext("Waiting short tasks ..."))
+        logger.info("Waiting short tasks ...")
         await aiotools.wait_all_short_tasks()
-        logger.info(self.gettext("Stopping system tasks ..."))
+        logger.info("Stopping system tasks ...")
         await aiotools.stop_all_deadly_tasks()
-        logger.info(self.gettext("Disconnecting clients ..."))
+        logger.info("Disconnecting clients ...")
         await self._close_all_wss()
-        logger.info(self.gettext("On-Shutdown complete"))
+        logger.info("On-Shutdown complete")
 
     async def _on_cleanup(self) -> None:
         logger = get_logger(0)
         for sub in self.__subsystems:
             if sub.cleanup:
-                logger.info(self.gettext("Cleaning up %s ..."), sub.name)
+                logger.info("Cleaning up %s ...", sub.name)
                 try:
                     await sub.cleanup()  # type: ignore
                 except Exception:
-                    logger.exception(self.gettext("Cleanup error on %s"), sub.name)
-        logger.info(self.gettext("On-Cleanup complete"))
+                    logger.exception("Cleanup error on %s", sub.name)
+        logger.info("On-Cleanup complete")
 
-    async def _on_ws_opened(self) -> None:
+    async def _on_ws_opened(self, _: WsSession) -> None:
         self.__streamer_notifier.notify()
 
-    async def _on_ws_closed(self) -> None:
+    async def _on_ws_closed(self, _: WsSession) -> None:
         self.__hid.clear_events()
         self.__streamer_notifier.notify()
 
@@ -351,12 +335,12 @@ class KvmdServer(HttpServer):  # pylint: disable=too-many-arguments,too-many-ins
             prev = cur
             await self.__streamer_notifier.wait()
 
-    async def __poll_state(self, event_type: str, poller: AsyncGenerator[dict, None]) -> None:
-        async for state in poller:
-            await self._broadcast_ws_event(event_type, state)
-
     async def __stream_snapshoter(self) -> None:
         await self.__snapshoter.run(
             is_live=self.__has_stream_clients,
             notifier=self.__streamer_notifier,
         )
+
+    async def __poll_state(self, event_type: str, poller: AsyncGenerator[dict, None]) -> None:
+        async for state in poller:
+            await self._broadcast_ws_event(event_type, state)

kvmd/apps/kvmd/snapshoter.py

@@ -123,10 +123,10 @@ class Snapshoter:  # pylint: disable=too-many-instance-attributes
 
         if self.__wakeup_key:
             logger.info("Waking up using key %r ...", self.__wakeup_key)
-            self.__hid.send_key_events([
-                (self.__wakeup_key, True),
-                (self.__wakeup_key, False),
-            ])
+            await self.__hid.send_key_events(
+                keys=[(self.__wakeup_key, True), (self.__wakeup_key, False)],
+                no_ignore_keys=True,
+            )
 
         if self.__wakeup_move:
             logger.info("Waking up using mouse move for %d units ...", self.__wakeup_move)

kvmd/apps/kvmd/streamer.py

@@ -20,24 +20,23 @@
 # ========================================================================== #
 
 
-import io
 import signal
 import asyncio
 import asyncio.subprocess
 import dataclasses
-import functools
+import copy
 
 from typing import AsyncGenerator
 from typing import Any
 
 import aiohttp
 
-from PIL import Image as PilImage
-
-from ...languages import Languages
-
 from ...logging import get_logger
 
+from ...clients.streamer import StreamerSnapshot
+from ...clients.streamer import HttpStreamerClient
+from ...clients.streamer import HttpStreamerClientSession
+
 from ... import tools
 from ... import aiotools
 from ... import aioproc
@@ -45,40 +44,6 @@ from ... import htclient
 
 
 # =====
-@dataclasses.dataclass(frozen=True)
-class StreamerSnapshot:
-    online: bool
-    width: int
-    height: int
-    headers: tuple[tuple[str, str], ...]
-    data: bytes
-
-    async def make_preview(self, max_width: int, max_height: int, quality: int) -> bytes:
-        assert max_width >= 0
-        assert max_height >= 0
-        assert quality > 0
-
-        if max_width == 0 and max_height == 0:
-            max_width = self.width // 5
-            max_height = self.height // 5
-        else:
-            max_width = min((max_width or self.width), self.width)
-            max_height = min((max_height or self.height), self.height)
-
-        if (max_width, max_height) == (self.width, self.height):
-            return self.data
-        return (await aiotools.run_async(self.__inner_make_preview, max_width, max_height, quality))
-
-    @functools.lru_cache(maxsize=1)
-    def __inner_make_preview(self, max_width: int, max_height: int, quality: int) -> bytes:
-        with io.BytesIO(self.data) as snapshot_bio:
-            with io.BytesIO() as preview_bio:
-                with PilImage.open(snapshot_bio) as image:
-                    image.thumbnail((max_width, max_height), PilImage.Resampling.LANCZOS)
-                    image.save(preview_bio, format="jpeg", quality=quality)
-                    return preview_bio.getvalue()
-
-
 class _StreamerParams:
     __DESIRED_FPS = "desired_fps"
 
@@ -138,7 +103,7 @@ class _StreamerParams:
         }
 
     def get_limits(self) -> dict:
-        limits = dict(self.__limits)
+        limits = copy.deepcopy(self.__limits)
         if self.__has_resolution:
             limits[self.__AVAILABLE_RESOLUTIONS] = list(limits[self.__AVAILABLE_RESOLUTIONS])
         return limits
@@ -172,6 +137,11 @@ class _StreamerParams:
 
 
 class Streamer:  # pylint: disable=too-many-instance-attributes
+    __ST_FULL     = 0xFF
+    __ST_PARAMS   = 0x01
+    __ST_STREAMER = 0x02
+    __ST_SNAPSHOT = 0x04
+
     def __init__(  # pylint: disable=too-many-arguments,too-many-locals
         self,
 
@@ -205,7 +175,6 @@ class Streamer:  # pylint: disable=too-many-instance-attributes
         self.__state_poll = state_poll
 
         self.__unix_path = unix_path
-        self.__timeout = timeout
         self.__snapshot_timeout = snapshot_timeout
 
         self.__process_name_prefix = process_name_prefix
@@ -222,15 +191,18 @@ class Streamer:  # pylint: disable=too-many-instance-attributes
         self.__streamer_task: (asyncio.Task | None) = None
         self.__streamer_proc: (asyncio.subprocess.Process | None) = None  # pylint: disable=no-member
 
-        self.__http_session: (aiohttp.ClientSession | None) = None
+        self.__client = HttpStreamerClient(
+            name="jpeg",
+            unix_path=self.__unix_path,
+            timeout=timeout,
+            user_agent=htclient.make_user_agent("KVMD"),
+        )
+        self.__client_session: (HttpStreamerClientSession | None) = None
 
         self.__snapshot: (StreamerSnapshot | None) = None
 
         self.__notifier = aiotools.AioNotifier()
 
-        self.gettext=Languages().gettext
-
-
     # =====
 
     @aiotools.atomic_fg
@@ -242,15 +214,15 @@ class Streamer:  # pylint: disable=too-many-instance-attributes
                 if not self.__stop_wip:
                     self.__stop_task.cancel()
                     await asyncio.gather(self.__stop_task, return_exceptions=True)
-                    logger.info(self.gettext("Streamer stop cancelled"))
+                    logger.info("Streamer stop cancelled")
                     return
                 else:
                     await asyncio.gather(self.__stop_task, return_exceptions=True)
 
             if reset and self.__reset_delay > 0:
-                logger.info(self.gettext("Waiting %.2f seconds for reset delay ..."), self.__reset_delay)
+                logger.info("Waiting %.2f seconds for reset delay ...", self.__reset_delay)
                 await asyncio.sleep(self.__reset_delay)
-            logger.info(self.gettext("Starting streamer ..."))
+            logger.info("Starting streamer ...")
             await self.__inner_start()
 
     @aiotools.atomic_fg
@@ -263,12 +235,12 @@ class Streamer:  # pylint: disable=too-many-instance-attributes
                     if not self.__stop_wip:
                         self.__stop_task.cancel()
                         await asyncio.gather(self.__stop_task, return_exceptions=True)
-                        logger.info(self.gettext("Stopping streamer immediately ..."))
+                        logger.info("Stopping streamer immediately ...")
                         await self.__inner_stop()
                     else:
                         await asyncio.gather(self.__stop_task, return_exceptions=True)
                 else:
-                    logger.info(self.gettext("Stopping streamer immediately ..."))
+                    logger.info("Stopping streamer immediately ...")
                     await self.__inner_stop()
 
             elif not self.__stop_task:
@@ -277,13 +249,13 @@ class Streamer:  # pylint: disable=too-many-instance-attributes
                     try:
                         await asyncio.sleep(self.__shutdown_delay)
                         self.__stop_wip = True
-                        logger.info(self.gettext("Stopping streamer after delay ..."))
+                        logger.info("Stopping streamer after delay ...")
                         await self.__inner_stop()
                     finally:
                         self.__stop_task = None
                         self.__stop_wip = False
 
-                logger.info(self.gettext("Planning to stop streamer in %.2f seconds ..."), self.__shutdown_delay)
+                logger.info("Planning to stop streamer in %.2f seconds ...", self.__shutdown_delay)
                 self.__stop_task = asyncio.create_task(delayed_stop())
 
     def is_working(self) -> bool:
@@ -294,6 +266,7 @@ class Streamer:  # pylint: disable=too-many-instance-attributes
 
     def set_params(self, params: dict) -> None:
         assert not self.__streamer_task
+        self.__notifier.notify(self.__ST_PARAMS)
         return self.__params.set_params(params)
 
     def get_params(self) -> dict:
@@ -302,55 +275,80 @@ class Streamer:  # pylint: disable=too-many-instance-attributes
     # =====
 
     async def get_state(self) -> dict:
-        streamer_state = None
+        return {
+            "features": self.__params.get_features(),
+            "limits": self.__params.get_limits(),
+            "params": self.__params.get_params(),
+            "streamer": (await self.__get_streamer_state()),
+            "snapshot": self.__get_snapshot_state(),
+        }
+
+    async def trigger_state(self) -> None:
+        self.__notifier.notify(self.__ST_FULL)
+
+    async def poll_state(self) -> AsyncGenerator[dict, None]:
+        # ==== Granularity table ====
+        #   - features -- Full
+        #   - limits   -- Partial, paired with params
+        #   - params   -- Partial, paired with limits
+        #   - streamer -- Partial, nullable
+        #   - snapshot -- Partial
+        # ===========================
+
+        def signal_handler(*_: Any) -> None:
+            get_logger(0).info("Got SIGUSR2, checking the stream state ...")
+            self.__notifier.notify(self.__ST_STREAMER)
+
+        get_logger(0).info("Installing SIGUSR2 streamer handler ...")
+        asyncio.get_event_loop().add_signal_handler(signal.SIGUSR2, signal_handler)
+
+        prev: dict = {}
+        while True:
+            new: dict = {}
+
+            mask = await self.__notifier.wait(timeout=self.__state_poll)
+            if mask == self.__ST_FULL:
+                new = await self.get_state()
+                prev = copy.deepcopy(new)
+                yield new
+                continue
+
+            if mask < 0:
+                mask = self.__ST_STREAMER
+
+            def check_update(key: str, value: (dict | None)) -> None:
+                if prev.get(key) != value:
+                    new[key] = value
+
+            if mask & self.__ST_PARAMS:
+                check_update("params", self.__params.get_params())
+            if mask & self.__ST_STREAMER:
+                check_update("streamer", await self.__get_streamer_state())
+            if mask & self.__ST_SNAPSHOT:
+                check_update("snapshot", self.__get_snapshot_state())
+
+            if new and prev != new:
+                prev.update(copy.deepcopy(new))
+                yield new
+
+    async def __get_streamer_state(self) -> (dict | None):
         if self.__streamer_task:
-            session = self.__ensure_http_session()
+            session = self.__ensure_client_session()
             try:
-                async with session.get(self.__make_url("state")) as response:
-                    htclient.raise_not_200(response)
-                    streamer_state = (await response.json())["result"]
+                return (await session.get_state())
             except (aiohttp.ClientConnectionError, aiohttp.ServerConnectionError):
                 pass
             except Exception:
-                get_logger().exception(self.gettext("Invalid streamer response from /state"))
+                get_logger().exception("Invalid streamer response from /state")
+        return None
 
-        snapshot: (dict | None) = None
+    def __get_snapshot_state(self) -> dict:
         if self.__snapshot:
             snapshot = dataclasses.asdict(self.__snapshot)
             del snapshot["headers"]
             del snapshot["data"]
-
-        return {
-            "limits": self.__params.get_limits(),
-            "params": self.__params.get_params(),
-            "snapshot": {"saved": snapshot},
-            "streamer": streamer_state,
-            "features": self.__params.get_features(),
-        }
-
-    async def poll_state(self) -> AsyncGenerator[dict, None]:
-        def signal_handler(*_: Any) -> None:
-            get_logger(0).info(self.gettext("Got SIGUSR2, checking the stream state ..."))
-            self.__notifier.notify()
-
-        get_logger(0).info(self.gettext("Installing SIGUSR2 streamer handler ..."))
-        asyncio.get_event_loop().add_signal_handler(signal.SIGUSR2, signal_handler)
-
-        waiter_task: (asyncio.Task | None) = None
-        prev_state: dict = {}
-        while True:
-            state = await self.get_state()
-            if state != prev_state:
-                yield state
-                prev_state = state
-
-            if waiter_task is None:
-                waiter_task = asyncio.create_task(self.__notifier.wait())
-            if waiter_task in (await aiotools.wait_first(
-                asyncio.ensure_future(asyncio.sleep(self.__state_poll)),
-                waiter_task,
-            ))[0]:
-                waiter_task = None
+            return {"saved": snapshot}
+        return {"saved": None}
 
     # =====
 
@@ -358,43 +356,19 @@ class Streamer:  # pylint: disable=too-many-instance-attributes
         if load:
             return self.__snapshot
         logger = get_logger()
-        session = self.__ensure_http_session()
+        session = self.__ensure_client_session()
         try:
-            async with session.get(
-                self.__make_url("snapshot"),
-                timeout=self.__snapshot_timeout,
-            ) as response:
-
-                htclient.raise_not_200(response)
-                online = (response.headers["X-UStreamer-Online"] == "true")
-                if online or allow_offline:
-                    snapshot = StreamerSnapshot(
-                        online=online,
-                        width=int(response.headers["X-UStreamer-Width"]),
-                        height=int(response.headers["X-UStreamer-Height"]),
-                        headers=tuple(
-                            (key, value)
-                            for (key, value) in tools.sorted_kvs(dict(response.headers))
-                            if key.lower().startswith("x-ustreamer-") or key.lower() in [
-                                "x-timestamp",
-                                "access-control-allow-origin",
-                                "cache-control",
-                                "pragma",
-                                "expires",
-                            ]
-                        ),
-                        data=bytes(await response.read()),
-                    )
-                    if save:
-                        self.__snapshot = snapshot
-                        self.__notifier.notify()
-                    return snapshot
-                logger.error(self.gettext("Stream is offline, no signal or so"))
-
-        except (aiohttp.ClientConnectionError, aiohttp.ServerConnectionError) as err:
-            logger.error(self.gettext("Can't connect to streamer: %s"), tools.efmt(err))
+            snapshot = await session.take_snapshot(self.__snapshot_timeout)
+            if snapshot.online or allow_offline:
+                if save:
+                    self.__snapshot = snapshot
+                    self.__notifier.notify(self.__ST_SNAPSHOT)
+                return snapshot
+            logger.error("Stream is offline, no signal or so")
+        except (aiohttp.ClientConnectionError, aiohttp.ServerConnectionError) as ex:
+            logger.error("Can't connect to streamer: %s", tools.efmt(ex))
         except Exception:
-            logger.exception(self.gettext("Invalid streamer response from /snapshot"))
+            logger.exception("Invalid streamer response from /snapshot")
         return None
 
     def remove_snapshot(self) -> None:
@@ -405,25 +379,14 @@ class Streamer:  # pylint: disable=too-many-instance-attributes
     @aiotools.atomic_fg
     async def cleanup(self) -> None:
         await self.ensure_stop(immediately=True)
-        if self.__http_session:
-            await self.__http_session.close()
-            self.__http_session = None
+        if self.__client_session:
+            await self.__client_session.close()
+            self.__client_session = None
 
-    # =====
-
-    def __ensure_http_session(self) -> aiohttp.ClientSession:
-        if not self.__http_session:
-            kwargs: dict = {
-                "headers": {"User-Agent": htclient.make_user_agent("KVMD")},
-                "connector": aiohttp.UnixConnector(path=self.__unix_path),
-                "timeout": aiohttp.ClientTimeout(total=self.__timeout),
-            }
-            self.__http_session = aiohttp.ClientSession(**kwargs)
-        return self.__http_session
-
-    def __make_url(self, handle: str) -> str:
-        assert not handle.startswith("/"), handle
-        return f"http://localhost:0/{handle}"
+    def __ensure_client_session(self) -> HttpStreamerClientSession:
+        if not self.__client_session:
+            self.__client_session = self.__client.make_session()
+        return self.__client_session
 
     # =====
 
@@ -451,14 +414,14 @@ class Streamer:  # pylint: disable=too-many-instance-attributes
                 await self.__start_streamer_proc()
                 assert self.__streamer_proc is not None
                 await aioproc.log_stdout_infinite(self.__streamer_proc, logger)
-                raise RuntimeError(self.gettext("Streamer unexpectedly died"))
+                raise RuntimeError("Streamer unexpectedly died")
             except asyncio.CancelledError:
                 break
             except Exception:
                 if self.__streamer_proc:
-                    logger.exception(self.gettext("Unexpected streamer error: pid=%d"), self.__streamer_proc.pid)
+                    logger.exception("Unexpected streamer error: pid=%d", self.__streamer_proc.pid)
                 else:
-                    logger.exception(self.gettext("Can't start streamer"))
+                    logger.exception("Can't start streamer")
                 await self.__kill_streamer_proc()
                 await asyncio.sleep(1)
 
@@ -478,14 +441,14 @@ class Streamer:  # pylint: disable=too-many-instance-attributes
         logger.info("%s: %s", name, tools.cmdfmt(cmd))
         try:
             await aioproc.log_process(cmd, logger, prefix=name)
-        except Exception as err:
-            logger.exception(self.gettext("Can't execute command: %s"), err)
+        except Exception as ex:
+            logger.exception("Can't execute command: %s", ex)
 
     async def __start_streamer_proc(self) -> None:
         assert self.__streamer_proc is None
         cmd = self.__make_cmd(self.__cmd)
         self.__streamer_proc = await aioproc.run_process(cmd)
-        get_logger(0).info(self.gettext("Started streamer pid=%d: %s"), self.__streamer_proc.pid, tools.cmdfmt(cmd))
+        get_logger(0).info("Started streamer pid=%d: %s", self.__streamer_proc.pid, tools.cmdfmt(cmd))
 
     async def __kill_streamer_proc(self) -> None:
         if self.__streamer_proc:

kvmd/apps/kvmd/switch/__init__.py

@@ -0,0 +1,400 @@
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+import os
+import asyncio
+
+from typing import AsyncGenerator
+
+from .lib import OperationError
+from .lib import get_logger
+from .lib import aiotools
+from .lib import Inotify
+
+from .types import Edid
+from .types import Edids
+from .types import Color
+from .types import Colors
+from .types import PortNames
+from .types import AtxClickPowerDelays
+from .types import AtxClickPowerLongDelays
+from .types import AtxClickResetDelays
+
+from .chain import DeviceFoundEvent
+from .chain import ChainTruncatedEvent
+from .chain import PortActivatedEvent
+from .chain import UnitStateEvent
+from .chain import UnitAtxLedsEvent
+from .chain import Chain
+
+from .state import StateCache
+
+from .storage import Storage
+
+
+# =====
+class SwitchError(Exception):
+    pass
+
+
+class SwitchOperationError(OperationError, SwitchError):
+    pass
+
+
+class SwitchUnknownEdidError(SwitchOperationError):
+    def __init__(self) -> None:
+        super().__init__("No specified EDID ID found")
+
+
+# =====
+class Switch:  # pylint: disable=too-many-public-methods
+    __X_EDIDS          = "edids"
+    __X_COLORS         = "colors"
+    __X_PORT_NAMES     = "port_names"
+    __X_ATX_CP_DELAYS  = "atx_cp_delays"
+    __X_ATX_CPL_DELAYS = "atx_cpl_delays"
+    __X_ATX_CR_DELAYS  = "atx_cr_delays"
+
+    __X_ALL = frozenset([
+        __X_EDIDS, __X_COLORS, __X_PORT_NAMES,
+        __X_ATX_CP_DELAYS, __X_ATX_CPL_DELAYS, __X_ATX_CR_DELAYS,
+    ])
+
+    def __init__(
+        self,
+        device_path: str,
+        default_edid_path: str,
+        pst_unix_path: str,
+    ) -> None:
+
+        self.__default_edid_path = default_edid_path
+
+        self.__chain = Chain(device_path)
+        self.__cache = StateCache()
+        self.__storage = Storage(pst_unix_path)
+
+        self.__lock = asyncio.Lock()
+
+        self.__save_notifier = aiotools.AioNotifier()
+
+    # =====
+
+    def __x_set_edids(self, edids: Edids, save: bool=True) -> None:
+        self.__chain.set_edids(edids)
+        self.__cache.set_edids(edids)
+        if save:
+            self.__save_notifier.notify()
+
+    def __x_set_colors(self, colors: Colors, save: bool=True) -> None:
+        self.__chain.set_colors(colors)
+        self.__cache.set_colors(colors)
+        if save:
+            self.__save_notifier.notify()
+
+    def __x_set_port_names(self, port_names: PortNames, save: bool=True) -> None:
+        self.__cache.set_port_names(port_names)
+        if save:
+            self.__save_notifier.notify()
+
+    def __x_set_atx_cp_delays(self, delays: AtxClickPowerDelays, save: bool=True) -> None:
+        self.__cache.set_atx_cp_delays(delays)
+        if save:
+            self.__save_notifier.notify()
+
+    def __x_set_atx_cpl_delays(self, delays: AtxClickPowerLongDelays, save: bool=True) -> None:
+        self.__cache.set_atx_cpl_delays(delays)
+        if save:
+            self.__save_notifier.notify()
+
+    def __x_set_atx_cr_delays(self, delays: AtxClickResetDelays, save: bool=True) -> None:
+        self.__cache.set_atx_cr_delays(delays)
+        if save:
+            self.__save_notifier.notify()
+
+    # =====
+
+    async def set_active_port(self, port: int) -> None:
+        self.__chain.set_active_port(port)
+
+    # =====
+
+    async def set_port_beacon(self, port: int, on: bool) -> None:
+        self.__chain.set_port_beacon(port, on)
+
+    async def set_uplink_beacon(self, unit: int, on: bool) -> None:
+        self.__chain.set_uplink_beacon(unit, on)
+
+    async def set_downlink_beacon(self, unit: int, on: bool) -> None:
+        self.__chain.set_downlink_beacon(unit, on)
+
+    # =====
+
+    async def atx_power_on(self, port: int) -> None:
+        self.__inner_atx_cp(port, False, self.__X_ATX_CP_DELAYS)
+
+    async def atx_power_off(self, port: int) -> None:
+        self.__inner_atx_cp(port, True, self.__X_ATX_CP_DELAYS)
+
+    async def atx_power_off_hard(self, port: int) -> None:
+        self.__inner_atx_cp(port, True, self.__X_ATX_CPL_DELAYS)
+
+    async def atx_power_reset_hard(self, port: int) -> None:
+        self.__inner_atx_cr(port, True)
+
+    async def atx_click_power(self, port: int) -> None:
+        self.__inner_atx_cp(port, None, self.__X_ATX_CP_DELAYS)
+
+    async def atx_click_power_long(self, port: int) -> None:
+        self.__inner_atx_cp(port, None, self.__X_ATX_CPL_DELAYS)
+
+    async def atx_click_reset(self, port: int) -> None:
+        self.__inner_atx_cr(port, None)
+
+    def __inner_atx_cp(self, port: int, if_powered: (bool | None), x_delay: str) -> None:
+        assert x_delay in [self.__X_ATX_CP_DELAYS, self.__X_ATX_CPL_DELAYS]
+        delay = getattr(self.__cache, f"get_{x_delay}")()[port]
+        self.__chain.click_power(port, delay, if_powered)
+
+    def __inner_atx_cr(self, port: int, if_powered: (bool | None)) -> None:
+        delay = self.__cache.get_atx_cr_delays()[port]
+        self.__chain.click_reset(port, delay, if_powered)
+
+    # =====
+
+    async def create_edid(self, name: str, data_hex: str) -> str:
+        async with self.__lock:
+            edids = self.__cache.get_edids()
+            edid_id = edids.add(Edid.from_data(name, data_hex))
+            self.__x_set_edids(edids)
+        return edid_id
+
+    async def change_edid(
+        self,
+        edid_id: str,
+        name: (str | None)=None,
+        data_hex: (str | None)=None,
+    ) -> None:
+
+        assert edid_id != Edids.DEFAULT_ID
+        async with self.__lock:
+            edids = self.__cache.get_edids()
+            if not edids.has_id(edid_id):
+                raise SwitchUnknownEdidError()
+            old = edids.get(edid_id)
+            name = (name or old.name)
+            data_hex = (data_hex or old.as_text())
+            edids.set(edid_id, Edid.from_data(name, data_hex))
+            self.__x_set_edids(edids)
+
+    async def remove_edid(self, edid_id: str) -> None:
+        assert edid_id != Edids.DEFAULT_ID
+        async with self.__lock:
+            edids = self.__cache.get_edids()
+            if not edids.has_id(edid_id):
+                raise SwitchUnknownEdidError()
+            edids.remove(edid_id)
+            self.__x_set_edids(edids)
+
+    # =====
+
+    async def set_colors(self, **values: str) -> None:
+        async with self.__lock:
+            old = self.__cache.get_colors()
+            new = {}
+            for role in Colors.ROLES:
+                if role in values:
+                    if values[role] != "default":
+                        new[role] = Color.from_text(values[role])
+                    # else reset to default
+                else:
+                    new[role] = getattr(old, role)
+            self.__x_set_colors(Colors(**new))  # type: ignore
+
+    # =====
+
+    async def set_port_params(
+        self,
+        port: int,
+        edid_id: (str | None)=None,
+        name: (str | None)=None,
+        atx_click_power_delay: (float | None)=None,
+        atx_click_power_long_delay: (float | None)=None,
+        atx_click_reset_delay: (float | None)=None,
+    ) -> None:
+
+        async with self.__lock:
+            if edid_id is not None:
+                edids = self.__cache.get_edids()
+                if not edids.has_id(edid_id):
+                    raise SwitchUnknownEdidError()
+                edids.assign(port, edid_id)
+                self.__x_set_edids(edids)
+
+            for (key, value) in [
+                (self.__X_PORT_NAMES,     name),
+                (self.__X_ATX_CP_DELAYS,  atx_click_power_delay),
+                (self.__X_ATX_CPL_DELAYS, atx_click_power_long_delay),
+                (self.__X_ATX_CR_DELAYS,  atx_click_reset_delay),
+            ]:
+                if value is not None:
+                    new = getattr(self.__cache, f"get_{key}")()
+                    new[port] = (value or None)  # None == reset to default
+                    getattr(self, f"_Switch__x_set_{key}")(new)
+
+    # =====
+
+    async def reboot_unit(self, unit: int, bootloader: bool) -> None:
+        self.__chain.reboot_unit(unit, bootloader)
+
+    # =====
+
+    async def get_state(self) -> dict:
+        return self.__cache.get_state()
+
+    async def trigger_state(self) -> None:
+        await self.__cache.trigger_state()
+
+    async def poll_state(self) -> AsyncGenerator[dict, None]:
+        async for state in self.__cache.poll_state():
+            yield state
+
+    # =====
+
+    async def systask(self) -> None:
+        tasks = [
+            asyncio.create_task(self.__systask_events()),
+            asyncio.create_task(self.__systask_default_edid()),
+            asyncio.create_task(self.__systask_storage()),
+        ]
+        try:
+            await asyncio.gather(*tasks)
+        except Exception:
+            for task in tasks:
+                task.cancel()
+            await asyncio.gather(*tasks, return_exceptions=True)
+            raise
+
+    async def __systask_events(self) -> None:
+        async for event in self.__chain.poll_events():
+            match event:
+                case DeviceFoundEvent():
+                    await self.__load_configs()
+                case ChainTruncatedEvent():
+                    self.__cache.truncate(event.units)
+                case PortActivatedEvent():
+                    self.__cache.update_active_port(event.port)
+                case UnitStateEvent():
+                    self.__cache.update_unit_state(event.unit, event.state)
+                case UnitAtxLedsEvent():
+                    self.__cache.update_unit_atx_leds(event.unit, event.atx_leds)
+
+    async def __load_configs(self) -> None:
+        async with self.__lock:
+            try:
+                async with self.__storage.readable() as ctx:
+                    values = {
+                        key: await getattr(ctx, f"read_{key}")()
+                        for key in self.__X_ALL
+                    }
+                    data_hex = await aiotools.read_file(self.__default_edid_path)
+                    values["edids"].set_default(data_hex)
+            except Exception:
+                get_logger(0).exception("Can't load configs")
+            else:
+                for (key, value) in values.items():
+                    func = getattr(self, f"_Switch__x_set_{key}")
+                    if isinstance(value, tuple):
+                        func(*value, save=False)
+                    else:
+                        func(value, save=False)
+                self.__chain.set_actual(True)
+
+    async def __systask_default_edid(self) -> None:
+        logger = get_logger(0)
+        async for _ in self.__poll_default_edid():
+            async with self.__lock:
+                edids = self.__cache.get_edids()
+                try:
+                    data_hex = await aiotools.read_file(self.__default_edid_path)
+                    edids.set_default(data_hex)
+                except Exception:
+                    logger.exception("Can't read default EDID, ignoring ...")
+                else:
+                    self.__x_set_edids(edids, save=False)
+
+    async def __poll_default_edid(self) -> AsyncGenerator[None, None]:
+        logger = get_logger(0)
+        while True:
+            while not os.path.exists(self.__default_edid_path):
+                await asyncio.sleep(5)
+            try:
+                with Inotify() as inotify:
+                    await inotify.watch_all_changes(self.__default_edid_path)
+                    if os.path.islink(self.__default_edid_path):
+                        await inotify.watch_all_changes(os.path.realpath(self.__default_edid_path))
+                    yield None
+                    while True:
+                        need_restart = False
+                        need_notify = False
+                        for event in (await inotify.get_series(timeout=1)):
+                            need_notify = True
+                            if event.restart:
+                                logger.warning("Got fatal inotify event: %s; reinitializing ...", event)
+                                need_restart = True
+                                break
+                        if need_restart:
+                            break
+                        if need_notify:
+                            yield None
+            except Exception:
+                logger.exception("Unexpected watcher error")
+                await asyncio.sleep(1)
+
+    async def __systask_storage(self) -> None:
+        # При остановке KVMD можем не успеть записать, ну да пофиг
+        prevs = dict.fromkeys(self.__X_ALL)
+        while True:
+            await self.__save_notifier.wait()
+            while (await self.__save_notifier.wait(5)):
+                pass
+            while True:
+                try:
+                    async with self.__lock:
+                        write = {
+                            key: new
+                            for (key, old) in prevs.items()
+                            if (new := getattr(self.__cache, f"get_{key}")()) != old
+                        }
+                        if write:
+                            async with self.__storage.writable() as ctx:
+                                for (key, new) in write.items():
+                                    func = getattr(ctx, f"write_{key}")
+                                    if isinstance(new, tuple):
+                                        await func(*new)
+                                    else:
+                                        await func(new)
+                                    prevs[key] = new
+                except Exception:
+                    get_logger(0).exception("Unexpected storage error")
+                    await asyncio.sleep(5)
+                else:
+                    break

kvmd/apps/kvmd/switch/chain.py

@@ -0,0 +1,440 @@
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+import multiprocessing
+import queue
+import select
+import dataclasses
+import time
+
+from typing import AsyncGenerator
+
+from .lib import get_logger
+from .lib import tools
+from .lib import aiotools
+from .lib import aioproc
+
+from .types import Edids
+from .types import Colors
+
+from .proto import Response
+from .proto import UnitState
+from .proto import UnitAtxLeds
+
+from .device import Device
+from .device import DeviceError
+
+
+# =====
+class _BaseCmd:
+    pass
+
+
+@dataclasses.dataclass(frozen=True)
+class _CmdSetActual(_BaseCmd):
+    actual: bool
+
+
+@dataclasses.dataclass(frozen=True)
+class _CmdSetActivePort(_BaseCmd):
+    port: int
+
+    def __post_init__(self) -> None:
+        assert self.port >= 0
+
+
+@dataclasses.dataclass(frozen=True)
+class _CmdSetPortBeacon(_BaseCmd):
+    port: int
+    on:   bool
+
+
+@dataclasses.dataclass(frozen=True)
+class _CmdSetUnitBeacon(_BaseCmd):
+    unit:     int
+    on:       bool
+    downlink: bool
+
+
+@dataclasses.dataclass(frozen=True)
+class _CmdSetEdids(_BaseCmd):
+    edids: Edids
+
+
+@dataclasses.dataclass(frozen=True)
+class _CmdSetColors(_BaseCmd):
+    colors: Colors
+
+
+@dataclasses.dataclass(frozen=True)
+class _CmdAtxClick(_BaseCmd):
+    port:       int
+    delay:      float
+    reset:      bool
+    if_powered: (bool | None)
+
+    def __post_init__(self) -> None:
+        assert self.port >= 0
+        assert 0.001 <= self.delay <= (0xFFFF / 1000)
+
+
+@dataclasses.dataclass(frozen=True)
+class _CmdRebootUnit(_BaseCmd):
+    unit:       int
+    bootloader: bool
+
+    def __post_init__(self) -> None:
+        assert self.unit >= 0
+
+
+class _UnitContext:
+    __TIMEOUT = 5.0
+
+    def __init__(self) -> None:
+        self.state:    (UnitState | None) = None
+        self.atx_leds: (UnitAtxLeds | None) = None
+        self.__rid = -1
+        self.__deadline_ts = -1.0
+
+    def can_be_changed(self) -> bool:
+        return (
+            self.state is not None
+            and not self.state.flags.changing_busy
+            and self.changing_rid < 0
+        )
+
+    # =====
+
+    @property
+    def changing_rid(self) -> int:
+        if self.__deadline_ts >= 0 and self.__deadline_ts < time.monotonic():
+            self.__rid = -1
+            self.__deadline_ts = -1
+        return self.__rid
+
+    @changing_rid.setter
+    def changing_rid(self, rid: int) -> None:
+        self.__rid = rid
+        self.__deadline_ts = ((time.monotonic() + self.__TIMEOUT) if rid >= 0 else -1)
+
+    # =====
+
+    def is_atx_allowed(self, ch: int) -> tuple[bool, bool]:  # (allowed, power_led)
+        if self.state is None or self.atx_leds is None:
+            return (False, False)
+        return ((not self.state.atx_busy[ch]), self.atx_leds.power[ch])
+
+
+# =====
+class BaseEvent:
+    pass
+
+
+class DeviceFoundEvent(BaseEvent):
+    pass
+
+
+@dataclasses.dataclass(frozen=True)
+class ChainTruncatedEvent(BaseEvent):
+    units: int
+
+
+@dataclasses.dataclass(frozen=True)
+class PortActivatedEvent(BaseEvent):
+    port: int
+
+
+@dataclasses.dataclass(frozen=True)
+class UnitStateEvent(BaseEvent):
+    unit: int
+    state: UnitState
+
+
+@dataclasses.dataclass(frozen=True)
+class UnitAtxLedsEvent(BaseEvent):
+    unit: int
+    atx_leds: UnitAtxLeds
+
+
+# =====
+class Chain:  # pylint: disable=too-many-instance-attributes
+    def __init__(self, device_path: str) -> None:
+        self.__device = Device(device_path)
+
+        self.__actual = False
+
+        self.__edids = Edids()
+
+        self.__colors = Colors()
+
+        self.__units: list[_UnitContext] = []
+        self.__active_port = -1
+
+        self.__cmd_queue: "multiprocessing.Queue[_BaseCmd]" = multiprocessing.Queue()
+        self.__events_queue: "multiprocessing.Queue[BaseEvent]" = multiprocessing.Queue()
+
+        self.__stop_event = multiprocessing.Event()
+
+    def set_actual(self, actual: bool) -> None:
+        # Флаг разрешения синхронизации EDID и прочих чувствительных вещей
+        self.__queue_cmd(_CmdSetActual(actual))
+
+    # =====
+
+    def set_active_port(self, port: int) -> None:
+        self.__queue_cmd(_CmdSetActivePort(port))
+
+    # =====
+
+    def set_port_beacon(self, port: int, on: bool) -> None:
+        self.__queue_cmd(_CmdSetPortBeacon(port, on))
+
+    def set_uplink_beacon(self, unit: int, on: bool) -> None:
+        self.__queue_cmd(_CmdSetUnitBeacon(unit, on, downlink=False))
+
+    def set_downlink_beacon(self, unit: int, on: bool) -> None:
+        self.__queue_cmd(_CmdSetUnitBeacon(unit, on, downlink=True))
+
+    # =====
+
+    def set_edids(self, edids: Edids) -> None:
+        self.__queue_cmd(_CmdSetEdids(edids))  # Will be copied because of multiprocessing.Queue()
+
+    def set_colors(self, colors: Colors) -> None:
+        self.__queue_cmd(_CmdSetColors(colors))
+
+    # =====
+
+    def click_power(self, port: int, delay: float, if_powered: (bool | None)) -> None:
+        self.__queue_cmd(_CmdAtxClick(port, delay, reset=False, if_powered=if_powered))
+
+    def click_reset(self, port: int, delay: float, if_powered: (bool | None)) -> None:
+        self.__queue_cmd(_CmdAtxClick(port, delay, reset=True, if_powered=if_powered))
+
+    # =====
+
+    def reboot_unit(self, unit: int, bootloader: bool) -> None:
+        self.__queue_cmd(_CmdRebootUnit(unit, bootloader))
+
+    # =====
+
+    async def poll_events(self) -> AsyncGenerator[BaseEvent, None]:
+        proc = multiprocessing.Process(target=self.__subprocess, daemon=True)
+        try:
+            proc.start()
+            while True:
+                try:
+                    yield (await aiotools.run_async(self.__events_queue.get, True, 0.1))
+                except queue.Empty:
+                    pass
+        finally:
+            if proc.is_alive():
+                self.__stop_event.set()
+            if proc.is_alive() or proc.exitcode is not None:
+                await aiotools.run_async(proc.join)
+
+    # =====
+
+    def __queue_cmd(self, cmd: _BaseCmd) -> None:
+        if not self.__stop_event.is_set():
+            self.__cmd_queue.put_nowait(cmd)
+
+    def __queue_event(self, event: BaseEvent) -> None:
+        if not self.__stop_event.is_set():
+            self.__events_queue.put_nowait(event)
+
+    def __subprocess(self) -> None:
+        logger = aioproc.settle("Switch", "switch")
+        no_device_reported = False
+        while True:
+            try:
+                if self.__device.has_device():
+                    no_device_reported = False
+                    with self.__device:
+                        logger.info("Switch found")
+                        self.__queue_event(DeviceFoundEvent())
+                        self.__main_loop()
+                elif not no_device_reported:
+                    self.__queue_event(ChainTruncatedEvent(0))
+                    logger.info("Switch is missing")
+                    no_device_reported = True
+            except DeviceError as ex:
+                logger.error("%s", tools.efmt(ex))
+            except Exception:
+                logger.exception("Unexpected error in the Switch loop")
+            tools.clear_queue(self.__cmd_queue)
+            if self.__stop_event.is_set():
+                break
+            time.sleep(1)
+
+    def __main_loop(self) -> None:
+        self.__device.request_state()
+        self.__device.request_atx_leds()
+        while not self.__stop_event.is_set():
+            if self.__select():
+                for resp in self.__device.read_all():
+                    self.__update_units(resp)
+                    self.__adjust_start_port()
+                    self.__finish_changing_request(resp)
+                self.__consume_commands()
+            self.__ensure_config()
+
+    def __select(self) -> bool:
+        try:
+            return bool(select.select([
+                self.__device.get_fd(),
+                self.__cmd_queue._reader,  # type: ignore  # pylint: disable=protected-access
+            ], [], [], 1)[0])
+        except Exception as ex:
+            raise DeviceError(ex)
+
+    def __consume_commands(self) -> None:
+        while not self.__cmd_queue.empty():
+            cmd = self.__cmd_queue.get()
+            match cmd:
+                case _CmdSetActual():
+                    self.__actual = cmd.actual
+
+                case _CmdSetActivePort():
+                    # Может быть вызвано изнутри при синхронизации
+                    self.__active_port = cmd.port
+                    self.__queue_event(PortActivatedEvent(self.__active_port))
+
+                case _CmdSetPortBeacon():
+                    (unit, ch) = self.get_real_unit_channel(cmd.port)
+                    self.__device.request_beacon(unit, ch, cmd.on)
+
+                case _CmdSetUnitBeacon():
+                    ch = (4 if cmd.downlink else 5)
+                    self.__device.request_beacon(cmd.unit, ch, cmd.on)
+
+                case _CmdAtxClick():
+                    (unit, ch) = self.get_real_unit_channel(cmd.port)
+                    if unit < len(self.__units):
+                        (allowed, powered) = self.__units[unit].is_atx_allowed(ch)
+                        if allowed and (cmd.if_powered is None or cmd.if_powered == powered):
+                            delay_ms = min(int(cmd.delay * 1000), 0xFFFF)
+                            if cmd.reset:
+                                self.__device.request_atx_cr(unit, ch, delay_ms)
+                            else:
+                                self.__device.request_atx_cp(unit, ch, delay_ms)
+
+                case _CmdSetEdids():
+                    self.__edids = cmd.edids
+
+                case _CmdSetColors():
+                    self.__colors = cmd.colors
+
+                case _CmdRebootUnit():
+                    self.__device.request_reboot(cmd.unit, cmd.bootloader)
+
+    def __update_units(self, resp: Response) -> None:
+        units = resp.header.unit + 1
+        while len(self.__units) < units:
+            self.__units.append(_UnitContext())
+
+        match resp.body:
+            case UnitState():
+                if not resp.body.flags.has_downlink and len(self.__units) > units:
+                    del self.__units[units:]
+                    self.__queue_event(ChainTruncatedEvent(units))
+                self.__units[resp.header.unit].state = resp.body
+                self.__queue_event(UnitStateEvent(resp.header.unit, resp.body))
+
+            case UnitAtxLeds():
+                self.__units[resp.header.unit].atx_leds = resp.body
+                self.__queue_event(UnitAtxLedsEvent(resp.header.unit, resp.body))
+
+    def __adjust_start_port(self) -> None:
+        if self.__active_port < 0:
+            for (unit, ctx) in enumerate(self.__units):
+                if ctx.state is not None and ctx.state.ch < 4:
+                    # Trigger queue select()
+                    port = self.get_virtual_port(unit, ctx.state.ch)
+                    get_logger().info("Found an active port %d on [%d:%d]: Syncing ...",
+                                      port, unit, ctx.state.ch)
+                    self.set_active_port(port)
+                    break
+
+    def __finish_changing_request(self, resp: Response) -> None:
+        if self.__units[resp.header.unit].changing_rid == resp.header.rid:
+            self.__units[resp.header.unit].changing_rid = -1
+
+    # =====
+
+    def __ensure_config(self) -> None:
+        for (unit, ctx) in enumerate(self.__units):
+            if ctx.state is not None:
+                self.__ensure_config_port(unit, ctx)
+                if self.__actual:
+                    self.__ensure_config_edids(unit, ctx)
+                    self.__ensure_config_colors(unit, ctx)
+
+    def __ensure_config_port(self, unit: int, ctx: _UnitContext) -> None:
+        assert ctx.state is not None
+        if self.__active_port >= 0 and ctx.can_be_changed():
+            ch = self.get_unit_target_channel(unit, self.__active_port)
+            if ctx.state.ch != ch:
+                get_logger().info("Switching for active port %d: [%d:%d] -> [%d:%d] ...",
+                                  self.__active_port, unit, ctx.state.ch, unit, ch)
+                ctx.changing_rid = self.__device.request_switch(unit, ch)
+
+    def __ensure_config_edids(self, unit: int, ctx: _UnitContext) -> None:
+        assert self.__actual
+        assert ctx.state is not None
+        if ctx.can_be_changed():
+            for ch in range(4):
+                port = self.get_virtual_port(unit, ch)
+                edid = self.__edids.get_edid_for_port(port)
+                if not ctx.state.compare_edid(ch, edid):
+                    get_logger().info("Changing EDID on port %d on [%d:%d]: %d/%d -> %d/%d (%s) ...",
+                                      port, unit, ch,
+                                      ctx.state.video_crc[ch], ctx.state.video_edid[ch],
+                                      edid.crc, edid.valid, edid.name)
+                    ctx.changing_rid = self.__device.request_set_edid(unit, ch, edid)
+                    break  # Busy globally
+
+    def __ensure_config_colors(self, unit: int, ctx: _UnitContext) -> None:
+        assert self.__actual
+        assert ctx.state is not None
+        for np in range(6):
+            if self.__colors.crc != ctx.state.np_crc[np]:
+                # get_logger().info("Changing colors on NP [%d:%d]: %d -> %d ...",
+                #                   unit, np, ctx.state.np_crc[np], self.__colors.crc)
+                self.__device.request_set_colors(unit, np, self.__colors)
+
+    # =====
+
+    @classmethod
+    def get_real_unit_channel(cls, port: int) -> tuple[int, int]:
+        return (port // 4, port % 4)
+
+    @classmethod
+    def get_unit_target_channel(cls, unit: int, port: int) -> int:
+        (t_unit, t_ch) = cls.get_real_unit_channel(port)
+        if unit != t_unit:
+            t_ch = 4
+        return t_ch
+
+    @classmethod
+    def get_virtual_port(cls, unit: int, ch: int) -> int:
+        return (unit * 4) + ch

kvmd/apps/kvmd/switch/device.py

@@ -0,0 +1,196 @@
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+import os
+import random
+import types
+
+import serial
+
+from .lib import tools
+
+from .types import Edid
+from .types import Colors
+
+from .proto import Packable
+from .proto import Request
+from .proto import Response
+from .proto import Header
+
+from .proto import BodySwitch
+from .proto import BodySetBeacon
+from .proto import BodyAtxClick
+from .proto import BodySetEdid
+from .proto import BodyClearEdid
+from .proto import BodySetColors
+
+
+# =====
+class DeviceError(Exception):
+    def __init__(self, ex: Exception):
+        super().__init__(tools.efmt(ex))
+
+
+class Device:
+    __SPEED = 115200
+    __TIMEOUT = 5.0
+
+    def __init__(self, device_path: str) -> None:
+        self.__device_path = device_path
+        self.__rid = random.randint(1, 0xFFFF)
+        self.__tty: (serial.Serial | None) = None
+        self.__buf: bytes = b""
+
+    def __enter__(self) -> "Device":
+        try:
+            self.__tty = serial.Serial(
+                self.__device_path,
+                baudrate=self.__SPEED,
+                timeout=self.__TIMEOUT,
+            )
+        except Exception as ex:
+            raise DeviceError(ex)
+        return self
+
+    def __exit__(
+        self,
+        _exc_type: type[BaseException],
+        _exc: BaseException,
+        _tb: types.TracebackType,
+    ) -> None:
+
+        if self.__tty is not None:
+            try:
+                self.__tty.close()
+            except Exception:
+                pass
+            self.__tty = None
+
+    def has_device(self) -> bool:
+        return os.path.exists(self.__device_path)
+
+    def get_fd(self) -> int:
+        assert self.__tty is not None
+        return self.__tty.fd
+
+    def read_all(self) -> list[Response]:
+        assert self.__tty is not None
+        try:
+            if not self.__tty.in_waiting:
+                return []
+            self.__buf += self.__tty.read_all()
+        except Exception as ex:
+            raise DeviceError(ex)
+
+        results: list[Response] = []
+        while True:
+            try:
+                begin = self.__buf.index(0xF1)
+            except ValueError:
+                break
+            try:
+                end = self.__buf.index(0xF2, begin)
+            except ValueError:
+                break
+            msg = self.__buf[begin + 1:end]
+            if 0xF1 in msg:
+                # raise RuntimeError(f"Found 0xF1 inside the message: {msg!r}")
+                break
+            self.__buf = self.__buf[end + 1:]
+            msg = self.__unescape(msg)
+            resp = Response.unpack(msg)
+            if resp is not None:
+                results.append(resp)
+        return results
+
+    def __unescape(self, msg: bytes) -> bytes:
+        if 0xF0 not in msg:
+            return msg
+        unesc: list[int] = []
+        esc = False
+        for ch in msg:
+            if ch == 0xF0:
+                esc = True
+            else:
+                if esc:
+                    ch ^= 0xFF
+                    esc = False
+                unesc.append(ch)
+        return bytes(unesc)
+
+    def request_reboot(self, unit: int, bootloader: bool) -> int:
+        return self.__send_request((Header.BOOTLOADER if bootloader else Header.REBOOT), unit, None)
+
+    def request_state(self) -> int:
+        return self.__send_request(Header.STATE, 0xFF, None)
+
+    def request_switch(self, unit: int, ch: int) -> int:
+        return self.__send_request(Header.SWITCH, unit, BodySwitch(ch))
+
+    def request_beacon(self, unit: int, ch: int, on: bool) -> int:
+        return self.__send_request(Header.BEACON, unit, BodySetBeacon(ch, on))
+
+    def request_atx_leds(self) -> int:
+        return self.__send_request(Header.ATX_LEDS, 0xFF, None)
+
+    def request_atx_cp(self, unit: int, ch: int, delay_ms: int) -> int:
+        return self.__send_request(Header.ATX_CLICK, unit, BodyAtxClick(ch, BodyAtxClick.POWER, delay_ms))
+
+    def request_atx_cr(self, unit: int, ch: int, delay_ms: int) -> int:
+        return self.__send_request(Header.ATX_CLICK, unit, BodyAtxClick(ch, BodyAtxClick.RESET, delay_ms))
+
+    def request_set_edid(self, unit: int, ch: int, edid: Edid) -> int:
+        if edid.valid:
+            return self.__send_request(Header.SET_EDID, unit, BodySetEdid(ch, edid))
+        return self.__send_request(Header.CLEAR_EDID, unit, BodyClearEdid(ch))
+
+    def request_set_colors(self, unit: int, ch: int, colors: Colors) -> int:
+        return self.__send_request(Header.SET_COLORS, unit, BodySetColors(ch, colors))
+
+    def __send_request(self, op: int, unit: int, body: (Packable | None)) -> int:
+        assert self.__tty is not None
+        req = Request(Header(
+            proto=1,
+            rid=self.__get_next_rid(),
+            op=op,
+            unit=unit,
+        ), body)
+        data: list[int] = [0xF1]
+        for ch in req.pack():
+            if 0xF0 <= ch <= 0xF2:
+                data.append(0xF0)
+                ch ^= 0xFF
+            data.append(ch)
+        data.append(0xF2)
+        try:
+            self.__tty.write(bytes(data))
+            self.__tty.flush()
+        except Exception as ex:
+            raise DeviceError(ex)
+        return req.header.rid
+
+    def __get_next_rid(self) -> int:
+        rid = self.__rid
+        self.__rid += 1
+        if self.__rid > 0xFFFF:
+            self.__rid = 1
+        return rid

kvmd/apps/kvmd/switch/lib.py

@@ -0,0 +1,35 @@
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+# pylint: disable=unused-import
+
+from ....logging import get_logger  # noqa: F401
+
+from .... import tools  # noqa: F401
+from .... import aiotools  # noqa: F401
+from .... import aioproc  # noqa: F401
+from .... import bitbang  # noqa: F401
+from .... import htclient  # noqa: F401
+from ....inotify import Inotify  # noqa: F401
+from ....errors import OperationError  # noqa: F401
+from ....edid import EdidNoBlockError as ParsedEdidNoBlockError  # noqa: F401
+from ....edid import Edid as ParsedEdid  # noqa: F401

kvmd/apps/kvmd/switch/proto.py

@@ -0,0 +1,295 @@
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+import struct
+import dataclasses
+
+from typing import Optional
+
+from .types import Edid
+from .types import Colors
+
+
+# =====
+class Packable:
+    def pack(self) -> bytes:
+        raise NotImplementedError()
+
+
+class Unpackable:
+    @classmethod
+    def unpack(cls, data: bytes, offset: int=0) -> "Unpackable":
+        raise NotImplementedError()
+
+
+# =====
+@dataclasses.dataclass(frozen=True)
+class Header(Packable, Unpackable):
+    proto:   int
+    rid:     int
+    op:      int
+    unit:    int
+
+    NAK        = 0
+    BOOTLOADER = 2
+    REBOOT     = 3
+    STATE      = 4
+    SWITCH     = 5
+    BEACON     = 6
+    ATX_LEDS   = 7
+    ATX_CLICK  = 8
+    SET_EDID   = 9
+    CLEAR_EDID = 10
+    SET_COLORS = 12
+
+    __struct = struct.Struct("<BHBB")
+
+    SIZE = __struct.size
+
+    def pack(self) -> bytes:
+        return self.__struct.pack(self.proto, self.rid, self.op, self.unit)
+
+    @classmethod
+    def unpack(cls, data: bytes, offset: int=0) -> "Header":
+        return Header(*cls.__struct.unpack_from(data, offset=offset))
+
+
+@dataclasses.dataclass(frozen=True)
+class Nak(Unpackable):
+    reason: int
+
+    INVALID_COMMAND   = 0
+    BUSY              = 1
+    NO_DOWNLINK       = 2
+    DOWNLINK_OVERFLOW = 3
+
+    __struct = struct.Struct("<B")
+
+    @classmethod
+    def unpack(cls, data: bytes, offset: int=0) -> "Nak":
+        return Nak(*cls.__struct.unpack_from(data, offset=offset))
+
+
+@dataclasses.dataclass(frozen=True)
+class UnitFlags:
+    changing_busy: bool
+    flashing_busy: bool
+    has_downlink:  bool
+
+
+@dataclasses.dataclass(frozen=True)
+class UnitState(Unpackable):  # pylint: disable=too-many-instance-attributes
+    sw_version:    int
+    hw_version:    int
+    flags:         UnitFlags
+    ch:            int
+    beacons:       tuple[bool, bool, bool, bool, bool, bool]
+    np_crc:        tuple[int,  int,  int,  int,  int,  int]
+    video_5v_sens: tuple[bool, bool, bool, bool, bool]
+    video_hpd:     tuple[bool, bool, bool, bool, bool]
+    video_edid:    tuple[bool, bool, bool, bool]
+    video_crc:     tuple[int,  int,  int,  int]
+    usb_5v_sens:   tuple[bool, bool, bool, bool]
+    atx_busy:      tuple[bool, bool, bool, bool]
+
+    __struct = struct.Struct("<HHHBBHHHHHHBBBHHHHBxB30x")
+
+    def compare_edid(self, ch: int, edid: Optional["Edid"]) -> bool:
+        if edid is None:
+            # Сойдет любой невалидный EDID
+            return (not self.video_edid[ch])
+        return (
+            self.video_edid[ch] == edid.valid
+            and self.video_crc[ch] == edid.crc
+        )
+
+    @classmethod
+    def unpack(cls, data: bytes, offset: int=0) -> "UnitState":  # pylint: disable=too-many-locals
+        (
+            sw_version, hw_version, flags, ch,
+            beacons, nc0, nc1, nc2, nc3, nc4, nc5,
+            video_5v_sens, video_hpd, video_edid, vc0, vc1, vc2, vc3,
+            usb_5v_sens, atx_busy,
+        ) = cls.__struct.unpack_from(data, offset=offset)
+        return UnitState(
+            sw_version,
+            hw_version,
+            flags=UnitFlags(
+                changing_busy=bool(flags & 0x80),
+                flashing_busy=bool(flags & 0x40),
+                has_downlink=bool(flags & 0x02),
+            ),
+            ch=ch,
+            beacons=cls.__make_flags6(beacons),
+            np_crc=(nc0, nc1, nc2, nc3, nc4, nc5),
+            video_5v_sens=cls.__make_flags5(video_5v_sens),
+            video_hpd=cls.__make_flags5(video_hpd),
+            video_edid=cls.__make_flags4(video_edid),
+            video_crc=(vc0, vc1, vc2, vc3),
+            usb_5v_sens=cls.__make_flags4(usb_5v_sens),
+            atx_busy=cls.__make_flags4(atx_busy),
+        )
+
+    @classmethod
+    def __make_flags6(cls, mask: int) -> tuple[bool, bool, bool, bool, bool, bool]:
+        return (
+            bool(mask & 0x01), bool(mask & 0x02), bool(mask & 0x04),
+            bool(mask & 0x08), bool(mask & 0x10), bool(mask & 0x20),
+        )
+
+    @classmethod
+    def __make_flags5(cls, mask: int) -> tuple[bool, bool, bool, bool, bool]:
+        return (
+            bool(mask & 0x01), bool(mask & 0x02), bool(mask & 0x04),
+            bool(mask & 0x08), bool(mask & 0x10),
+        )
+
+    @classmethod
+    def __make_flags4(cls, mask: int) -> tuple[bool, bool, bool, bool]:
+        return (bool(mask & 0x01), bool(mask & 0x02), bool(mask & 0x04), bool(mask & 0x08))
+
+
+@dataclasses.dataclass(frozen=True)
+class UnitAtxLeds(Unpackable):
+    power: tuple[bool, bool, bool, bool]
+    hdd:   tuple[bool, bool, bool, bool]
+
+    __struct = struct.Struct("<B")
+
+    @classmethod
+    def unpack(cls, data: bytes, offset: int=0) -> "UnitAtxLeds":
+        (mask,) = cls.__struct.unpack_from(data, offset=offset)
+        return UnitAtxLeds(
+            power=(bool(mask & 0x01), bool(mask & 0x02), bool(mask & 0x04), bool(mask & 0x08)),
+            hdd=(bool(mask & 0x10), bool(mask & 0x20), bool(mask & 0x40), bool(mask & 0x80)),
+        )
+
+
+# =====
+@dataclasses.dataclass(frozen=True)
+class BodySwitch(Packable):
+    ch: int
+
+    def __post_init__(self) -> None:
+        assert 0 <= self.ch <= 4
+
+    def pack(self) -> bytes:
+        return self.ch.to_bytes()
+
+
+@dataclasses.dataclass(frozen=True)
+class BodySetBeacon(Packable):
+    ch: int
+    on: bool
+
+    def __post_init__(self) -> None:
+        assert 0 <= self.ch <= 5
+
+    def pack(self) -> bytes:
+        return self.ch.to_bytes() + self.on.to_bytes()
+
+
+@dataclasses.dataclass(frozen=True)
+class BodyAtxClick(Packable):
+    ch:       int
+    action:   int
+    delay_ms: int
+
+    POWER = 0
+    RESET = 1
+
+    __struct = struct.Struct("<BBH")
+
+    def __post_init__(self) -> None:
+        assert 0 <= self.ch <= 3
+        assert self.action in [self.POWER, self.RESET]
+        assert 1 <= self.delay_ms <= 0xFFFF
+
+    def pack(self) -> bytes:
+        return self.__struct.pack(self.ch, self.action, self.delay_ms)
+
+
+@dataclasses.dataclass(frozen=True)
+class BodySetEdid(Packable):
+    ch:   int
+    edid: Edid
+
+    def __post_init__(self) -> None:
+        assert 0 <= self.ch <= 3
+
+    def pack(self) -> bytes:
+        return self.ch.to_bytes() + self.edid.pack()
+
+
+@dataclasses.dataclass(frozen=True)
+class BodyClearEdid(Packable):
+    ch: int
+
+    def __post_init__(self) -> None:
+        assert 0 <= self.ch <= 3
+
+    def pack(self) -> bytes:
+        return self.ch.to_bytes()
+
+
+@dataclasses.dataclass(frozen=True)
+class BodySetColors(Packable):
+    ch:     int
+    colors: Colors
+
+    def __post_init__(self) -> None:
+        assert 0 <= self.ch <= 5
+
+    def pack(self) -> bytes:
+        return self.ch.to_bytes() + self.colors.pack()
+
+
+# =====
+@dataclasses.dataclass(frozen=True)
+class Request:
+    header: Header
+    body:   (Packable | None) = dataclasses.field(default=None)
+
+    def pack(self) -> bytes:
+        msg = self.header.pack()
+        if self.body is not None:
+            msg += self.body.pack()
+        return msg
+
+
+@dataclasses.dataclass(frozen=True)
+class Response:
+    header: Header
+    body:   Unpackable
+
+    @classmethod
+    def unpack(cls, msg: bytes) -> Optional["Response"]:
+        header = Header.unpack(msg)
+        match header.op:
+            case Header.NAK:
+                return Response(header, Nak.unpack(msg, Header.SIZE))
+            case Header.STATE:
+                return Response(header, UnitState.unpack(msg, Header.SIZE))
+            case Header.ATX_LEDS:
+                return Response(header, UnitAtxLeds.unpack(msg, Header.SIZE))
+        # raise RuntimeError(f"Unknown OP in the header: {header!r}")
+        return None

kvmd/apps/kvmd/switch/state.py

@@ -0,0 +1,358 @@
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+import asyncio
+import dataclasses
+import time
+
+from typing import AsyncGenerator
+
+from .types import Edids
+from .types import Color
+from .types import Colors
+from .types import PortNames
+from .types import AtxClickPowerDelays
+from .types import AtxClickPowerLongDelays
+from .types import AtxClickResetDelays
+
+from .proto import UnitState
+from .proto import UnitAtxLeds
+
+from .chain import Chain
+
+
+# =====
+@dataclasses.dataclass
+class _UnitInfo:
+    state: (UnitState | None) = dataclasses.field(default=None)
+    atx_leds: (UnitAtxLeds | None) = dataclasses.field(default=None)
+
+
+# =====
+class StateCache:  # pylint: disable=too-many-instance-attributes
+    __FW_VERSION = 5
+
+    __FULL    = 0xFFFF
+    __SUMMARY = 0x01
+    __EDIDS   = 0x02
+    __COLORS  = 0x04
+    __VIDEO   = 0x08
+    __USB     = 0x10
+    __BEACONS = 0x20
+    __ATX     = 0x40
+
+    def __init__(self) -> None:
+        self.__edids = Edids()
+        self.__colors = Colors()
+        self.__port_names = PortNames({})
+        self.__atx_cp_delays = AtxClickPowerDelays({})
+        self.__atx_cpl_delays = AtxClickPowerLongDelays({})
+        self.__atx_cr_delays = AtxClickResetDelays({})
+
+        self.__units: list[_UnitInfo] = []
+        self.__active_port = -1
+        self.__synced = True
+
+        self.__queue: "asyncio.Queue[int]" = asyncio.Queue()
+
+    def get_edids(self) -> Edids:
+        return self.__edids.copy()
+
+    def get_colors(self) -> Colors:
+        return self.__colors
+
+    def get_port_names(self) -> PortNames:
+        return self.__port_names.copy()
+
+    def get_atx_cp_delays(self) -> AtxClickPowerDelays:
+        return self.__atx_cp_delays.copy()
+
+    def get_atx_cpl_delays(self) -> AtxClickPowerLongDelays:
+        return self.__atx_cpl_delays.copy()
+
+    def get_atx_cr_delays(self) -> AtxClickResetDelays:
+        return self.__atx_cr_delays.copy()
+
+    # =====
+
+    def get_state(self) -> dict:
+        return self.__inner_get_state(self.__FULL)
+
+    async def trigger_state(self) -> None:
+        self.__bump_state(self.__FULL)
+
+    async def poll_state(self) -> AsyncGenerator[dict, None]:
+        atx_ts: float = 0
+        while True:
+            try:
+                mask = await asyncio.wait_for(self.__queue.get(), timeout=0.1)
+            except TimeoutError:
+                mask = 0
+
+            if mask == self.__ATX:
+                # Откладываем единичное новое событие ATX, чтобы аккумулировать с нескольких свичей
+                if atx_ts == 0:
+                    atx_ts = time.monotonic() + 0.2
+                    continue
+                elif atx_ts >= time.monotonic():
+                    continue
+                # ... Ну или разрешаем отправить, если оно уже достаточно мариновалось
+            elif mask == 0 and atx_ts > time.monotonic():
+                # Разрешаем отправить отложенное
+                mask = self.__ATX
+                atx_ts = 0
+            elif mask & self.__ATX:
+                # Комплексное событие всегда должно обрабатываться сразу
+                atx_ts = 0
+
+            if mask != 0:
+                yield self.__inner_get_state(mask)
+
+    def __inner_get_state(self, mask: int) -> dict:  # pylint: disable=too-many-branches,too-many-statements,too-many-locals
+        assert mask != 0
+        x_model = (mask == self.__FULL)
+        x_summary = (mask & self.__SUMMARY)
+        x_edids = (mask & self.__EDIDS)
+        x_colors = (mask & self.__COLORS)
+        x_video = (mask & self.__VIDEO)
+        x_usb = (mask & self.__USB)
+        x_beacons = (mask & self.__BEACONS)
+        x_atx = (mask & self.__ATX)
+
+        state: dict = {}
+        if x_model:
+            state["model"] = {
+                "firmware": {"version": self.__FW_VERSION},
+                "units": [],
+                "ports": [],
+                "limits": {
+                    "atx": {
+                        "click_delays": {
+                            key: {"default": value, "min": 0, "max": 10}
+                            for (key, value) in [
+                                ("power",      self.__atx_cp_delays.default),
+                                ("power_long", self.__atx_cpl_delays.default),
+                                ("reset",      self.__atx_cr_delays.default),
+                            ]
+                        },
+                    },
+                },
+            }
+        if x_summary:
+            state["summary"] = {"active_port": self.__active_port, "synced": self.__synced}
+        if x_edids:
+            state["edids"] = {
+                "all": {
+                    edid_id: {
+                        "name": edid.name,
+                        "data": edid.as_text(),
+                        "parsed": (dataclasses.asdict(edid.info) if edid.info is not None else None),
+                    }
+                    for (edid_id, edid) in self.__edids.all.items()
+                },
+                "used": [],
+            }
+        if x_colors:
+            state["colors"] = {
+                role: {
+                    comp: getattr(getattr(self.__colors, role), comp)
+                    for comp in Color.COMPONENTS
+                }
+                for role in Colors.ROLES
+            }
+        if x_video:
+            state["video"] = {"links": []}
+        if x_usb:
+            state["usb"] = {"links": []}
+        if x_beacons:
+            state["beacons"] = {"uplinks": [], "downlinks": [], "ports": []}
+        if x_atx:
+            state["atx"] = {"busy": [], "leds": {"power": [], "hdd": []}}
+
+        if not self.__is_units_ready():
+            return state
+
+        for (unit, ui) in enumerate(self.__units):
+            assert ui.state is not None
+            assert ui.atx_leds is not None
+            if x_model:
+                state["model"]["units"].append({"firmware": {"version": ui.state.sw_version}})
+            if x_video:
+                state["video"]["links"].extend(ui.state.video_5v_sens[:4])
+            if x_usb:
+                state["usb"]["links"].extend(ui.state.usb_5v_sens)
+            if x_beacons:
+                state["beacons"]["uplinks"].append(ui.state.beacons[5])
+                state["beacons"]["downlinks"].append(ui.state.beacons[4])
+                state["beacons"]["ports"].extend(ui.state.beacons[:4])
+            if x_atx:
+                state["atx"]["busy"].extend(ui.state.atx_busy)
+                state["atx"]["leds"]["power"].extend(ui.atx_leds.power)
+                state["atx"]["leds"]["hdd"].extend(ui.atx_leds.hdd)
+            if x_model or x_edids:
+                for ch in range(4):
+                    port = Chain.get_virtual_port(unit, ch)
+                    if x_model:
+                        state["model"]["ports"].append({
+                            "unit": unit,
+                            "channel": ch,
+                            "name": self.__port_names[port],
+                            "atx": {
+                                "click_delays": {
+                                    "power": self.__atx_cp_delays[port],
+                                    "power_long": self.__atx_cpl_delays[port],
+                                    "reset": self.__atx_cr_delays[port],
+                                },
+                            },
+                        })
+                    if x_edids:
+                        state["edids"]["used"].append(self.__edids.get_id_for_port(port))
+        return state
+
+    def __inner_check_synced(self) -> bool:
+        for (unit, ui) in enumerate(self.__units):
+            if ui.state is None or ui.state.flags.changing_busy:
+                return False
+            if (
+                self.__active_port >= 0
+                and ui.state.ch != Chain.get_unit_target_channel(unit, self.__active_port)
+            ):
+                return False
+            for ch in range(4):
+                port = Chain.get_virtual_port(unit, ch)
+                edid = self.__edids.get_edid_for_port(port)
+                if not ui.state.compare_edid(ch, edid):
+                    return False
+            for ch in range(6):
+                if ui.state.np_crc[ch] != self.__colors.crc:
+                    return False
+        return True
+
+    def __recache_synced(self) -> bool:
+        synced = self.__inner_check_synced()
+        if self.__synced != synced:
+            self.__synced = synced
+            return True
+        return False
+
+    def truncate(self, units: int) -> None:
+        if len(self.__units) > units:
+            del self.__units[units:]
+            self.__bump_state(self.__FULL)
+
+    def update_active_port(self, port: int) -> None:
+        changed = (self.__active_port != port)
+        self.__active_port = port
+        changed = (self.__recache_synced() or changed)
+        if changed:
+            self.__bump_state(self.__SUMMARY)
+
+    def update_unit_state(self, unit: int, new: UnitState) -> None:
+        ui = self.__ensure_unit(unit)
+        (prev, ui.state) = (ui.state, new)
+        if not self.__is_units_ready():
+            return
+        mask = 0
+        if prev is None:
+            mask = self.__FULL
+        else:
+            if self.__recache_synced():
+                mask |= self.__SUMMARY
+            if prev.video_5v_sens != new.video_5v_sens:
+                mask |= self.__VIDEO
+            if prev.usb_5v_sens != new.usb_5v_sens:
+                mask |= self.__USB
+            if prev.beacons != new.beacons:
+                mask |= self.__BEACONS
+            if prev.atx_busy != new.atx_busy:
+                mask |= self.__ATX
+        if mask:
+            self.__bump_state(mask)
+
+    def update_unit_atx_leds(self, unit: int, new: UnitAtxLeds) -> None:
+        ui = self.__ensure_unit(unit)
+        (prev, ui.atx_leds) = (ui.atx_leds, new)
+        if not self.__is_units_ready():
+            return
+        if prev is None:
+            self.__bump_state(self.__FULL)
+        elif prev != new:
+            self.__bump_state(self.__ATX)
+
+    def __is_units_ready(self) -> bool:
+        for ui in self.__units:
+            if ui.state is None or ui.atx_leds is None:
+                return False
+        return True
+
+    def __ensure_unit(self, unit: int) -> _UnitInfo:
+        while len(self.__units) < unit + 1:
+            self.__units.append(_UnitInfo())
+        return self.__units[unit]
+
+    def __bump_state(self, mask: int) -> None:
+        assert mask != 0
+        self.__queue.put_nowait(mask)
+
+    # =====
+
+    def set_edids(self, edids: Edids) -> None:
+        changed = (
+            self.__edids.all != edids.all
+            or not self.__edids.compare_on_ports(edids, self.__get_ports())
+        )
+        self.__edids = edids.copy()
+        if changed:
+            self.__bump_state(self.__EDIDS)
+
+    def set_colors(self, colors: Colors) -> None:
+        changed = (self.__colors != colors)
+        self.__colors = colors
+        if changed:
+            self.__bump_state(self.__COLORS)
+
+    def set_port_names(self, port_names: PortNames) -> None:
+        changed = (not self.__port_names.compare_on_ports(port_names, self.__get_ports()))
+        self.__port_names = port_names.copy()
+        if changed:
+            self.__bump_state(self.__FULL)
+
+    def set_atx_cp_delays(self, delays: AtxClickPowerDelays) -> None:
+        changed = (not self.__atx_cp_delays.compare_on_ports(delays, self.__get_ports()))
+        self.__atx_cp_delays = delays.copy()
+        if changed:
+            self.__bump_state(self.__FULL)
+
+    def set_atx_cpl_delays(self, delays: AtxClickPowerLongDelays) -> None:
+        changed = (not self.__atx_cpl_delays.compare_on_ports(delays, self.__get_ports()))
+        self.__atx_cpl_delays = delays.copy()
+        if changed:
+            self.__bump_state(self.__FULL)
+
+    def set_atx_cr_delays(self, delays: AtxClickResetDelays) -> None:
+        changed = (not self.__atx_cr_delays.compare_on_ports(delays, self.__get_ports()))
+        self.__atx_cr_delays = delays.copy()
+        if changed:
+            self.__bump_state(self.__FULL)
+
+    def __get_ports(self) -> int:
+        return (len(self.__units) * 4)

kvmd/apps/kvmd/switch/storage.py

@@ -0,0 +1,186 @@
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+import os
+import asyncio
+import json
+import contextlib
+
+from typing import AsyncGenerator
+
+try:
+    from ....clients.pst import PstClient
+except ImportError:
+    PstClient = None  # type: ignore
+
+# from .lib import get_logger
+from .lib import aiotools
+from .lib import htclient
+from .lib import get_logger
+
+from .types import Edid
+from .types import Edids
+from .types import Color
+from .types import Colors
+from .types import PortNames
+from .types import AtxClickPowerDelays
+from .types import AtxClickPowerLongDelays
+from .types import AtxClickResetDelays
+
+
+# =====
+class StorageContext:
+    __F_EDIDS_ALL = "edids_all.json"
+    __F_EDIDS_PORT = "edids_port.json"
+
+    __F_COLORS = "colors.json"
+
+    __F_PORT_NAMES = "port_names.json"
+
+    __F_ATX_CP_DELAYS = "atx_click_power_delays.json"
+    __F_ATX_CPL_DELAYS = "atx_click_power_long_delays.json"
+    __F_ATX_CR_DELAYS = "atx_click_reset_delays.json"
+
+    def __init__(self, path: str, rw: bool) -> None:
+        self.__path = path
+        self.__rw = rw
+
+    # =====
+
+    async def write_edids(self, edids: Edids) -> None:
+        await self.__write_json_keyvals(self.__F_EDIDS_ALL, {
+            edid_id.lower(): {"name": edid.name, "data": edid.as_text()}
+            for (edid_id, edid) in edids.all.items()
+            if edid_id != Edids.DEFAULT_ID
+        })
+        await self.__write_json_keyvals(self.__F_EDIDS_PORT, edids.port)
+
+    async def write_colors(self, colors: Colors) -> None:
+        await self.__write_json_keyvals(self.__F_COLORS, {
+            role: {
+                comp: getattr(getattr(colors, role), comp)
+                for comp in Color.COMPONENTS
+            }
+            for role in Colors.ROLES
+        })
+
+    async def write_port_names(self, port_names: PortNames) -> None:
+        await self.__write_json_keyvals(self.__F_PORT_NAMES, port_names.kvs)
+
+    async def write_atx_cp_delays(self, delays: AtxClickPowerDelays) -> None:
+        await self.__write_json_keyvals(self.__F_ATX_CP_DELAYS, delays.kvs)
+
+    async def write_atx_cpl_delays(self, delays: AtxClickPowerLongDelays) -> None:
+        await self.__write_json_keyvals(self.__F_ATX_CPL_DELAYS, delays.kvs)
+
+    async def write_atx_cr_delays(self, delays: AtxClickResetDelays) -> None:
+        await self.__write_json_keyvals(self.__F_ATX_CR_DELAYS, delays.kvs)
+
+    async def __write_json_keyvals(self, name: str, kvs: dict) -> None:
+        if len(self.__path) == 0:
+            return
+        assert self.__rw
+        kvs = {str(key): value for (key, value) in kvs.items()}
+        if (await self.__read_json_keyvals(name)) == kvs:
+            return  # Don't write the same data
+        path = os.path.join(self.__path, name)
+        get_logger(0).info("Writing '%s' ...", name)
+        await aiotools.write_file(path, json.dumps(kvs))
+
+    # =====
+
+    async def read_edids(self) -> Edids:
+        all_edids = {
+            edid_id.lower(): Edid.from_data(edid["name"], edid["data"])
+            for (edid_id, edid) in (await self.__read_json_keyvals(self.__F_EDIDS_ALL)).items()
+        }
+        port_edids = await self.__read_json_keyvals_int(self.__F_EDIDS_PORT)
+        return Edids(all_edids, port_edids)
+
+    async def read_colors(self) -> Colors:
+        raw = await self.__read_json_keyvals(self.__F_COLORS)
+        return Colors(**{  # type: ignore
+            role: Color(**{comp: raw[role][comp] for comp in Color.COMPONENTS})
+            for role in Colors.ROLES
+            if role in raw
+        })
+
+    async def read_port_names(self) -> PortNames:
+        return PortNames(await self.__read_json_keyvals_int(self.__F_PORT_NAMES))
+
+    async def read_atx_cp_delays(self) -> AtxClickPowerDelays:
+        return AtxClickPowerDelays(await self.__read_json_keyvals_int(self.__F_ATX_CP_DELAYS))
+
+    async def read_atx_cpl_delays(self) -> AtxClickPowerLongDelays:
+        return AtxClickPowerLongDelays(await self.__read_json_keyvals_int(self.__F_ATX_CPL_DELAYS))
+
+    async def read_atx_cr_delays(self) -> AtxClickResetDelays:
+        return AtxClickResetDelays(await self.__read_json_keyvals_int(self.__F_ATX_CR_DELAYS))
+
+    async def __read_json_keyvals_int(self, name: str) -> dict:
+        return (await self.__read_json_keyvals(name, int_keys=True))
+
+    async def __read_json_keyvals(self, name: str, int_keys: bool=False) -> dict:
+        if len(self.__path) == 0:
+            return {}
+        path = os.path.join(self.__path, name)
+        try:
+            kvs: dict = json.loads(await aiotools.read_file(path))
+        except FileNotFoundError:
+            kvs = {}
+        if int_keys:
+            kvs = {int(key): value for (key, value) in kvs.items()}
+        return kvs
+
+
+class Storage:
+    __SUBDIR = "__switch__"
+    __TIMEOUT = 5.0
+
+    def __init__(self, unix_path: str) -> None:
+        self.__pst: (PstClient | None) = None
+        if len(unix_path) > 0 and PstClient is not None:
+            self.__pst = PstClient(
+                subdir=self.__SUBDIR,
+                unix_path=unix_path,
+                timeout=self.__TIMEOUT,
+                user_agent=htclient.make_user_agent("KVMD"),
+            )
+        self.__lock = asyncio.Lock()
+
+    @contextlib.asynccontextmanager
+    async def readable(self) -> AsyncGenerator[StorageContext, None]:
+        async with self.__lock:
+            if self.__pst is None:
+                yield StorageContext("", False)
+            else:
+                path = await self.__pst.get_path()
+                yield StorageContext(path, False)
+
+    @contextlib.asynccontextmanager
+    async def writable(self) -> AsyncGenerator[StorageContext, None]:
+        async with self.__lock:
+            if self.__pst is None:
+                yield StorageContext("", True)
+            else:
+                async with self.__pst.writable() as path:
+                    yield StorageContext(path, True)

kvmd/apps/kvmd/switch/types.py

@@ -0,0 +1,308 @@
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+import re
+import struct
+import uuid
+import dataclasses
+
+from typing import TypeVar
+from typing import Generic
+
+from .lib import bitbang
+from .lib import ParsedEdidNoBlockError
+from .lib import ParsedEdid
+
+
+# =====
+@dataclasses.dataclass(frozen=True)
+class EdidInfo:
+    mfc_id:         str
+    product_id:     int
+    serial:         int
+    monitor_name:   (str | None)
+    monitor_serial: (str | None)
+    audio:          bool
+
+    @classmethod
+    def from_data(cls, data: bytes) -> "EdidInfo":
+        parsed = ParsedEdid(data)
+
+        monitor_name: (str | None) = None
+        try:
+            monitor_name = parsed.get_monitor_name()
+        except ParsedEdidNoBlockError:
+            pass
+
+        monitor_serial: (str | None) = None
+        try:
+            monitor_serial = parsed.get_monitor_serial()
+        except ParsedEdidNoBlockError:
+            pass
+
+        return EdidInfo(
+            mfc_id=parsed.get_mfc_id(),
+            product_id=parsed.get_product_id(),
+            serial=parsed.get_serial(),
+            monitor_name=monitor_name,
+            monitor_serial=monitor_serial,
+            audio=parsed.get_audio(),
+        )
+
+
+@dataclasses.dataclass(frozen=True)
+class Edid:
+    name:  str
+    data:  bytes
+    crc:   int = dataclasses.field(default=0)
+    valid: bool = dataclasses.field(default=False)
+    info:  (EdidInfo | None) = dataclasses.field(default=None)
+
+    __HEADER = b"\x00\xFF\xFF\xFF\xFF\xFF\xFF\x00"
+
+    def __post_init__(self) -> None:
+        assert len(self.name) > 0
+        assert len(self.data) == 256
+        object.__setattr__(self, "crc", bitbang.make_crc16(self.data))
+        object.__setattr__(self, "valid", self.data.startswith(self.__HEADER))
+        try:
+            object.__setattr__(self, "info", EdidInfo.from_data(self.data))
+        except Exception:
+            pass
+
+    def as_text(self) -> str:
+        return "".join(f"{item:0{2}X}" for item in self.data)
+
+    def pack(self) -> bytes:
+        return self.data
+
+    @classmethod
+    def from_data(cls, name: str, data: (str | bytes | None)) -> "Edid":
+        if data is None:  # Пустой едид
+            return Edid(name, b"\x00" * 256)
+
+        if isinstance(data, bytes):
+            if data.startswith(cls.__HEADER):
+                return Edid(name, data)  # Бинарный едид
+            data_hex = data.decode()  # Текстовый едид, прочитанный как бинарный из файла
+        else:  # isinstance(data, str)
+            data_hex = str(data)  # Текстовый едид
+
+        data_hex = re.sub(r"\s", "", data_hex)
+        assert len(data_hex) == 512
+        data = bytes([
+            int(data_hex[index:index + 2], 16)
+            for index in range(0, len(data_hex), 2)
+        ])
+        return Edid(name, data)
+
+
+@dataclasses.dataclass
+class Edids:
+    DEFAULT_NAME = "Default"
+    DEFAULT_ID = "default"
+
+    all:  dict[str, Edid] = dataclasses.field(default_factory=dict)
+    port: dict[int, str] = dataclasses.field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.DEFAULT_ID not in self.all:
+            self.set_default(None)
+
+    def set_default(self, data: (str | bytes | None)) -> None:
+        self.all[self.DEFAULT_ID] = Edid.from_data(self.DEFAULT_NAME, data)
+
+    def copy(self) -> "Edids":
+        return Edids(dict(self.all), dict(self.port))
+
+    def compare_on_ports(self, other: "Edids", ports: int) -> bool:
+        for port in range(ports):
+            if self.get_id_for_port(port) != other.get_id_for_port(port):
+                return False
+        return True
+
+    def add(self, edid: Edid) -> str:
+        edid_id = str(uuid.uuid4()).lower()
+        self.all[edid_id] = edid
+        return edid_id
+
+    def set(self, edid_id: str, edid: Edid) -> None:
+        assert edid_id in self.all
+        self.all[edid_id] = edid
+
+    def get(self, edid_id: str) -> Edid:
+        return self.all[edid_id]
+
+    def remove(self, edid_id: str) -> None:
+        assert edid_id in self.all
+        self.all.pop(edid_id)
+        for port in list(self.port):
+            if self.port[port] == edid_id:
+                self.port.pop(port)
+
+    def has_id(self, edid_id: str) -> bool:
+        return (edid_id in self.all)
+
+    def assign(self, port: int, edid_id: str) -> None:
+        assert edid_id in self.all
+        if edid_id == Edids.DEFAULT_ID:
+            self.port.pop(port, None)
+        else:
+            self.port[port] = edid_id
+
+    def get_id_for_port(self, port: int) -> str:
+        return self.port.get(port, self.DEFAULT_ID)
+
+    def get_edid_for_port(self, port: int) -> Edid:
+        return self.all[self.get_id_for_port(port)]
+
+
+# =====
+@dataclasses.dataclass(frozen=True)
+class Color:
+    COMPONENTS = frozenset(["red", "green", "blue", "brightness", "blink_ms"])
+
+    red:        int
+    green:      int
+    blue:       int
+    brightness: int
+    blink_ms:   int
+    crc:        int = dataclasses.field(default=0)
+    _packed:    bytes = dataclasses.field(default=b"")
+
+    __struct = struct.Struct("<BBBBH")
+    __rx = re.compile(r"^([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2}):([0-9a-fA-F]{2}):([0-9a-fA-F]{4})$")
+
+    def __post_init__(self) -> None:
+        assert 0 <= self.red <= 0xFF
+        assert 0 <= self.green <= 0xFF
+        assert 0 <= self.blue <= 0xFF
+        assert 0 <= self.brightness <= 0xFF
+        assert 0 <= self.blink_ms <= 0xFFFF
+        data = self.__struct.pack(self.red, self.green, self.blue, self.brightness, self.blink_ms)
+        object.__setattr__(self, "crc", bitbang.make_crc16(data))
+        object.__setattr__(self, "_packed", data)
+
+    def pack(self) -> bytes:
+        return self._packed
+
+    @classmethod
+    def from_text(cls, text: str) -> "Color":
+        match = cls.__rx.match(text)
+        assert match is not None, text
+        return Color(
+            red=int(match.group(1), 16),
+            green=int(match.group(2), 16),
+            blue=int(match.group(3), 16),
+            brightness=int(match.group(4), 16),
+            blink_ms=int(match.group(5), 16),
+        )
+
+
+@dataclasses.dataclass(frozen=True)
+class Colors:
+    ROLES = frozenset(["inactive", "active", "flashing", "beacon", "bootloader"])
+
+    inactive:   Color = dataclasses.field(default=Color(255, 0,   0,   64,  0))
+    active:     Color = dataclasses.field(default=Color(0,   255, 0,   128, 0))
+    flashing:   Color = dataclasses.field(default=Color(0,   170, 255, 128, 0))
+    beacon:     Color = dataclasses.field(default=Color(228, 44,  156, 255, 250))
+    bootloader: Color = dataclasses.field(default=Color(255, 170, 0,   128, 0))
+    crc:        int = dataclasses.field(default=0)
+    _packed:    bytes = dataclasses.field(default=b"")
+
+    __crc_struct = struct.Struct("<HHHHH")
+
+    def __post_init__(self) -> None:
+        crcs: list[int] = []
+        packed: bytes = b""
+        for color in [self.inactive, self.active, self.flashing, self.beacon, self.bootloader]:
+            crcs.append(color.crc)
+            packed += color.pack()
+        object.__setattr__(self, "crc", bitbang.make_crc16(self.__crc_struct.pack(*crcs)))
+        object.__setattr__(self, "_packed", packed)
+
+    def pack(self) -> bytes:
+        return self._packed
+
+
+# =====
+_T = TypeVar("_T")
+
+
+class _PortsDict(Generic[_T]):
+    def __init__(self, default: _T, kvs: dict[int, _T]) -> None:
+        self.default = default
+        self.kvs = {
+            port: value
+            for (port, value) in kvs.items()
+            if value != default
+        }
+
+    def compare_on_ports(self, other: "_PortsDict[_T]", ports: int) -> bool:
+        for port in range(ports):
+            if self[port] != other[port]:
+                return False
+        return True
+
+    def __getitem__(self, port: int) -> _T:
+        return self.kvs.get(port, self.default)
+
+    def __setitem__(self, port: int, value: (_T | None)) -> None:
+        if value is None:
+            value = self.default
+        if value == self.default:
+            self.kvs.pop(port, None)
+        else:
+            self.kvs[port] = value
+
+
+class PortNames(_PortsDict[str]):
+    def __init__(self, kvs: dict[int, str]) -> None:
+        super().__init__("", kvs)
+
+    def copy(self) -> "PortNames":
+        return PortNames(self.kvs)
+
+
+class AtxClickPowerDelays(_PortsDict[float]):
+    def __init__(self, kvs: dict[int, float]) -> None:
+        super().__init__(0.5, kvs)
+
+    def copy(self) -> "AtxClickPowerDelays":
+        return AtxClickPowerDelays(self.kvs)
+
+
+class AtxClickPowerLongDelays(_PortsDict[float]):
+    def __init__(self, kvs: dict[int, float]) -> None:
+        super().__init__(5.5, kvs)
+
+    def copy(self) -> "AtxClickPowerLongDelays":
+        return AtxClickPowerLongDelays(self.kvs)
+
+
+class AtxClickResetDelays(_PortsDict[float]):
+    def __init__(self, kvs: dict[int, float]) -> None:
+        super().__init__(0.5, kvs)
+
+    def copy(self) -> "AtxClickResetDelays":
+        return AtxClickResetDelays(self.kvs)

kvmd/apps/kvmd/sysunit.py

@@ -35,6 +35,7 @@ class SystemdUnitInfo:
         self.__bus: (dbus_next.aio.MessageBus | None) = None
         self.__intr: (dbus_next.introspection.Node | None) = None
         self.__manager: (dbus_next.aio.proxy_object.ProxyInterface | None) = None
+        self.__requested = False
 
     async def get_status(self, name: str) -> tuple[bool, bool]:
         assert self.__bus is not None
@@ -49,8 +50,9 @@ class SystemdUnitInfo:
             unit = self.__bus.get_proxy_object("org.freedesktop.systemd1", unit_p, self.__intr)
             unit_props = unit.get_interface("org.freedesktop.DBus.Properties")
             started = ((await unit_props.call_get("org.freedesktop.systemd1.Unit", "ActiveState")).value == "active")  # type: ignore
-        except dbus_next.errors.DBusError as err:
-            if err.type != "org.freedesktop.systemd1.NoSuchUnit":
+            self.__requested = True
+        except dbus_next.errors.DBusError as ex:
+            if ex.type != "org.freedesktop.systemd1.NoSuchUnit":
                 raise
             started = False
         enabled = ((await self.__manager.call_get_unit_file_state(name)) in [  # type: ignore
@@ -75,8 +77,13 @@ class SystemdUnitInfo:
     async def close(self) -> None:
         try:
             if self.__bus is not None:
-                self.__bus.disconnect()
-                await self.__bus.wait_for_disconnect()
+                try:
+                    # XXX: Workaround for dbus_next bug: https://github.com/pikvm/kvmd/pull/182
+                    if not self.__requested:
+                        await self.__manager.call_get_default_target()  # type: ignore
+                finally:
+                    self.__bus.disconnect()
+                    await self.__bus.wait_for_disconnect()
         except Exception:
             pass
         self.__manager = None

kvmd/apps/kvmd/ugpio.py

@@ -21,13 +21,12 @@
 
 
 import asyncio
+import copy
 
 from typing import AsyncGenerator
 from typing import Callable
 from typing import Any
 
-from ...languages import Languages
-
 from ...logging import get_logger
 
 from ...errors import IsBusyError
@@ -48,42 +47,40 @@ from ...yamlconf import Section
 # =====
 class GpioChannelNotFoundError(GpioOperationError):
     def __init__(self) -> None:
-        super().__init__(Languages().gettext("GPIO channel is not found"))
+        super().__init__("GPIO channel is not found")
 
 
 class GpioSwitchNotSupported(GpioOperationError):
     def __init__(self) -> None:
-        super().__init__(Languages().gettext("This GPIO channel does not support switching"))
+        super().__init__("This GPIO channel does not support switching")
 
 
 class GpioPulseNotSupported(GpioOperationError):
     def __init__(self) -> None:
-        super().__init__(Languages().gettext("This GPIO channel does not support pulsing"))
+        super().__init__("This GPIO channel does not support pulsing")
 
 
 class GpioChannelIsBusyError(IsBusyError, GpioError):
     def __init__(self) -> None:
-        super().__init__(Languages().gettext("Performing another GPIO operation on this channel, please try again later"))
+        super().__init__("Performing another GPIO operation on this channel, please try again later")
 
 
 # =====
 class _GpioInput:
     def __init__(
         self,
-        channel: str,
+        ch: str,
         config: Section,
         driver: BaseUserGpioDriver,
     ) -> None:
 
-        self.__channel = channel
+        self.__ch = ch
         self.__pin: str = str(config.pin)
         self.__inverted: bool = config.inverted
 
         self.__driver = driver
         self.__driver.register_input(self.__pin, config.debounce)
 
-        self.gettext=Languages().gettext
-
     def get_scheme(self) -> dict:
         return {
             "hw": {
@@ -104,7 +101,7 @@ class _GpioInput:
         }
 
     def __str__(self) -> str:
-        return f"Input({self.__channel}, driver={self.__driver}, pin={self.__pin})"
+        return f"Input({self.__ch}, driver={self.__driver}, pin={self.__pin})"
 
     __repr__ = __str__
 
@@ -112,13 +109,13 @@ class _GpioInput:
 class _GpioOutput:  # pylint: disable=too-many-instance-attributes
     def __init__(
         self,
-        channel: str,
+        ch: str,
         config: Section,
         driver: BaseUserGpioDriver,
         notifier: aiotools.AioNotifier,
     ) -> None:
 
-        self.__channel = channel
+        self.__ch = ch
         self.__pin: str = str(config.pin)
         self.__inverted: bool = config.inverted
 
@@ -140,8 +137,6 @@ class _GpioOutput:  # pylint: disable=too-many-instance-attributes
 
         self.__region = aiotools.AioExclusiveRegion(GpioChannelIsBusyError, notifier)
 
-        self.gettext=Languages().gettext
-
     def is_const(self) -> bool:
         return (not self.__switch and not self.__pulse_delay)
 
@@ -190,11 +185,11 @@ class _GpioOutput:  # pylint: disable=too-many-instance-attributes
     @aiotools.atomic_fg
     async def __run_action(self, wait: bool, name: str, func: Callable, *args: Any) -> None:
         if wait:
-            async with self.__region:
+            with self.__region:
                 await func(*args)
         else:
             await aiotools.run_region_task(
-                self.gettext(f"Can't perform {name} of {self} or operation was not completed"),
+                f"Can't perform {name} of {self} or operation was not completed",
                 self.__region, self.__action_task_wrapper, name, func, *args,
             )
 
@@ -203,12 +198,12 @@ class _GpioOutput:  # pylint: disable=too-many-instance-attributes
         try:
             return (await func(*args))
         except GpioDriverOfflineError:
-            get_logger(0).error(self.gettext("Can't perform %s of %s or operation was not completed: driver offline"), name, self)
+            get_logger(0).error("Can't perform %s of %s or operation was not completed: driver offline", name, self)
 
     @aiotools.atomic_fg
     async def __inner_switch(self, state: bool) -> None:
         await self.__write(state)
-        get_logger(0).info(self.gettext("Ensured switch %s to state=%d"), self, state)
+        get_logger(0).info("Ensured switch %s to state=%d", self, state)
         await asyncio.sleep(self.__busy_delay)
 
     @aiotools.atomic_fg
@@ -219,7 +214,7 @@ class _GpioOutput:  # pylint: disable=too-many-instance-attributes
         finally:
             await self.__write(False)
             await asyncio.sleep(self.__busy_delay)
-        get_logger(0).info(self.gettext("Pulsed %s with delay=%.2f"), self, delay)
+        get_logger(0).info("Pulsed %s with delay=%.2f", self, delay)
 
     # =====
 
@@ -230,7 +225,7 @@ class _GpioOutput:  # pylint: disable=too-many-instance-attributes
         await self.__driver.write(self.__pin, (state ^ self.__inverted))
 
     def __str__(self) -> str:
-        return self.gettext(f"Output({self.__channel}, driver={self.__driver}, pin={self.__pin})")
+        return f"Output({self.__ch}, driver={self.__driver}, pin={self.__pin})"
 
     __repr__ = __str__
 
@@ -238,8 +233,6 @@ class _GpioOutput:  # pylint: disable=too-many-instance-attributes
 # =====
 class UserGpio:
     def __init__(self, config: Section, otg_config: Section) -> None:
-        self.__view = config.view
-
         self.__notifier = aiotools.AioNotifier()
 
         self.__drivers = {
@@ -255,54 +248,74 @@ class UserGpio:
         self.__inputs: dict[str, _GpioInput] = {}
         self.__outputs: dict[str, _GpioOutput] = {}
 
-        self.gettext=Languages().gettext
-
-        for (channel, ch_config) in tools.sorted_kvs(config.scheme):
+        for (ch, ch_config) in tools.sorted_kvs(config.scheme):
             driver = self.__drivers[ch_config.driver]
             if ch_config.mode == UserGpioModes.INPUT:
-                self.__inputs[channel] = _GpioInput(channel, ch_config, driver)
+                self.__inputs[ch] = _GpioInput(ch, ch_config, driver)
             else:  # output:
-                self.__outputs[channel] = _GpioOutput(channel, ch_config, driver, self.__notifier)
+                self.__outputs[ch] = _GpioOutput(ch, ch_config, driver, self.__notifier)
 
-    async def get_model(self) -> dict:
-        return {
-            "scheme": {
-                "inputs": {channel: gin.get_scheme() for (channel, gin) in self.__inputs.items()},
-                "outputs": {
-                    channel: gout.get_scheme()
-                    for (channel, gout) in self.__outputs.items()
-                    if not gout.is_const()
-                },
-            },
-            "view": self.__make_view(),
-        }
+        self.__scheme = self.__make_scheme()
+        self.__view = self.__make_view(config.view)
 
     async def get_state(self) -> dict:
         return {
-            "inputs": {channel: await gin.get_state() for (channel, gin) in self.__inputs.items()},
+            "model": {
+                "scheme": copy.deepcopy(self.__scheme),
+                "view": copy.deepcopy(self.__view),
+            },
+            "state": (await self.__get_io_state()),
+        }
+
+    async def trigger_state(self) -> None:
+        self.__notifier.notify(1)
+
+    async def poll_state(self) -> AsyncGenerator[dict, None]:
+        # ==== Granularity table ====
+        #   - model -- Full
+        #   - state.inputs  -- Partial
+        #   - state.outputs -- Partial
+        # ===========================
+
+        prev: dict = {"inputs": {}, "outputs": {}}
+        while True:  # pylint: disable=too-many-nested-blocks
+            if (await self.__notifier.wait()) > 0:
+                full = await self.get_state()
+                prev = copy.deepcopy(full["state"])
+                yield full
+            else:
+                new = await self.__get_io_state()
+                diff: dict = {}
+                for sub in ["inputs", "outputs"]:
+                    for ch in new[sub]:
+                        if new[sub][ch] != prev[sub].get(ch):
+                            if sub not in diff:
+                                diff[sub] = {}
+                            diff[sub][ch] = new[sub][ch]
+                if diff:
+                    prev = copy.deepcopy(new)
+                    yield {"state": diff}
+
+    async def __get_io_state(self) -> dict:
+        return {
+            "inputs": {
+                ch: (await gin.get_state())
+                for (ch, gin) in self.__inputs.items()
+            },
             "outputs": {
-                channel: await gout.get_state()
-                for (channel, gout) in self.__outputs.items()
+                ch: (await gout.get_state())
+                for (ch, gout) in self.__outputs.items()
                 if not gout.is_const()
             },
         }
 
-    async def poll_state(self) -> AsyncGenerator[dict, None]:
-        prev_state: dict = {}
-        while True:
-            state = await self.get_state()
-            if state != prev_state:
-                yield state
-                prev_state = state
-            await self.__notifier.wait()
-
     def sysprep(self) -> None:
-        get_logger(0).info(self.gettext("Preparing User-GPIO drivers ..."))
+        get_logger(0).info("Preparing User-GPIO drivers ...")
         for (_, driver) in tools.sorted_kvs(self.__drivers):
             driver.prepare()
 
     async def systask(self) -> None:
-        get_logger(0).info(self.gettext("Running User-GPIO drivers ..."))
+        get_logger(0).info("Running User-GPIO drivers ...")
         await asyncio.gather(*[
             driver.run()
             for (_, driver) in tools.sorted_kvs(self.__drivers)
@@ -313,30 +326,45 @@ class UserGpio:
             try:
                 await driver.cleanup()
             except Exception:
-                get_logger().exception(self.gettext("Can't cleanup driver %s"), driver)
+                get_logger().exception("Can't cleanup driver %s", driver)
 
-    async def switch(self, channel: str, state: bool, wait: bool) -> None:
-        gout = self.__outputs.get(channel)
+    async def switch(self, ch: str, state: bool, wait: bool) -> None:
+        gout = self.__outputs.get(ch)
         if gout is None:
             raise GpioChannelNotFoundError()
         await gout.switch(state, wait)
 
-    async def pulse(self, channel: str, delay: float, wait: bool) -> None:
-        gout = self.__outputs.get(channel)
+    async def pulse(self, ch: str, delay: float, wait: bool) -> None:
+        gout = self.__outputs.get(ch)
         if gout is None:
             raise GpioChannelNotFoundError()
         await gout.pulse(delay, wait)
 
     # =====
 
-    def __make_view(self) -> dict:
+    def __make_scheme(self) -> dict:
         return {
-            "header": {"title": self.__make_view_title()},
-            "table": self.__make_view_table(),
+            "inputs": {
+                ch: gin.get_scheme()
+                for (ch, gin) in self.__inputs.items()
+            },
+            "outputs": {
+                ch: gout.get_scheme()
+                for (ch, gout) in self.__outputs.items()
+                if not gout.is_const()
+            },
         }
 
-    def __make_view_title(self) -> list[dict]:
-        raw_title = self.__view["header"]["title"]
+    # =====
+
+    def __make_view(self, view: dict) -> dict:
+        return {
+            "header": {"title": self.__make_view_title(view)},
+            "table": self.__make_view_table(view),
+        }
+
+    def __make_view_title(self, view: dict) -> list[dict]:
+        raw_title = view["header"]["title"]
         title: list[dict] = []
         if isinstance(raw_title, list):
             for item in raw_title:
@@ -350,9 +378,9 @@ class UserGpio:
             title.append(self.__make_item_label(f"#{raw_title}"))
         return title
 
-    def __make_view_table(self) -> list[list[dict] | None]:
+    def __make_view_table(self, view: dict) -> list[list[dict] | None]:
         table: list[list[dict] | None] = []
-        for row in self.__view["table"]:
+        for row in view["table"]:
             if len(row) == 0:
                 table.append(None)
                 continue
@@ -380,7 +408,7 @@ class UserGpio:
     def __make_item_input(self, parts: list[str]) -> dict:
         assert len(parts) >= 1
         color = (parts[1] if len(parts) > 1 else None)
-        if color not in ["green", "yellow", "red"]:
+        if color not in ["green", "yellow", "red", "blue", "cyan", "magenta", "pink", "white"]:
             color = "green"
         return {
             "type": UserGpioModes.INPUT,

kvmd/apps/media/__init__.py

@@ -0,0 +1,48 @@
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2020  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+from ...clients.streamer import StreamerFormats
+from ...clients.streamer import MemsinkStreamerClient
+
+from .. import init
+
+from .server import MediaServer
+
+
+# =====
+def main(argv: (list[str] | None)=None) -> None:
+    config = init(
+        prog="kvmd-media",
+        description="The media proxy",
+        check_run=True,
+        argv=argv,
+    )[2].media
+
+    def make_streamer(name: str, fmt: int) -> (MemsinkStreamerClient | None):
+        if getattr(config.memsink, name).sink:
+            return MemsinkStreamerClient(name.upper(), fmt, **getattr(config.memsink, name)._unpack())
+        return None
+
+    MediaServer(
+        h264_streamer=make_streamer("h264", StreamerFormats.H264),
+        jpeg_streamer=make_streamer("jpeg", StreamerFormats.JPEG),
+    ).run(**config.server._unpack())

kvmd/apps/media/__main__.py

@@ -0,0 +1,24 @@
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2020  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+from . import main
+main()

kvmd/apps/media/server.py

@@ -0,0 +1,190 @@
+# ========================================================================== #
+#                                                                            #
+#    KVMD - The main PiKVM daemon.                                           #
+#                                                                            #
+#    Copyright (C) 2020  Maxim Devaev <mdevaev@gmail.com>                    #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+import asyncio
+import dataclasses
+
+from aiohttp.web import Request
+from aiohttp.web import WebSocketResponse
+
+from ...logging import get_logger
+
+from ... import tools
+from ... import aiotools
+
+from ...htserver import exposed_http
+from ...htserver import exposed_ws
+from ...htserver import WsSession
+from ...htserver import HttpServer
+
+from ...clients.streamer import StreamerError
+from ...clients.streamer import StreamerPermError
+from ...clients.streamer import StreamerFormats
+from ...clients.streamer import BaseStreamerClient
+
+
+# =====
+@dataclasses.dataclass
+class _Source:
+    type:         str
+    fmt:          str
+    streamer:     BaseStreamerClient
+    meta:         dict = dataclasses.field(default_factory=dict)
+    clients:      dict[WsSession, "_Client"] = dataclasses.field(default_factory=dict)
+    key_required: bool = dataclasses.field(default=False)
+
+
+@dataclasses.dataclass
+class _Client:
+    ws:     WsSession
+    src:    _Source
+    queue:  asyncio.Queue[dict]
+    sender: (asyncio.Task | None) = dataclasses.field(default=None)
+
+
+class MediaServer(HttpServer):
+    __K_VIDEO = "video"
+
+    __F_H264 = "h264"
+    __F_JPEG = "jpeg"
+
+    __Q_SIZE = 32
+
+    def __init__(
+        self,
+        h264_streamer: (BaseStreamerClient | None),
+        jpeg_streamer: (BaseStreamerClient | None),
+    ) -> None:
+
+        super().__init__()
+
+        self.__srcs: list[_Source] = []
+        if h264_streamer:
+            self.__srcs.append(_Source(self.__K_VIDEO, self.__F_H264, h264_streamer, {"profile_level_id": "42E01F"}))
+        if jpeg_streamer:
+            self.__srcs.append(_Source(self.__K_VIDEO, self.__F_JPEG, jpeg_streamer))
+
+    # =====
+
+    @exposed_http("GET", "/ws")
+    async def __ws_handler(self, req: Request) -> WebSocketResponse:
+        async with self._ws_session(req) as ws:
+            media: dict = {self.__K_VIDEO: {}}
+            for src in self.__srcs:
+                media[src.type][src.fmt] = src.meta
+            await ws.send_event("media", media)
+            return (await self._ws_loop(ws))
+
+    @exposed_ws(0)
+    async def __ws_bin_ping_handler(self, ws: WsSession, _: bytes) -> None:
+        await ws.send_bin(255, b"")  # Ping-pong
+
+    @exposed_ws("start")
+    async def __ws_start_handler(self, ws: WsSession, event: dict) -> None:
+        try:
+            req_type = str(event.get("type"))
+            req_fmt = str(event.get("format"))
+        except Exception:
+            return
+        src: (_Source | None) = None
+        for cand in self.__srcs:
+            if ws in cand.clients:
+                return  # Don't allow any double streaming
+            if (cand.type, cand.fmt) == (req_type, req_fmt):
+                src = cand
+        if src:
+            client = _Client(ws, src, asyncio.Queue(self.__Q_SIZE))
+            client.sender = aiotools.create_deadly_task(str(ws), self.__sender(client))
+            src.clients[ws] = client
+            get_logger(0).info("Streaming %s to %s ...", src.streamer, ws)
+
+    # =====
+
+    async def _init_app(self) -> None:
+        logger = get_logger(0)
+        for src in self.__srcs:
+            logger.info("Starting streamer %s ...", src.streamer)
+            aiotools.create_deadly_task(str(src.streamer), self.__streamer(src))
+        self._add_exposed(self)
+
+    async def _on_shutdown(self) -> None:
+        logger = get_logger(0)
+        logger.info("Stopping system tasks ...")
+        await aiotools.stop_all_deadly_tasks()
+        logger.info("Disconnecting clients ...")
+        await self._close_all_wss()
+        logger.info("On-Shutdown complete")
+
+    async def _on_ws_closed(self, ws: WsSession) -> None:
+        for src in self.__srcs:
+            client = src.clients.pop(ws, None)
+            if client and client.sender:
+                get_logger(0).info("Closed stream for %s", ws)
+                client.sender.cancel()
+                return
+
+    # =====
+
+    async def __sender(self, client: _Client) -> None:
+        need_key = StreamerFormats.is_diff(client.src.streamer.get_format())
+        if need_key:
+            client.src.key_required = True
+        has_key = False
+        while True:
+            frame = await client.queue.get()
+            has_key = (not need_key or has_key or frame["key"])
+            if has_key:
+                try:
+                    await client.ws.send_bin(1, frame["key"].to_bytes() + frame["data"])
+                except Exception:
+                    pass
+
+    async def __streamer(self, src: _Source) -> None:
+        logger = get_logger(0)
+        while True:
+            if len(src.clients) == 0:
+                await asyncio.sleep(1)
+                continue
+            try:
+                async with src.streamer.reading() as read_frame:
+                    while len(src.clients) > 0:
+                        frame = await read_frame(src.key_required)
+                        if frame["key"]:
+                            src.key_required = False
+                        for client in src.clients.values():
+                            try:
+                                client.queue.put_nowait(frame)
+                            except asyncio.QueueFull:
+                                # Если какой-то из клиентов не справляется, очищаем ему очередь и запрашиваем кейфрейм.
+                                # Я вижу у такой логики кучу минусов, хз как себя покажет, но лучше пока ничего не придумал.
+                                tools.clear_queue(client.queue)
+                                src.key_required = True
+                            except Exception:
+                                pass
+            except StreamerError as ex:
+                if isinstance(ex, StreamerPermError):
+                    logger.exception("Streamer failed: %s", src.streamer)
+                else:
+                    logger.error("Streamer error: %s: %s", src.streamer, tools.efmt(ex))
+            except Exception:
+                get_logger(0).exception("Unexpected streamer error: %s", src.streamer)
+            await asyncio.sleep(1)

kvmd/apps/oled/__init__.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+# ========================================================================== #
+#                                                                            #
+#    KVMD-OLED - A small OLED daemon for PiKVM.                              #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+import sys
+import os
+import signal
+import itertools
+import logging
+import time
+
+import usb.core
+
+from luma.core import cmdline as luma_cmdline
+
+from PIL import ImageFont
+
+from .screen import Screen
+from .sensors import Sensors
+
+
+# =====
+_logger = logging.getLogger("oled")
+
+
+# =====
+def _detect_geometry() -> dict:
+    with open("/proc/device-tree/model") as file:
+        is_cm4 = ("Compute Module 4" in file.read())
+    has_usb = bool(list(usb.core.find(find_all=True)))
+    if is_cm4 and has_usb:
+        return {"height": 64, "rotate": 2}
+    return {"height": 32, "rotate": 0}
+
+
+def _get_data_path(subdir: str, name: str) -> str:
+    if not name.startswith("@"):
+        return name  # Just a regular system path
+    name = name[1:]
+    module_path = sys.modules[__name__].__file__
+    assert module_path is not None
+    return os.path.join(os.path.dirname(module_path), subdir, name)
+
+
+# =====
+def main() -> None:  # pylint: disable=too-many-locals,too-many-branches,too-many-statements
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    logging.getLogger("PIL").setLevel(logging.ERROR)
+
+    parser = luma_cmdline.create_parser(description="Display FQDN and IP on the OLED")
+    parser.set_defaults(**_detect_geometry())
+
+    parser.add_argument("--font", default="@ProggySquare.ttf", type=(lambda arg: _get_data_path("fonts", arg)), help="Font path")
+    parser.add_argument("--font-size", default=16, type=int, help="Font size")
+    parser.add_argument("--font-spacing", default=2, type=int, help="Font line spacing")
+    parser.add_argument("--offset-x", default=0, type=int, help="Horizontal offset")
+    parser.add_argument("--offset-y", default=0, type=int, help="Vertical offset")
+    parser.add_argument("--interval", default=5, type=int, help="Screens interval")
+    parser.add_argument("--image", default="", type=(lambda arg: _get_data_path("pics", arg)), help="Display some image, wait a single interval and exit")
+    parser.add_argument("--text", default="", help="Display some text, wait a single interval and exit")
+    parser.add_argument("--pipe", action="store_true", help="Read and display lines from stdin until EOF, wait a single interval and exit")
+    parser.add_argument("--clear-on-exit", action="store_true", help="Clear display on exit")
+    parser.add_argument("--contrast", default=64, type=int, help="Set OLED contrast, values from 0 to 255")
+    parser.add_argument("--fahrenheit", action="store_true", help="Display temperature in Fahrenheit instead of Celsius")
+    options = parser.parse_args(sys.argv[1:])
+    if options.config:
+        config = luma_cmdline.load_config(options.config)
+        options = parser.parse_args(config + sys.argv[1:])
+
+    device = luma_cmdline.create_device(options)
+    device.cleanup = (lambda _: None)
+    screen = Screen(
+        device=device,
+        font=ImageFont.truetype(options.font, options.font_size),
+        font_spacing=options.font_spacing,
+        offset=(options.offset_x, options.offset_y),
+    )
+
+    if options.display not in luma_cmdline.get_display_types()["emulator"]:
+        _logger.info("Iface: %s", options.interface)
+    _logger.info("Display: %s", options.display)
+    _logger.info("Size: %dx%d", device.width, device.height)
+    options.contrast = min(max(options.contrast, 0), 255)
+    _logger.info("Contrast: %d", options.contrast)
+    device.contrast(options.contrast)
+
+    try:
+        if options.image:
+            screen.draw_image(options.image)
+            time.sleep(options.interval)
+
+        elif options.text:
+            screen.draw_text(options.text.replace("\\n", "\n"))
+            time.sleep(options.interval)
+
+        elif options.pipe:
+            text = ""
+            for line in sys.stdin:
+                text += line
+                if "\0" in text:
+                    screen.draw_text(text.replace("\0", ""))
+                    text = ""
+            time.sleep(options.interval)
+
+        else:
+            stop_reason: (str | None) = None
+
+            def sigusr_handler(signum: int, _) -> None:  # type: ignore
+                nonlocal stop_reason
+                if signum in (signal.SIGINT, signal.SIGTERM):
+                    stop_reason = ""
+                elif signum == signal.SIGUSR1:
+                    stop_reason = "Rebooting...\nPlease wait"
+                elif signum == signal.SIGUSR2:
+                    stop_reason = "Halted"
+
+            for signum in [signal.SIGTERM, signal.SIGINT, signal.SIGUSR1, signal.SIGUSR2]:
+                signal.signal(signum, sigusr_handler)
+
+            hb = itertools.cycle(r"/-\|")  # Heartbeat
+            swim = 0
+
+            def draw(text: str) -> None:
+                nonlocal swim
+                count = 0
+                while (count < max(options.interval, 1) * 2) and stop_reason is None:
+                    screen.draw_text(
+                        text=text.replace("__hb__", next(hb)),
+                        offset_x=(3 if swim < 0 else 0),
+                    )
+                    count += 1
+                    if swim >= 1200:
+                        swim = -1200
+                    else:
+                        swim += 1
+                    time.sleep(0.5)
+
+            sensors = Sensors(options.fahrenheit)
+
+            if device.height >= 64:
+                while stop_reason is None:
+                    text = "{fqdn}\n{ip}\niface: {iface}\ntemp: {temp}\ncpu: {cpu} mem: {mem}\n(__hb__) {uptime}"
+                    draw(sensors.render(text))
+            else:
+                summary = True
+                while stop_reason is None:
+                    if summary:
+                        text = "{fqdn}\n(__hb__) {uptime}\ntemp: {temp}"
+                    else:
+                        text = "{ip}\n(__hb__) iface: {iface}\ncpu: {cpu} mem: {mem}"
+                    draw(sensors.render(text))
+                    summary = (not summary)
+
+            if stop_reason is not None:
+                if len(stop_reason) > 0:
+                    options.clear_on_exit = False
+                    screen.draw_text(stop_reason)
+                while len(stop_reason) > 0:
+                    time.sleep(0.1)
+
+    except (SystemExit, KeyboardInterrupt):
+        pass
+
+    if options.clear_on_exit:
+        screen.draw_text("")

kvmd/apps/oled/__main__.py

@@ -20,15 +20,5 @@
 # ========================================================================== #
 
 
-from typing import Any
-
-from . import check_string_in_list
-
-from .basic import valid_number
-
-
-# =====
-def valid_languages(arg: Any) -> str:
-    return check_string_in_list(arg, "Languages", ["zh", "en", "default"])
-
-
+from . import main
+main()