42tr · 博客

从零开始开发 ESP32

Wed, 23 Sep 2026 16:00:00 GMT

从零开始开发 ESP32，我把第一个目标定得很小：先让一块屏幕显示出图片，再逐步加入联网、中文排版和触摸操作。本文以 ESP42 项目为例，记录使用 ESP32-S3 开发中文资讯终端的过程，以及后续语音唤醒实验和 PCB 载板设计。

起点：硬件与开发环境

动手之前，我先向 ChatGPT 询问：从零开始做这个 ESP32 项目，需要准备哪些硬件？根据讨论整理好开发板、屏幕、连接材料和调试工具的清单，确认后再到淘宝购买。这样先把需要的东西准备齐，再一步步搭建和验证。

当时整理的购物车里，除了 ESP32-S3 开发板与 2.8 英寸 TFT 屏幕套装，还包括面包板、杜邦线、万用表，以及电阻、LED、按键等基础元件；也准备了 INMP441 麦克风、MAX98357 I2S 功放和扬声器，供后续音频实验使用。

准备硬件时的购物车记录，包含后续实验备料；具体接入终端的硬件以各阶段实现为准。

项目使用 ESP32-S3-N16R8 开发板，搭配一块 2.8 英寸、240×320 的 SPI ILI9341 屏幕，触摸控制器为 XPT2046。板载 PSRAM 用来容纳画面缓冲和较大的资讯数据，为后续联网留出内部 RAM。

最初的开发工具是 Arduino CLI，显示驱动使用 Adafruit ILI9341 和 GFX 库。仓库验证过的编译配置采用 Arduino Nano ESP32 核心，并显式启用 ESP32 GPIO 编号；这只是软件配置，实物仍是 ESP32-S3 开发板。刷写使用 esptool，串口以 115200 波特率输出诊断信息。

为了在 Windows 上继续开发 ESP-IDF 工程，我在 VSCode 中安装 Espressif 的 Espressif IDF 扩展，由扩展统一安装 ESP-IDF、Python、CMake、Ninja、编译器和 esptool，并选择 ESP32-S3 作为目标芯片。打开仓库的 firmware/ 目录后，可以在 VSCode 的 ESP-IDF 终端中执行：

idf.py set-target esp32s3
idf.py build
idf.py flash monitor

hello_tft/ 和早期 alphapulse/ 草图保留了 Arduino CLI 的快速验证路径；firmware/ 则是 ESP-IDF 的 CMake 工程外壳，通过 Arduino component 复用应用代码，并接入 esp-sr 组件和 WakeNet 模型分区。这样既能快速点亮屏幕，也能逐步进入更完整的 ESP-IDF 构建、刷写和串口监视流程。

开发顺序是先验证显示和接线，再接入网络与数据，最后完善交互和硬件载板。每完成一步，都留下可复用的示例、脚本或验证记录。

先让屏幕亮起来

项目最早从 hello_tft/ 开始。它用 SPI 驱动 ILI9341，在 ESP32-S3 上显示内置 Flash 的 RGB565 图片，不依赖 SD 卡。这个阶段先把最容易出问题的部分固定下来：LCD 控制器确实返回了 93 41，GPIO 接线和竖屏方向也在真实硬件上核对过。

这段实拍动图记录了点亮屏幕阶段的显示效果。先确认供电、SPI 接线和显示输出，再继续做软件功能。

图片转换由 tools/convert_image.py 完成，生成的 display_image.h 让普通编译不再依赖 Pillow。这样既保留了一个最小可运行的显示示例，也给后面的中文终端留下了可靠的硬件基线。

切换到树莓派开发：Linux 主机编译并写入 ESP32

硬件接线稳定后，我把开发主机切换到树莓派。树莓派运行 Raspberry Pi OS，作为一台 Linux 小主机连接开发板、屏幕和串口线；代码可以用 VSCode 远程编辑，也可以直接在终端里使用 ESP-IDF 命令行工具。这样开发板放在桌面上持续运行时，不需要一直占用 Windows 电脑。

ESP-IDF 工程的写入流程是：在树莓派上安装 ESP-IDF 和工具链，打开仓库的 firmware/ 目录，设置 ESP32-S3 目标后编译，再通过 USB 串口写入并打开监视器：

idf.py set-target esp32s3
idf.py build
idf.py -p /dev/ttyACM0 flash
idf.py -p /dev/ttyACM0 monitor

/dev/ttyACM0 是示例串口名，实际设备可能是 /dev/ttyUSB0；可以先用 ls /dev/ttyACM* /dev/ttyUSB* 检查。刷写时 ESP-IDF 会把编译出的 bootloader、分区表、应用和模型分区按地址写入 ESP32，监视器则接收 115200 波特率的启动日志和调试命令。

仓库的 hello_tft/ 和 Arduino 版 alphapulse/ 也可以在树莓派上使用 Arduino CLI 编译，再用 esptool 写入：

arduino-cli compile --fqbn arduino:esp32:nano_nora:PinNumbers=byGPIONumber \
  --output-dir alphapulse/build alphapulse
python3 -m esptool --chip esp32s3 --port /dev/ttyACM0 --baud 460800 write_flash -z \
  0x0 alphapulse/build/alphapulse.ino.bootloader.bin \
  0x8000 alphapulse/build/alphapulse.ino.partitions.bin \
  0x10000 alphapulse/build/alphapulse.ino.bin

因此，树莓派承担的是编译、串口刷写和日志观察的主机角色，真正运行资讯界面、Wi-Fi 和 WakeNet 的仍然是 ESP32-S3。

从图片演示到独立联网

alphapulse/ 是现在的主应用。设备启动后从 NVS 读取 Wi-Fi 和网站账号配置，同步时间，再通过 HTTPS 登录 Supabase 接口。证书验证没有被关闭：Google Trust Services 根证书随固件提供，令牌接近过期时刷新，刷新失败再重新登录。

资讯列表每 60 秒更新一次，每次最多取 12 条二星及以上资讯。列表只取标题、正文、来源和时间；用户打开某一条资讯后，设备才单独请求 AI 解析。这个拆分降低了自动刷新的传输量，同时让解析加载期间仍能继续阅读正文。

联网资讯列表实拍：屏幕显示更新时间、资讯标题，以及上一页、下一页和刷新按钮。

设备端页面有三个主要状态：

列表：每页显示三条资讯，上滑和下滑翻页；
正文：长文章按屏幕分页，阅读期间不会被后台刷新替换；
AI 解析：按需加载，支持分页、切换和返回列表。

网络异常时会保留当前列表并显示失败状态。首次 NTP 同步或登录超时会在设备上提示，并在 10 秒后重试。

把网络读取做成可以测试的模块

服务器不一定会主动关闭连接，因此固件没有把“读到 EOF”当作响应结束条件。HTTP 读取器兼容分块传输，设置了 30 秒读取期限和 192 KiB 解码上限：先把完整响应收进 PSRAM，再解析 JSON，避免把解析时间计入网络接收超时。

电脑端的 tests/test_body_stream.py 直接编译固件中的读取类，覆盖分块解码、超时和大小限制。这让网络边界行为可以在不接设备的情况下回归测试。

python3 tests/test_body_stream.py

较大的画面缓冲区和资讯 JSON 也放在 PSRAM，内部 RAM 留给 Wi-Fi 和 TLS。这个分配方式是联网终端能够稳定工作的基础之一。

触摸交互

屏幕触摸控制器是 XPT2046，与 LCD 共用 SPI，但使用独立的片选 GPIO5。首次启用时依次点击三个十字中心，校准结果写入 NVS；列表、正文和 AI 解析都支持滑动翻页。

交互层特别区分了点击和拖动：滑动至少 32 像素才翻页，短暂触摸断点保留 80 ms 容错，拖动不会误打开资讯。按钮和卡片在松手后短暂高亮，只有确认目标区域后才执行操作。串口还提供 tap、swipe、screenshot 等命令，触摸未接好时也能先验证页面状态机。

下面是触摸滑动查看的实拍动图：

语音唤醒

语音部分经历了两个阶段。最开始为了先验证麦克风、I2S 采样和特征计算链路，我使用个人录音训练了一个轻量的 MFCC 双中心分类器：把 1 秒音频窗口转换成 MFCC 特征，按 250 ms 步进持续分析，再比较输入特征到正负样本中心的距离。tools/train_keyword.py 和 data/wake_training.json 记录了这次离线实验；当时有 39 个可用样本，划分为 29 个训练样本和 10 个测试样本，测试集结果为 10/10。这个结果只说明小样本离线流程跑通，不能代表真实环境下的误唤醒率、距离和噪声表现。

后来运行时方案切换到 ESP-SR WakeNet。固件从 model 分区加载 wn9_ 模型，筛选关键词模型 xiaoaitongxue，以 16 kHz 单声道 I2S 音频输入运行 DET_MODE_90，检测阈值设置为 0.55。WakeNet 保留自己的循环状态，由独立任务持续读取音频并按模型要求的 chunk 大小调用 detect()；主循环只接收唤醒事件并更新界面。

当前固件唤醒成功后会输出 WAKENET_HIT，并显示 5 秒的语音反馈界面；还没有接入语音指令识别。旧的 wake_model.h、tools/train_keyword.py 和 data/wake_training.json 仍保留在仓库中，作为 MFCC 方案的历史实验资产，不是当前 WakeNet 的运行时模型或性能评估。

下面是语音唤醒的实拍视频：

当前浏览器不支持播放此视频。

接口	主要连接
J1 LCD	CS=10、RST=4、DC=2、MOSI=11、SCK=12、MISO=13
J2 Touch	共用 SPI，独立 CS=5，IRQ 暂不接
J3 Mic	I2S BCLK=15、WS=16、DATA=17
J4 Power/UART	+5V 输入、3V3 LDO、TX=43、RX=44

之前的 Codex 工作轨迹

这个仓库的工作不是一次性生成出来的，而是逐步收敛的：

显示原型：确认 ILI9341 识别、GPIO 接线、图片缩放和 RGB565 资源生成。
联网终端：加入 Wi-Fi、NTP、HTTPS 证书校验、Supabase 登录和会话续期。
中文与交互：生成 CJK 字体，实现资讯列表、正文分页、AI 解析、触摸校准和串口模拟操作。
可靠性与语音唤醒：完成 HTTP 分块读取限制和本地测试；运行时接入 ESP-SR WakeNet、I2S 采样任务和模型分区，旧的 MFCC 训练脚本作为历史实验资产保留。
硬件交付候选版：生成 KiCad 原理图和 PCB，完成布线、ERC/DRC、BOM、Gerber 和钻孔文件。

真实硬件上已经验证过：设备可以刷写并联网，获取 12 条真实资讯，自动刷新再次成功；中文列表和 AI 解析可以通过帧缓冲检查，串口模拟点击可以完成正文翻页、解析切换和返回列表；触摸三点校准结果也已经保存到板上 NVS。

碰到的问题

一开始使用的是 Arduino IDE 的 ESP32 开发板环境，原来的网络代码直接运行在 Arduino 核心上，网站访问正常。为了加载官方 WakeNet，工程后来迁移到 ESP-IDF 5.3.2，并做了几组会同时影响编译、启动和网络的改动：

Arduino 核心改成作为 ESP-IDF 组件运行；
Arduino-ESP32 核心版本随 ESP-IDF 组合发生变化；
增加 ESP-SR、WakeNet 和模型分区；
修改分区表和固件启动方式；
增加 mbedTLS 的 PSK 配置；
网络请求从原来的 Arduino 编译链切换到新的 IDF 网络栈。

迁移后 Wi-Fi 仍然可以连接，但新的 ESP-IDF / Arduino 组合在访问 Supabase HTTPS 时失败。这个现象说明“能连上 Wi-Fi”并不等于 TLS、证书、HTTP 请求和服务端接口都已经兼容；问题出现在网络请求链路，而不是射频连接本身。

当前的排查方向是保留已经接入的 WakeNet 和模型分区，只把网络部分改成 ESP-IDF 原生 esp_http_client，逐层确认时间同步、证书校验、TLS 握手、请求头和响应读取。这样可以把 Arduino HTTPClient 与 IDF 网络栈的影响拆开，避免为了修复 HTTPS 又回退语音唤醒的工程迁移。

下一步工作

接入语音转文字模块，增加语音输入处理功能
接入喇叭，增加文字转语音模块
尝试电烙铁焊接
学习 PCB 制作优化
网上项目复刻

麒麟 4.0.2 上的 Electron 适配：从运行库到现代 CSS 降级

Mon, 07 Sep 2026 16:00:00 GMT

目标是在麒麟 4.0.2 上把 CoAssist_web 打包成一个自带浏览器的桌面程序。前端项目使用 Vue 3、Vite、Tailwind v4 和 Element Plus；目标系统则以 Ubuntu 16.04 为底，只有 glibc 2.23、4.11 内核和 NSS 3.28，系统库停留在 2016 年的水平。两者之间的版本落差，决定了这不是一次常规的 Electron 打包。

最终可用的方案固定在 Electron 22.3.27（Chromium 108），并以绿色包形式交付：release/CoAssist-0.0.0-x64.tar.gz，约 90 MiB，解压即可运行。

架构：前端无需改动

桌面端没有改动任何前端请求逻辑。electron/server.cjs 在 127.0.0.1 的随机端口启动本地 HTTP 服务，负责两件事：

托管 dist/ 静态资源；
复刻 Vite 开发服务器的四条代理规则：/api、/map-api、/agent-api、/crewai，其中 WebSocket 通过 TCP 隧道转发。

前端原本就全部使用相对路径请求，因此在浏览器和 Electron 中的行为保持一致。127.0.0.1 还是安全上下文，LiveKit 的音视频权限可以正常使用。

Electron 窗口
    |
    v
127.0.0.1:<随机端口>
    |-- dist/ 静态资源
    |-- /api      -> 后端服务
    |-- /map-api  -> 地图服务
    |-- /agent-api -> Agent 服务
    `-- /crewai   -> CrewAI 服务（含 WebSocket）

排障过程：四层问题逐层剥开

1. 加载期符号不兼容

最早的错误是 GLIBC_2.25、NSS_3.30 not found。没有直接盲目降版本，而是先用 objdump -T 检查各候选 Electron 二进制的 GLIBC_、NSS_ 符号要求，快速排除不可能在 glibc 2.23 上加载的版本。

运行库的解决方式分两部分：

降低 Electron 版本；
随包携带 CentOS 7 的 NSS 3.90。该版本仅依赖 glibc 2.17，由 shell wrapper 预先设置 LD_LIBRARY_PATH。

随后又遇到 gbm_bo_get_modifier 未定义。这不是 NSS 问题，而是图形栈缺库。兼容目录继续补入 mesa-libgbm 18.3、libdrm 和 libwayland-server。

2. 运行期启动即段错误

符号加载通过后，Electron 一启动就段错误，gdb 回溯显示 rip=0 的空调用。排查按最小化原则进行：

ELECTRON_RUN_AS_NODE 能正常运行，排除 Node 本身；
直接运行裸 Electron binary 也崩溃，排除业务代码与打包资源；
Electron 22 能运行，24、25、28 都崩溃。

结论是 Chromium 版本墙，而不是应用层问题。麒麟 4.0.2 的可运行上限为 Electron 22.3.27，对应 Chromium 108；该版本需要固定，不能再按常规节奏跟进 Electron 大版本。

3. Chromium 108 无法解析现代 CSS

Electron 22 解决了运行时，却带来浏览器内核兼容问题：Chromium 108 不支持 oklch() 和 color-mix()，两者都在 Chrome 111 之后才可用。

Tailwind v4 生成的相关样式有 861 处包在 @supports 守卫中。Chromium 108 会自动跳过这部分并使用回退规则，因此无需额外处理。

需要处理的是业务样式中的裸 color-mix(in srgb, var(--token) P%, transparent/white/var(--B))，共 369 处且没有守卫。为此增加了 scripts/lower-color-mix.cjs 构建后处理：

根据 color-mix 在预乘 alpha 空间插值的规则，预计算为 var(--token-mixP-*)；
按 token 的 light/dark 主题选择器展开变体规则；
保持主题切换行为不变。

oklch() 则在 PostCSS 阶段使用 @csstools/postcss-oklab-function 生成 RGB 回退，最终将裸 oklch() 清零。

处理中还发现有 9 个 CSS 文件带 UTF-8 BOM，导致 Lightning CSS 解析失败；清理 BOM 后，兼容管线可以稳定执行。

4. 白屏并不等于加载失败

最后一个现象是页面白屏，但资源和页面实际都已加载成功。根因在绘制阶段：使用 root 运行时，X 会话属于 osystem 用户，X 授权无法通过；麒麟的安全机制还会限制 libGLESv2.so 的访问权限。

改用桌面会话用户运行后，页面可以正常绘制。这是运行环境权限问题，与 Electron、前端代码和本地 HTTP 服务无关。

交付内容

本次适配已在提交 0cd56a1 中完成并推送至 Gitea main 分支，包含：

electron/ 下的本地服务器、启动脚本和兼容运行库配置；
electron-builder.yml 打包配置；
CSS 兼容构建管线与 color-mix 降级脚本；
使用说明文档；
release/CoAssist-0.0.0-x64.tar.gz 绿色版产物。

Windows 的 NSIS 安装包仍需要在 x86 环境配合 Wine 构建，当前环境无法产出。

后续维护要点

qemu-user 不能用于验证 Electron 的运行期行为：Electron 16、23、24 都会在仿真下崩溃，这是 qemu-user 的限制，不代表真机结论。它仍可用于验证加载期符号解析；版本兼容必须回到真机测试。

面对老系统时，先用 objdump -T 检查 GLIBC_ 和 NSS_ 符号要求，通常比反复试装版本更快。CSS 降级也不应一概而论，应先区分框架已经通过 @supports 保护的特性和业务代码中的裸用特性，只处理后者。

后续如果前端引入 :has()、text-wrap 等新 CSS 特性，需要同步以 Chromium 108 为基准检查兼容性，并为未受守卫保护的样式补充构建期回退。

麒麟 Kylin 4.0.2 + 4.11 内核 Docker 安装

Sun, 06 Sep 2026 16:00:00 GMT

最近在一台麒麟 Kylin 4.0.2 的服务器上装 Docker，内核版本是 4.11。这个环境有几个限制：

系统比较老，官方 yum/apt 源里没有可用的 Docker 包，第三方源也基本不再支持这个内核版本
机器可能无法直接访问外网，或者网络受限
新版本的 Docker 对内核特性（cgroup v2、iptables-nft 等）要求越来越高，在老内核上容易翻车

综合考虑下来，最稳妥的方案是使用 Docker 官方提供的静态编译二进制包（static binaries），不依赖包管理器，对系统侵入最小，卸载也干净。版本选择上用了 20.10.24 —— 这是 20.10 系列的最后一个版本，对老内核兼容性最好，再新的 23.x/24.x 在 4.11 内核上可能遇到 iptables 或 cgroup 相关的兼容问题。

1. 下载并解压静态二进制包

cd /tmp

wget https://download.docker.com/linux/static/stable/x86_64/docker-20.10.24.tgz

tar -xzf docker-20.10.24.tgz
cp docker/* /usr/bin/
chmod +x /usr/bin/docker*

压缩包里包含完整的运行时组件：docker（CLI）、dockerd（守护进程）、containerd、containerd-shim、ctr、runc、docker-init、docker-proxy 等，全部复制到 /usr/bin/ 即可。

如果是 aarch64 架构的麒麟机器，把下载链接中的 x86_64 换成 aarch64。

2. 配置 daemon.json

mkdir -p /etc/docker

cat > /etc/docker/daemon.json <<'EOF'
{
  "storage-driver": "overlay2"
}
EOF

4.11 内核已经支持 overlay2，比默认的 devicemapper 或 vfs 性能好得多。如果机器在内网、拉镜像困难，可以顺便配上镜像加速和私有仓库地址：

{
  "storage-driver": "overlay2",
  "registry-mirrors": ["https://<你的镜像加速地址>"],
  "insecure-registries": ["<私有仓库地址>"]
}

3. 编写 systemd 服务

静态包不带服务文件，需要自己写。containerd 和 dockerd 分成两个 service，dockerd 依赖 containerd：

cat > /etc/systemd/system/containerd.service <<'EOF'
[Unit]
Description=containerd container runtime
After=network.target

[Service]
ExecStart=/usr/bin/containerd
Restart=always
RestartSec=2
LimitNOFILE=1048576
LimitNPROC=1048576
LimitCORE=infinity

[Install]
WantedBy=multi-user.target
EOF

cat > /etc/systemd/system/docker.service <<'EOF'
[Unit]
Description=Docker Application Container Engine
After=network.target containerd.service
Requires=containerd.service

[Service]
Type=notify
ExecStart=/usr/bin/dockerd --containerd=/run/containerd/containerd.sock
Restart=always
RestartSec=2
LimitNOFILE=1048576
LimitNPROC=1048576
LimitCORE=infinity

[Install]
WantedBy=multi-user.target
EOF

几个注意点：

Type=notify：dockerd 启动完成后会主动通知 systemd，避免 After 依赖判断过早
--containerd=/run/containerd/containerd.sock：显式指定使用外部 containerd，否则 dockerd 会自己拉起一个
LimitNOFILE/LimitNPROC/LimitCORE：容器场景下默认值太小容易出问题，直接放大

4. 启动并验证

systemctl daemon-reload
systemctl enable containerd
systemctl enable docker
systemctl start containerd
systemctl start docker

docker version
docker info

docker version 能同时看到 Client 和 Server 信息、docker info 正常输出系统信息（Storage Driver 应为 overlay2），就说明安装成功了。可以再跑个容器验证一下：

docker run --rm hello-world

5. 安装 Docker Compose 插件

Compose V2 以 Docker CLI 插件的形式分发，也是一个独立的静态二进制，放到插件目录即可使用：

mkdir -p /usr/local/lib/docker/cli-plugins

wget -O /usr/local/lib/docker/cli-plugins/docker-compose \
  https://github.com/docker/compose/releases/download/v2.24.7/docker-compose-linux-x86_64

chmod +x /usr/local/lib/docker/cli-plugins/docker-compose

docker compose version

正常的话会看到类似输出：

Docker Compose version v2.24.7

之后就可以正常使用 docker compose 子命令了：

docker compose up -d
docker compose ps
docker compose logs -f
docker compose down

注意 V2 的用法是 docker compose（空格，作为 docker 的子命令），不再是老版本的 docker-compose（连字符，独立命令）。如果旧脚本里还在用 docker-compose，可以加一个软链接兼容：

ln -s /usr/local/lib/docker/cli-plugins/docker-compose /usr/bin/docker-compose

常见问题

dockerd 启动报 iptables 相关错误。 老内核可能没有 xt_conntrack 等模块，或者系统默认用了 nftables。可以先 modprobe br_netfilter overlay，仍然不行的话在 daemon.json 里加 "iptables": false 绕过（代价是容器端口映射需要自己管）。

docker info 提示 swap cgroup 警告。 麒麟老版本默认没开 swap 限制，需要在 GRUB 内核参数里加 cgroup_enable=memory swapaccount=1 然后重启，不影响使用的话可以忽略。

卸载。 静态安装卸载很简单：systemctl stop docker containerd，删掉 /usr/bin/docker*、/usr/bin/containerd*、/usr/bin/runc 等二进制，再删 /etc/systemd/system/{docker,containerd}.service、/etc/docker/ 和 /var/lib/docker/ 即可。

用 OpenDataLoader PDF 搭一个兼容 MinerU 的解析服务

Sun, 09 Aug 2026 16:00:00 GMT

最近整理了一下 PDF 解析的调用链。上层应用已经按照 MinerU 的 /file_parse 接口接入，如果直接替换解析引擎，上传参数、页码规则和返回数据都要跟着修改。于是有了 opendataloader-pdf-service：在 OpenDataLoader PDF 外面加一层轻量的 FastAPI 适配器，尽量保持原有调用方式不变。

这个项目不是重新实现 PDF 解析算法。真正的版面分析、文本提取和 Markdown 生成仍由 opendataloader-pdf 完成，服务本身负责处理 HTTP 上传、参数转换、结果适配和文件打包。

一条请求是怎样完成的

项目只有一个主要接口：POST /file_parse。一次请求大致经过下面几个阶段：

multipart 上传
    ↓
分块写入任务目录
    ↓
pdfinfo 读取页数和每页尺寸
    ↓
opendataloader-pdf 生成 JSON、Markdown 和图片
    ↓
转换为兼容的 content_list
    ↓
返回 JSON，或打包为 ZIP

服务会为每次请求生成一个 8 位任务 ID，并把文件写入 output/<task_id>/。上传文件按 1 MiB 分块落盘，因此不会先把整份 PDF 全部读进内存。解析工作是同步且偏 CPU/IO 密集的，接口通过 FastAPI 的 run_in_threadpool 执行，避免直接阻塞异步事件循环。

OpenDataLoader 一次可以接收多份输入，所以批量上传的文件会在一次转换调用中完成。每个文件仍有独立的 success 或 failed 状态，最终响应还会汇总总数、成功数、失败数和耗时。

兼容层主要适配了什么

表面上看，这个服务只是把 Python 函数放到 HTTP 接口后面，实际最有价值的部分是两种数据格式之间的转换。

页码规则

接口沿用 start_page_id 和 end_page_id：从 0 开始，并且包含结束页；OpenDataLoader 的 pages 参数从 1 开始。比如：

start_page_id=0, end_page_id=2  -> pages="1-3"
start_page_id=3, end_page_id=3  -> pages="4"

如果只给起始页，服务会先通过 pdfinfo 获取总页数，再生成从起始页到末页的范围。

坐标系统

这是最容易出现“文字对了，框却飘了”的地方。OpenDataLoader 返回 PDF 坐标，原点位于左下角；MinerU 风格的 bbox 使用左上角原点，并把每一页分别归一化到 0-1000。

服务先用 pdfinfo -box 读取每页真实宽高，然后进行坐标翻转和缩放：

x' = x / page_width  * 1000
y' = (page_height - y) / page_height * 1000

最终的 bbox 固定为 [x0, y0, x1, y1] 整数数组，并限制在 0-1000 范围内。这里按页读取尺寸很重要，因为同一份 PDF 里可能同时存在横向页和纵向页，不能拿第一页的尺寸套用整份文档。

内容列表

OpenDataLoader 的文档 JSON 是树形结构，而兼容接口需要较扁平的 content_list。适配器会按元素类型转换：

普通段落、标题和列表项转换为 text；
页眉、页脚保留为 header、footer；
表格转成包含 rowspan、colspan 的 HTML；
图片转换为 image，并保留图片路径、页码和坐标。

有些图片会嵌套在列表、表格单元格或页眉中。代码会递归遍历整棵元素树，将这些图片额外提升为独立条目，避免扁平化时悄悄丢失。

当 return_images=true 时，解析器输出的图片会转换成 Data URI 放在响应的 images 字典中。既支持 OpenDataLoader JSON 已经内嵌的图片，也会扫描外部图片目录并进行 Base64 编码。

本地启动

项目使用 Python 3.11 或 3.12，并通过 uv 管理依赖。OpenDataLoader PDF 的本地解析器依赖 Java，读取 PDF 元数据还需要 Poppler 提供的 pdfinfo。

准备好 uv、Java 11+ 和 Poppler 后运行：

git clone https://github.com/42tr/opendataloader-pdf-service.git
cd opendataloader-pdf-service
uv sync
uv run uvicorn app.main:app --host 0.0.0.0 --port 8000

启动后可以访问 http://localhost:8000/docs 查看 Swagger 文档，或通过健康检查确认服务状态：

curl http://localhost:8000/health

返回结果如下：

{"status":"ok","parser":"opendataloader-pdf"}

解析一份 PDF：

curl -X POST 'http://localhost:8000/file_parse' \
  -F 'files=@./example.pdf' \
  -F 'return_md=true' \
  -F 'return_content_list=true' \
  -F 'return_images=true' \
  -o output.json

批量上传只需重复 files 字段：

curl -X POST 'http://localhost:8000/file_parse' \
  -F 'files=@./a.pdf' \
  -F 'files=@./b.pdf' \
  -F 'start_page_id=0' \
  -F 'end_page_id=4'

如果设置 response_format_zip=true，接口会返回 ZIP 文件，其中包含响应 JSON 和本次上传的 PDF。

用 Docker 部署

仓库里的 Dockerfile 使用 python:3.11-slim-bookworm，并预装 OpenJDK 17 和 poppler-utils，省去了宿主机准备解析环境的步骤：

docker build -t opendataloader-pdf-api .
docker run --rm \
  -p 8000:8000 \
  -v "$PWD/output:/app/output" \
  opendataloader-pdf-api

挂载 output 目录后，任务文件在容器退出后仍然保留。镜像通过 uv sync --frozen 按锁文件安装依赖，部署结果也更容易复现。

后端选择与兼容边界

默认的 backend=pipeline 使用 OpenDataLoader 本地 Java 解析器。传入 docling、docling-fast 或 hybrid 时会统一映射为 docling-fast，这要求另行部署 opendataloader-pdf-hybrid 服务；hancom-ai 也会原样映射到对应混合后端。其他值会回落到本地解析。

兼容不等于功能完全相同，当前有几个边界需要注意：

服务目前面向 PDF，OpenDataLoader 不原生支持 Office 文件；
formula_enable、table_enable 等字段为了兼容现有客户端会被接收，但不会改变 OpenDataLoader 的解析行为；
output_dir、语言相关字段和部分中间结果开关同样只保留接口形状；
任务目录不会自动清理，长期运行时需要额外配置定时清理或生命周期策略；
接口没有内置鉴权、限流和上传大小限制，暴露到公网前应放在网关之后。

这种适配方式的好处是把变化控制在服务端：已有客户端仍然上传同样的 multipart 表单、读取相近的结果结构，而底层解析器可以独立替换和演进。对于依赖 Markdown、版面坐标、表格和图片的 RAG 或文档入库流程，这层小小的边界转换往往比“再写一个解析器”更实用。

轻量级日志监控平台搭建

Wed, 22 Apr 2026 16:00:00 GMT

Promtail 是代理，负责收集日志并将其发送给 loki 。

Loki 是主服务器，负责存储日志和处理查询。

Grafana 用于 UI 展示。

环境部署

promtail-config.yaml

server:
  http_listen_port: 9080

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: docker

    pipeline_stages:
      - docker: {}

      # ✅ 从日志路径中提取 container_id
      - regex:
          expression: '/images/docker/containers/(?P<container_id>[a-f0-9]+)/.*\.log'

      # ✅ 把 container_id 提升为 label
      - labels:
          container_id:

    static_configs:
      - targets:
          - localhost
        labels:
          job: docker
          __path__: /images/docker/containers/*/*.log

注：我的 Docker 目录迁移了，/images/docker 改为自己的 Docker 目录

docker-compose.yaml

services:
  loki:
    image: grafana/loki:2.9.0
    ports:
      - "3100:3100"

  promtail:
    image: grafana/promtail:2.9.0
    volumes:
      # - /images/docker/containers:/var/lib/docker/containers:ro
      - /images/docker/containers:/images/docker/containers:ro
      - /var/run/docker.sock:/var/run/docker.sock
      - ./promtail-config.yaml:/etc/promtail/config.yml

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3101:3000"
    volumes:
      - ./grafana-data:/var/lib/grafana

docker compose up -d

使用

进入 3101 端口 Grafana，默认账号密码 admin/admin

配置 Connections

Save & test

测试

配置 Dashboard

Rust LanceDB 内存不足问题

Thu, 19 Mar 2026 16:00:00 GMT

报错内容：

thread '<unnamed>' (245) panicked at library/std/src/sys/pal/unix/stack_overflow.rs:231:13:
failed to set up alternative stack guard page: Cannot allocate memory (os error 12)
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

thread '<unnamed>' (246) panicked at library/std/src/sys/pal/unix/stack_overflow.rs:231:13:
failed to set up alternative stack guard page: Cannot allocate memory (os error 12)
2026-03-19 15:07:33 [lance_io::local] DEBUG - get_range: range=713265..717361

thread '<unnamed>' (247) panicked at library/std/src/sys/pal/unix/stack_overflow.rs:227:13:
failed to allocate an alternative stack: Cannot allocate memory (os error 12)
2026-03-19 15:07:33 [lance_io::local] DEBUG - open; path=Path { raw: "app/data/lancedb_data/documents.lance/data/3836854-10fc-49da-af99-3315c0982ed4.lance" } block-size=4096 know.
fatal runtime error: failed to initiate panic, error fatal runtime error: failed to initiate panic, error fatal runtime error: failed to initiate panic, error 555, aborting
, aborting
, aborting
memory allocation of 41 bytes failed

猜测一：RAM 不足

从报错可以看到是内存分配失败，启动时监控内存 free -mh，内存变化不大，确认不是 RAM 不足。

猜测二：Docker 容器限制

猜测是 Docker 容器限制了内存使用，修改 docker-compose.yaml

services:
  app:
    image: your-image
    mem_limit: 128g

发现还是不行。

猜测三：虚拟内存不足

根据AI推理，修改 stack 大小

services:
  app:
    ulimits:
      stack: 1024

仍然不行。

尝试增加 swap，依然不行。

猜测四：mmap（实际问题）

因为 lancedb 会把数据读到 mmap 提高访问速度

查询系统允许的最大 mmap 数量

> cat /proc/sys/vm/max_map_count
262162 /proc/2440330/maps

查询 mmap 数量

pid=$(pgrep -f '/app/htknow|htknow' | head -n1)
wc -l /proc/$pid/maps

临时修改

sysctl -w vm.max_map_count=1048576

再启动就 ok 了，确认是该问题。

持久化配置

echo 'vm.max_map_count=2097152' | sudo tee /etc/sysctl.d/99-htknow.conf
sudo sysctl --system

克鲁斯卡尔（Kruskal）算法

Wed, 18 Mar 2026 16:00:00 GMT

克鲁斯卡尔算法（Kruskal Algorithm）是一种用于求解最小生成树（Minimum Spanning Tree, MST）的经典贪心算法，适用于无向加权图。

核心思想：每次选择当前权重最小、且不会形成环的边加入生成树。

关键点：使用并查集判断是否会形成环。

时间复杂度

排序边：O(E log E)
并查集操作：近似 O(E α(N))（α 是反阿克曼函数，极小）

总体复杂度：O(E log E)

代码：

def kruskal(n: list, edges: list[list[int]]): # [[端点1, 端点2, 权重], ...]
    edges.sort(key=lambda x: x[2])  # 按权重排序
    dsu = DSU(n)
    mst = []
    
    for u, v, w in edges:
        if dsu.find(u) == dsu.find(v):
            continue
        dsu.union(u, v)
        mst.append((u, v, w))
  
    return mst

练习题：3600.升级后最大生成树稳定性

并查集

Wed, 11 Mar 2026 16:00:00 GMT

并查集（Union Find / Disjoint Set Union） 是一种用于管理分组的数据结构（一般使用树形结构来表示）~

（1）Find：查询 a 元素和 b 元素是否为同一组（只需要判断他们的 root 根节点是否为同一个即可）

（2）Union：合并元素 a 和 b 为同一组

代码

class DSU:
    def __init__(self, parent: list[int]):
        this.parent = parent
        
    def find(self, x: int):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]
        
    def union(self, x: int, y: int):
        px = self.find(x)
        py = self.find(y)
        self.parent[px] = py

PageIndex架构分析

Thu, 05 Mar 2026 16:00:00 GMT

PageIndex 的核心目标是解决一个问题：

如何让 LLM 高质量理解长文档，并实现精准搜索。

传统 RAG 的问题：

文档 chunk 切得很碎
结构信息丢失
搜索结果上下文不完整
LLM 容易产生幻觉

PageIndex 的思路是：

先理解文档结构 → 再建立树状索引 → 再做向量搜索

而不是直接 chunk。

整个系统可以拆成两个阶段：

离线阶段（Indexing）

文档解析 → 结构提取 → 索引构建 → 向量存储

在线阶段（Query）

用户问题 → 向量搜索 → 结构补全 → LLM回答

一、文档解析流程（Document Parsing）

文档解析的目标是：

把 PDF / Word / Markdown 转换成可理解的结构化数据

典型输入：

PDF
Word
Markdown
HTML

解析流程如下。

1 文档加载

首先系统加载原始文档。

核心任务：

读取文档
转换为文本
保留基础结构

可能用到的工具：

pdf parser
docx parser
html parser

输出类似：

{
  "pages": [
    {
      "text": "...",
      "layout": "..."
    }
  ]
}

此时仍然是原始文本。

2 文档结构解析

接下来需要识别文档结构。

系统会识别：

标题（H1 / H2 / H3）
段落
列表
表格
代码块

例如：

原文：

1. Introduction
This paper introduces...
2. Method

会被解析成：

[
  { "type": "heading", "level": 1, "text": "Introduction" },
  { "type": "paragraph", "text": "This paper introduces..." },
  { "type": "heading", "level": 1, "text": "Method" }
]

这一步的意义是：

恢复文档逻辑结构。

3 LLM 推理生成初始目录

如果文档结构不明显（很多 PDF 都这样），系统会调用 LLM。

让 LLM：

根据文本推断文档目录结构

例如：

输入：

大量文本

输出：

1 Introduction
2 Background
3 Method
4 Experiment

这一步得到：

Document Outline

也就是 初始目录线索。

4 构建文档树（Document Tree）

有了标题信息之后，就可以生成文档树结构。

例如：

Document
 ├── Introduction
 │     ├── paragraph
 │     └── paragraph
 │
 ├── Method
 │     ├── subsection
 │     └── subsection
 │
 └── Experiment

内部结构通常是：

Node {
    title
    level
    content
    children
}

这样每一段文本都有：

父节点
子节点
层级关系

这就是 PageIndex 的核心结构。

5 文档 Chunk 切分

接下来系统会生成检索单元。

但和传统 RAG 不同：

不是固定长度切分

而是：

按结构切分

例如：

Section
Subsection
Paragraph

形成 chunk：

chunk_1 = "Introduction section"
chunk_2 = "Method subsection"
chunk_3 = "Experiment subsection"

同时保留：

parent
section path

例如：

path = Introduction > Background

这对于搜索非常重要。

6 Embedding 向量化

然后系统会对每个 chunk 生成向量存入向量库

7 构建索引

最终索引包含：

text
embedding
tree path
node id
parent id

例如：

{
  "text": "...",
  "vector": [...],
  "path": "Method > Architecture",
  "node_id": 123
}

到这里 离线阶段完成。

二、搜索流程（Query Pipeline）

当用户提问时，系统开始在线搜索流程。

1 Query 解析

用户输入：

How does the method work?

系统会：

清洗 query
生成 embedding

得到：

query vector

2 向量搜索

在向量数据库中查找 TopK 相似 chunk

Method section
Architecture subsection
Algorithm description

这是第一层召回。

3 结构补全

如果只返回 chunk，LLM 很可能缺上下文。

所以 PageIndex 会：

补充父节点
补充兄弟节点
补充上下文

例如：

原始 chunk：

Algorithm Step 2

系统会扩展为：

Method
 └ Algorithm
      ├ Step1
      ├ Step2
      └ Step3

这样上下文完整。

4 上下文重排序

如果 chunk 很多，需要排序。

排序依据：

embedding 相似度
文档结构距离
LLM rerank

最终选择：Top N context

5 构造 LLM Prompt

系统构造 Prompt：

Context:
[document chunks]

Question:
user query

例如：

Answer based on the following document.

6 LLM 生成答案

最后调用 LLM 输出：

final answer

同时可能附带：

引用来源
section path

例如：

Source: Method > Architecture

三、核心算法

1. 文档树生成算法

核心思想：

把文档转换成类似 HTML DOM 的树结构

结构示意：

Document
 ├── Section
 │     ├── Subsection
 │     │       ├── Paragraph
 │     │       └── Paragraph
 │     └── Subsection
 └── Section

每个节点都保存：

Node
 ├ id
 ├ title
 ├ content
 ├ level
 ├ parent
 └ children

构建流程通常是三阶段。

1 结构元素检测

首先解析文本块类型：

heading
paragraph
list
table
code

例如：

1 Introduction
This paper proposes...

解析结果：

Heading(level=1)
Paragraph

在 PDF 场景下，通常还会利用：

字体大小
字体粗细
行距
版面布局

来识别标题。

例如：

FontSize > 18 → H1
FontSize > 14 → H2

这样可以初步恢复文档结构。

2 层级推断

如果文档本身没有明确层级（很多 PDF 都是这样），就需要推断。

典型方法：

方法1：规则推断

例如：

1
1.1
1.1.1

直接转换成：

level1
level2
level3

方法2：LLM 推断

当结构不清晰时，让 LLM 推理：

输入：

大量文本片段

输出：

Possible outline:
1 Introduction
2 Background
3 Method

但注意：

不会把整个文档给 LLM。

而是：

抽样片段 + 标题候选

这样 token 很小。

3 树结构构建

当拿到标题层级之后，构建树结构。

伪代码：

stack = []

for element in elements:
    if element is heading:
        while stack.top.level >= element.level:
            stack.pop()

        stack.top.children.append(element)
        stack.push(element)

    else:
        stack.top.children.append(element)

最终得到：

Document Tree

优势：

结构清晰
支持父子检索
支持上下文扩展

搜索时的结构扩展策略

普通 RAG 的最大问题：

chunk 太碎

例如：

Algorithm Step 2

LLM 根本不知道：

Step1
Step3

PageIndex 的解决办法是：

结构扩展（Structure Expansion）

流程如下。

1 初始向量召回

首先正常向量搜索：

query embedding
↓
vector search
↓
topK chunks

例如：

Chunk A
Chunk B
Chunk C

但这些 chunk 只是局部。

2 向上扩展（Parent Expansion）

系统会找：

父节点

例如：

原始结果：

Algorithm Step 2

扩展后：

Method
 └ Algorithm
      └ Step 2

这样 LLM 就知道：

这是 Method 章节里的算法

3 向下扩展（Child Expansion）

如果 chunk 是一个标题节点：

Algorithm

系统会补充：

Algorithm
 ├ Step1
 ├ Step2
 └ Step3

这样内容更完整。

4 兄弟节点扩展（Sibling Expansion）

有时需要增加相邻信息：

Step1
Step2
Step3

而不是只给：

Step2

这样能明显提高回答质量。

5 Token Budget 控制

扩展不是无限的。

系统会控制：

max_tokens

例如：

4000 tokens context

策略：

优先保留最相关 chunk
逐层扩展
直到 token 满

类似：

relevance-first expansion

LLM 生成目录为什么不会超上下文

很多人看到 PageIndex 的一个步骤：

LLM 推理生成文档目录

会有疑问：

文档几百页，LLM 怎么可能读完？

实际上它用了分层策略。

1 文档分段

首先文档会被切成块：

chunk size ≈ 500 tokens

例如：

chunk1
chunk2
chunk3
...

每个 chunk 单独分析。

2 局部目录生成

LLM 对每一小段生成：

local outline

例如：

chunk1 → Introduction
chunk2 → Method
chunk3 → Experiment

3 Outline 合并

系统再把这些 outline 合并：

merge outlines

类似：

map-reduce

过程：

local outline
     ↓
merge
     ↓
global outline

4 层级压缩

如果目录太长，还会压缩：

例如：

原始：

1 Introduction
1.1 Motivation
1.2 Background
2 Method
2.1 Architecture
2.2 Training

压缩为：

Introduction
Method
Experiment

这样 token 极小

rust内存分析

Thu, 29 Jan 2026 16:00:00 GMT

环境准备

需要 jeprof 工具解析 heap 文件 apt install libjemalloc-dev graphviz

代码

cargo.toml

[package]
name = "test260202"
version = "0.1.0"
edition = "2024"

[dependencies]
tikv-jemallocator = { version = "0.6", features = ["profiling"] }
tikv-jemalloc-ctl = { version = "0.6", features = ["profiling", "use_std"] }

main.rs

#[global_allocator]
static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;

#[unsafe(export_name = "_rjem_malloc_conf")]
// lg_prof_sample:0 表示每次分配都采样(最详细,但性能开销大)
// lg_prof_sample:10 表示每 1KB 采样一次(推荐)
// lg_prof_sample:19 表示每 512KB 采样一次(默认值)
pub static MALLOC_CONF: &[u8] = b"prof:true,prof_active:true,lg_prof_sample:10\0";

use std::{
    ffi::CString,
    fs,
    process::Command,
    time::{Duration, SystemTime, UNIX_EPOCH},
};

use tikv_jemalloc_ctl::raw;
fn main() {
    let mut keep = Vec::new();
    for _ in 0..1024 {
        keep.push(vec![0u8; 4096]);
    }
    std::thread::sleep(Duration::from_millis(200));

    let path = heap_profile_pdf_impl();
    println!("Heap profile PDF saved to {}", path.display());
    std::mem::forget(keep);
}

fn heap_profile_pdf_impl() -> std::path::PathBuf {
    let pid = std::process::id();
    let ts = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("SystemTime error")
        .as_secs();

    // 生成 heap dump 文件
    let heap_filename = format!("heap.{}.{}.heap", pid, ts);
    let mut heap_path = std::env::temp_dir();
    heap_path.push(&heap_filename);
    let heap_path_str = heap_path.to_string_lossy().into_owned();
    let c_path =
        CString::new(heap_path_str.clone()).expect("Failed to create C string for heap path");

    // 导出 heap dump
    println!("Generating heap dump: {}", heap_path_str);
    let ptr = c_path.as_ptr();
    unsafe {
        raw::write(b"prof.dump\0", ptr).expect("jemalloc heap dump failed");
    }

    // 生成 PDF 文件
    let pdf_filename = format!("heap.{}.{}.pdf", pid, ts);
    let mut pdf_path = std::env::current_dir().expect("Failed to get current dir");
    pdf_path.push(&pdf_filename);
    let pdf_path_str = pdf_path.to_string_lossy().into_owned();

    // 获取当前二进制文件路径
    let binary_path = std::env::current_exe().expect("Failed to get binary path");
    let binary_path_str = binary_path.to_string_lossy();

    println!(
        "Running jeprof: binary={}, heap={}, output={}",
        binary_path_str, heap_path_str, pdf_path_str
    );

    // 执行 jeprof 命令
    let output = Command::new("jeprof")
        .arg("--pdf")
        .arg(binary_path_str.as_ref())
        .arg(&heap_path_str)
        .output()
        .expect("Failed to execute jeprof (make sure jeprof is installed)");

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        let _ = fs::remove_file(&heap_path);
        panic!("jeprof execution failed: {}", stderr);
    }

    // 读取生成的 PDF
    let pdf_bytes = output.stdout;
    if pdf_bytes.is_empty() {
        let _ = fs::remove_file(&heap_path);
        panic!("jeprof generated empty PDF");
    }

    fs::write(&pdf_path, &pdf_bytes).expect("Failed to write PDF");

    // 清理临时文件
    let _ = fs::remove_file(&heap_path);

    println!(
        "Successfully generated heap profile PDF: {} bytes",
        pdf_bytes.len()
    );

    pdf_path
}

使用

cargo run 在当前目录生成文件 heap.3742391.1770170243.pdf，可以加到 debug 中实时生成 heap 文件，pdf 文件可后续有问题时再解析，也可以使用其他方式处理 heap 文件。

算力

Tue, 06 Jan 2026 16:00:00 GMT

估算方式

CPU：核心数 × 主频 × 每核心每周期 FP32 FLOPs ≈ FP32 GFLOPS
GPU：CUDA cores × 主频 × 2

树莓派

# lscpu
Architecture:             aarch64
  CPU op-mode(s):         32-bit, 64-bit
  Byte Order:             Little Endian
CPU(s):                   4
  On-line CPU(s) list:    0-3
Vendor ID:                ARM
  Model name:             Cortex-A72
    Model:                3
    Thread(s) per core:   1
    Core(s) per cluster:  4
    Socket(s):            -
    Cluster(s):           1
    Stepping:             r0p3
    CPU max MHz:          1800.0000
    CPU min MHz:          600.0000
    BogoMIPS:             108.00
    Flags:                fp asimd evtstrm crc32 cpuid
Caches (sum of all):
  L1d:                    128 KiB (4 instances)
  L1i:                    192 KiB (4 instances)
  L2:                     1 MiB (1 instance)
Vulnerabilities:
  Gather data sampling:   Not affected
  Itlb multihit:          Not affected
  L1tf:                   Not affected
  Mds:                    Not affected
  Meltdown:               Not affected
  Mmio stale data:        Not affected
  Reg file data sampling: Not affected
  Retbleed:               Not affected
  Spec rstack overflow:   Not affected
  Spec store bypass:      Vulnerable
  Spectre v1:             Mitigation; __user pointer sanitization
  Spectre v2:             Vulnerable
  Srbds:                  Not affected
  Tsx async abort:        Not affected

注：

支持 NEON SIMD，128-bit
FP32 SIMD vector 长度 4 → 每周期 4 FLOPs
Cortex-A72 可以做 FMA（乘加） → 每周期 8 FLOPs

理论峰值算力 = 4 × 1.8 GHz × 8 = 57.6 GFLOPS（FP32）

ARM + 内存带宽限制较明显，经验值：

实际可用 FP32：30% ~ 60% ≈ 17 ~ 35 GFLOPS

mac mini m1

CPU

FP32 GFLOPS = (P核 × P频率 + E核 × E频率) × 8

sysctl -n hw.perflevel0.physicalcpu   # 性能核（P-core）
sysctl -n hw.perflevel1.physicalcpu   # 能效核（E-core）

看芯片型号

sysctl -n machdep.cpu.brand_string

芯片	P 核频率	E 核频率
M1	~3.2 GHz	~2.0 GHz
M2	~3.5 GHz	~2.4 GHz
M3	~4.0 GHz	~2.8 GHz

$ sysctl -n hw.perflevel0.physicalcpu
6

$ sysctl -n hw.perflevel1.physicalcpu
2

$ sysctl -n machdep.cpu.brand_string
Apple M1 Pro

算力 ≈ ( 6 x 3.2 + 2 x 2.0 ) x 8 = 185.6 GFLOPS

Apple Silicon 内存带宽强，但调度保守：

实际可用 FP32 ≈ 60% ~ 80%

≈ 110 ~ 150 GFLOPS

GPU

$ system_profiler SPDisplaysDataType

Graphics/Displays:

    Apple M1 Pro:

      Chipset Model: Apple M1 Pro
      Type: GPU
      Bus: Built-In
      Total Number of Cores: 14
      Vendor: Apple (0x106b)
      Metal Support: Metal 4
      Displays:
        Color LCD:
          Display Type: Built-in Liquid Retina XDR Display
          Resolution: 3024 x 1964 Retina
          Main Display: Yes
          Mirror: Off
          Online: Yes
          Automatically Adjust Brightness: Yes
          Connection Type: Internal

官方参考 FP32 理论峰值

芯片 / 核心数	FP32 TFLOPS
M1 Pro 14 核	~2.3 TFLOPS
M1 Pro 16 核	~2.6 TFLOPS

Linux 服务器

$ lscpu
Architecture:             x86_64
  CPU op-mode(s):         32-bit, 64-bit
  Address sizes:          46 bits physical, 57 bits virtual
  Byte Order:             Little Endian
CPU(s):                   128
  On-line CPU(s) list:    0-127
Vendor ID:                GenuineIntel
  Model name:             INTEL(R) XEON(R) GOLD 6530
    CPU family:           6
    Model:                207
    Thread(s) per core:   2
    Core(s) per socket:   32
    Socket(s):            2
    Stepping:             2
    CPU max MHz:          4000.0000
    CPU min MHz:          800.0000
    BogoMIPS:             4200.00
    Flags:                fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx pdpe1gb rdtscp lm constant_tsc a
                          rt arch_perfmon pebs bts rep_good nopl xtopology nonstop_tsc cpuid aperfmperf tsc_known_freq pni pclmulqdq dtes64 ds_cpl vmx smx est tm2 ssse3 sdbg fma cx16 xtpr p
                          dcm pcid dca sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand lahf_lm abm 3dnowprefetch cpuid_fault epb cat_l3 cat_l2 cdp_l3 intel_pp
                          in cdp_l2 ssbd mba ibrs ibpb stibp ibrs_enhanced tpr_shadow flexpriority ept vpid ept_ad fsgsbase tsc_adjust bmi1 avx2 smep bmi2 erms invpcid cqm rdt_a avx512f avx
                          512dq rdseed adx smap avx512ifma clflushopt clwb intel_pt avx512cd sha_ni avx512bw avx512vl xsaveopt xsavec xgetbv1 xsaves cqm_llc cqm_occup_llc cqm_mbm_total cqm_
                          mbm_local split_lock_detect user_shstk avx_vnni avx512_bf16 wbnoinvd dtherm ida arat pln pts vnmi avx512vbmi umip pku ospke waitpkg avx512_vbmi2 gfni vaes vpclmulq
                          dq avx512_vnni avx512_bitalg tme avx512_vpopcntdq la57 rdpid bus_lock_detect cldemote movdiri movdir64b enqcmd fsrm md_clear serialize tsxldtrk pconfig arch_lbr ib
                          t amx_bf16 avx512_fp16 amx_tile amx_int8 flush_l1d arch_capabilities
Virtualization features:
  Virtualization:         VT-x
Caches (sum of all):
  L1d:                    3 MiB (64 instances)
  L1i:                    2 MiB (64 instances)
  L2:                     128 MiB (64 instances)
  L3:                     320 MiB (2 instances)
NUMA:
  NUMA node(s):           2
  NUMA node0 CPU(s):      0-31,64-95
  NUMA node1 CPU(s):      32-63,96-127
Vulnerabilities:
  Gather data sampling:   Not affected
  Itlb multihit:          Not affected
  L1tf:                   Not affected
  Mds:                    Not affected
  Meltdown:               Not affected
  Mmio stale data:        Not affected
  Reg file data sampling: Not affected
  Retbleed:               Not affected
  Spec rstack overflow:   Not affected
  Spec store bypass:      Mitigation; Speculative Store Bypass disabled via prctl
  Spectre v1:             Mitigation; usercopy/swapgs barriers and __user pointer sanitization
  Spectre v2:             Mitigation; Enhanced / Automatic IBRS; IBPB conditional; RSB filling; PBRSB-eIBRS SW sequence; BHI BHI_DIS_S
  Srbds:                  Not affected
  Tsx async abort:        Not affected

注：

Xeon Gold 6530 支持 AVX512
每个 AVX512 vector 寄存器 512 bit → 16 FP32 per vector
CPU 支持 FMA（乘加） → 每周期每核心可以执行 32 FLOPs

2 × Intel Xeon Gold 6530，一共 128 逻辑核心（64 物理核心 × 2 超线程）

理论峰值算力 = 64 × 4 GHz × 32 = 8.2 TFLOPS（FP32）

实际可用通常 70–80% ≈ 5.74 ~ 6.56 TFLOPS

$ nvidia-smi
Wed Jan  7 17:51:05 2026
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 570.169                Driver Version: 570.169        CUDA Version: 12.8     |
|-----------------------------------------+------------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  NVIDIA GeForce RTX 4090        Off |   00000000:4B:00.0 Off |                  Off |
| 30%   29C    P8              8W /  450W |    7449MiB /  24564MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+
|   1  NVIDIA GeForce RTX 4090        Off |   00000000:4C:00.0 Off |                  Off |
| 30%   31C    P8              8W /  450W |   21079MiB /  24564MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+
|   2  NVIDIA GeForce RTX 4090        Off |   00000000:4E:00.0 Off |                  Off |
| 30%   29C    P8             10W /  450W |    3457MiB /  24564MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+
|   3  NVIDIA GeForce RTX 4090        Off |   00000000:4F:00.0 Off |                  Off |
| 30%   31C    P8              7W /  450W |    2007MiB /  24564MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+
|   4  NVIDIA GeForce RTX 4090        Off |   00000000:CB:00.0 Off |                  Off |
| 30%   33C    P8              7W /  450W |   20443MiB /  24564MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+
|   5  NVIDIA GeForce RTX 4090        Off |   00000000:CC:00.0 Off |                  Off |
| 30%   34C    P8              5W /  450W |   20359MiB /  24564MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+
|   6  NVIDIA GeForce RTX 4090        Off |   00000000:CE:00.0 Off |                  Off |
| 30%   31C    P8              7W /  450W |   20359MiB /  24564MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+
|   7  NVIDIA GeForce RTX 4090        Off |   00000000:CF:00.0 Off |                  Off |
| 30%   32C    P8              5W /  450W |   22098MiB /  24564MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+

GPU	CUDA 核心	基本时钟	FP32 计算能力
RTX 4090	16,384	2.23 GHz	~82.6 TFLOPS（FP32）

82.6 TFLOPS × 8 ≈ 660 TFLOPS（理论峰值）

实际可用（70–80%）≈ 450–500 TFLOPS

对比

项目	树莓派 4	M1 Pro	服务器
理论 FP32	~58 GFLOPS	~186 GFLOPS	8.2 TFLOPS
实际 FP32	~20–30	~110–150	5.12 ~ 6.56
倍数	1×	~5–6×	~170-328x

项目	树莓派 4	M1 Pro	服务器
GPU FP32	~10 GFLOPS	~2.6 TFLOPS	~660 TFLOPS
AI / 专用计算单元	❌	Neural Engine ≈ 11 TOPS	Tensor Core（4090）≈ 1300+ TOPS INT8

M1 Pro ≈ 树莓派 100×

8×4090 服务器 ≈ M1 Pro 60×

服务器 ≈ 树莓派 8000×

轻量化部署 git server

Wed, 03 Dec 2025 16:00:00 GMT

创建用户

adduser git

切换到 git 用户

su - git

创建裸仓库

没有工作目录，专用于服务器存储，不能直接编辑文件

mkdir -p /home/git/myproject.git
cd /home/git/myproject.git
git init --bare

创建钩子脚本

vim /home/git/myproject.git/hooks/post-receive
# 赋予执行权限
chmod +x /home/git/myproject.git/hooks/post-receive

钩子脚本内容

#!/bin/bash
# 执行你的自定义脚本
/path/to/your/script.sh
# 可选：输出日志到文件（调试用）
# echo "$(date): Push received" >> /tmp/git-hook.log

使用

git remote set-url origin ssh://git@42tr.cn:8899/home/git/x.git

本地使用

git clone ssh://git@127.0.0.1/home/git/x.git

钩子脚本权限问题 sudo visudo 增加一行

git ALL=(root) NOPASSWD: /path/to/your/script.sh

然后钩子脚本中改用 sudo /path/to/your/script.sh 执行

rust 性能测试

Wed, 19 Nov 2025 16:00:00 GMT

Cargo.toml

[package]
name = "test01"
version = "0.1.0"
edition = "2024"

[dependencies]
rand = "0.9.2"
rand_xoshiro = "0.7.0"
rayon = "1.11.0"

main.rs

use rand_xoshiro::Xoshiro256PlusPlus;
use rand::{RngCore, SeedableRng};
use std::fs::File;
use std::io::{BufWriter, Write};
use std::time::Instant;
use rayon::prelude::*;   // ← 需要这个

const CHARSET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const LINE_LEN: usize = 100;
const BATCH: usize = 100000;
const TOTAL_LINE: usize = 10_000_000;
const THREAD_NUM: usize = 8;

fn main() {
    rayon::ThreadPoolBuilder::new()
        .num_threads(THREAD_NUM)
        .build_global()
        .unwrap();

    let start = Instant::now();

    (0..THREAD_NUM).into_par_iter().for_each(|chunk| {
        let mut rng = Xoshiro256PlusPlus::seed_from_u64(123456 + chunk as u64);

        let filename = format!("log{}.txt", chunk);
        let file = File::create(filename).unwrap();
        let mut writer = BufWriter::new(file);

        let mut buf = vec![0u8; BATCH * LINE_LEN];

        for _ in 0..(TOTAL_LINE / THREAD_NUM / BATCH) {
            rng.fill_bytes(&mut buf);

            for b in &mut buf {
                *b = CHARSET[(*b & 63) as usize];
            }

            writer.write_all(&buf).unwrap();
        }

        writer.flush().unwrap();
    });

    println!("Time: {:?}", start.elapsed());
}

在 m1 macbook pro 8c 上

Time: 1.50388325s

邮件清理

Tue, 18 Nov 2025 16:00:00 GMT

`cargo.toml`

[package]
name = "email_helper"
version = "0.1.0"
edition = "2024"

[dependencies]
imap = "2.4"
native-tls = "0.2"
mailparse = "0.14"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
anyhow = "1"
chrono = { version = "0.4", features = ["serde"] }
encoding_rs = "0.8"

`main.rs`

use std::net::TcpStream;

use anyhow::Result;
use imap::{
    Session,
    types::{Fetch, Flag, ZeroCopy},
};
use mailparse::{MailHeaderMap, parse_mail};
use native_tls::{TlsConnector, TlsStream};

fn main() -> Result<()> {
    let imap_server = "smtp.qq.com";
    let imap_port = 993;
    let username = "xxx";
    let password = "xxx"; // 授权码

    // 创建 TLS 连接
    let tls = TlsConnector::builder().build()?;
    let client = native_tls::TlsConnector::connect(
        &tls,
        imap_server,
        std::net::TcpStream::connect((imap_server, imap_port))?,
    )?;

    // 使用 imap 2.4 登录
    let mut imap_session = imap::Client::new(client)
        .login(username, password)
        .map_err(|e| e.0)?;

    // 选择 INBOX
    let mailbox = imap_session.select("INBOX")?;
    println!("Total messages in INBOX: {}", mailbox.exists);

    let batch_size = 100;
    let mut start = 1;
    let total = mailbox.exists;
    while start <= total {
        let end = std::cmp::min(start + batch_size - 1, total);
        let sequence_set = format!("{}:{}", start, end);
        println!("Fetching emails {}-{}", start, end);

        let messages = imap_session.fetch(&sequence_set, "(UID FLAGS BODY.PEEK[])")?;
        println!("Fetched {} messages", messages.len());
        let result = handle_messages(&messages, &mut imap_session);
        if result.is_err() {
            println!("Error handling messages: {}", result.err().unwrap());
        }
        start += batch_size;
    }

    // 删除标记的邮件
    imap_session.expunge()?;

    imap_session.logout()?;
    println!("Completed");
    Ok(())
}

fn handle_messages(
    messages: &ZeroCopy<Vec<Fetch>>,
    session: &mut Session<TlsStream<TcpStream>>,
) -> Result<()> {
    for msg in messages.iter() {
        let uid = msg.uid;
        if uid.is_none() {
            println!("uid is none");
            continue;
        }
        let uid = uid.unwrap();
        if let Some(body) = msg.body() {
            let parsed = parse_mail(body)?;

            // 邮件头
            let subject = parsed
                .headers
                .get_first_value("Subject")
                .unwrap_or_default();
            let from = parsed.headers.get_first_value("From").unwrap_or_default();
            let seen = msg.flags().iter().any(|f| matches!(f, Flag::Seen));
            if !seen {
                println!("Email '{}' (UID {}) has not been seen", subject, uid);
                continue;
            }
            if from.contains("联想") || subject.contains("校招") || subject.contains("应聘")
                || subject.contains("校园招聘") || from.contains("校园招聘") || from.contains("校招") || from.contains("yunying1@alimail.zhaopin.com") || from.contains("service@steelport.zhaopin.com") || from.contains("RMASERVER@msi.com") || from.contains("billing@microsoft.com") || from.contains("noreply@steampowered.com") || from.contains("MicrosoftOffice365@email.office.com") || subject.contains("投递进度") || from.contains("no-reply@gitmail.oschina.net") || from.contains("imooc@dm.mukewang.com")
                || subject.contains("漫画更新")
                || subject.contains("ACM TechNews")
                || subject.contains("简单百宝箱")
                || subject.contains("启动完成")
                || (subject.contains("提醒") && from.contains("1055894396@qq.com"))
                || subject.contains("This is jumpserver.")
                || subject.contains("对您很感兴趣，邀您沟通")
                // 阿里云
                || from.contains("aliyun.com")
                // GitHub
                || from.contains("notifications@github.com")
                || subject.contains("[GitHub]")
                // other
                || from.contains("acmhelp@acm.org")
                || from.contains("no-reply@unity3d.com")
                || subject.contains("验证码") || subject.contains("Verification Code") || subject.contains("统一身份认证平台通知") || subject.contains("激活码") || subject.contains("email verification code") || subject.contains("用户注册确认") || subject.contains("Verify your email address")
                || from.contains("support@codepen.io") || from.contains("noreply@topcoder.com") || from.contains("music@tencent.com") || from.contains("cloud_noreply@tencent.com")
                || from.contains("ccfdigital@ccfservice.cn")
                || from.contains("csdn.net")
                || from.contains("51job.com")
                || from.contains("noreply@icloud.com.cn")
                || from.contains("no-reply@email.leetcode.cn") || from.contains("no-reply@email.leetcode-cn.com") || from.contains("no-reply@leetcode.com")
                || from.contains("admin@qq.com") || from.contains("10000@qq.com")
                || from.contains("topcoder.com")
                || subject.contains("安全提醒")
                || from.contains("support@codepen.io")
                || from.contains("huawei_ebg@research-satisfaction.com")
                || from.contains("contact@gitpod.io")
                || from.contains("no_reply@email.apple.com") || from.contains("shipping_notification@orders.apple.com") || from.contains("MarketResearch@insideapple.apple.com>") || from.contains("contact@scenario.com") || from.contains("no-reply@email.apple.com") || from.contains("do_not_reply@apple.com") || from.contains("OnlineResearch@insideapple.apple.com")
                || from.contains("info@service.yuque.com")
                || from.contains("noreply@shmail.ibeisen.com")
                || from.contains("noreply@blizzardgames.cn")
                || from.contains("updates-noreply@linkedin.com")
                || from.contains("no-reply@notify.docker.com")
                || from.contains("maya@meilisearch.com")
                || from.contains("notifications@gitbook.com")
                || from.contains("noreply@wakatime.com")
                || from.contains("hello@promos.memrise.com") || from.contains("elasticon@elastic.co") || from.contains("replies@oracle-mail.com") || from.contains("jobs-listings@linkedin.com") || from.contains("support@gitguardian.com") || from.contains("e@notification.coding.net") || from.contains("membership@ccf.org.cn") || from.contains("developer@photonengine.com") || from.contains("film@tencent.com") || from.contains("welcome@openrouter.ai")
            {
                // 标记删除
                let uid = msg.uid.ok_or("无法获取 UID").unwrap();
                session.uid_store(uid.to_string(), "+FLAGS (\\Deleted)")?;
                session.expunge()?;
                println!("Marked email '{}' (UID {}) for deletion", subject, uid);
            }
        }
    }
    Ok(())
}

离线环境下实现经纬度与地区名称双向转换

Sun, 12 Oct 2025 16:00:00 GMT

在很多实际应用场景中，我们无法依赖网络请求（如高德、百度地图 API），例如：

内网系统
数据安全要求高的环境
移动端离线应用
批量处理大量地理数据

这时，离线地理编码（Offline Geocoding） 就成为必要选择。本文将介绍如何使用 GeoJSON + Shapely 在 Python 中实现 经纬度 ↔ 地区名称 的双向转换，并支持计算两地距离。

核心思路

数据源：使用包含中国行政区划边界的 GeoJSON 文件（如省、市、区县）
空间判断：利用 shapely 判断点是否在多边形内（反向编码）
几何中心：取行政区多边形的质心作为代表经纬度（正向编码）
距离计算：采用 Haversine 公式计算球面距离

所需依赖

pip install shapely

数据准备

以下 GeoJSON 文件（可从阿里云 DataV 地理工具下载）：

geo_province.json：省级边界
geo_city.json：市级边界
geo_china.json：区县级边界（全国）

核心代码

import json
import math
from shapely.geometry import Point, shape

class OfflineGeocoder:
    def __init__(self, geojson_paths):
        self.features = []
        self.code2name = {}
        for geojson_path in geojson_paths:
            with open(geojson_path, 'r', encoding='utf-8') as f:
                geojson_data = json.load(f)
                self.features.extend(geojson_data['features'])
                for feature in geojson_data['features']:
                    self.code2name[feature['properties']['adcode']] = feature['properties']['name']

        self.name_index = {}
        for feat in self.features:
            props = feat['properties']
            key = f"{props.get('name', '')}"
            self.name_index[key] = feat

    def position2region(self, lat, lon):
        """经纬度 → 地区"""
        point = Point(lon, lat)
        features = []
        for feat in self.features:
            if shape(feat['geometry']).contains(point):
                features.append(feat)
        ans = ""
        for feat in features:
            props = feat['properties']
            temp = ""
            for code in props.get('acroutes', []):
                temp += f"{self.code2name.get(code, '')}-"
            temp += f"{props.get('name', '')}"
            if len(temp) > len(ans):
                ans = temp
        return ans

    def region2position(self, full_name):
        """地区 → 经纬度（质心）"""
        feat = self.name_index.get(full_name)
        if not feat:
            return None
        centroid = shape(feat['geometry']).centroid
        return {'lat': centroid.y, 'lon': centroid.x}

    def distance_of_regions(self, region1, region2):
        """
        地区 → 距离（千米），保留 2 位小数
        """
        pos1 = self.region2position(region1)
        pos2 = self.region2position(region2)
        if not pos1 or not pos2:
            return None
        dis = self.distance_of_position(pos1['lat'], pos1['lon'], pos2['lat'], pos2['lon']) / 1000
        return f"{dis:.2f} km"

    def distance_of_position(self, lat1, lon1, lat2, lon2):
        """经纬度 → 距离（米）"""

        # 将度转换为弧度
        lat1_rad = math.radians(lat1)
        lon1_rad = math.radians(lon1)
        lat2_rad = math.radians(lat2)
        lon2_rad = math.radians(lon2)

        # 地球半径（米）
        R = 6371000

        # Haversine公式计算两点间距离
        dlat = lat2_rad - lat1_rad
        dlon = lon2_rad - lon1_rad

        a = math.sin(dlat/2)**2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(dlon/2)**2
        c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))

        distance = R * c
        return distance

Geo = OfflineGeocoder(["geo_china.json", "geo_province.json", "geo_city.json"])

测试

from geo_helper import Geo

# 位置转地区
print(Geo.position2region(39.9087, 116.4729))

# 地区转位置
print(Geo.region2position("银川市"))

# 地区距离
print(Geo.distance_of_regions("银川市", "北京市"))

⚠️ 注意事项

地区重名问题：当前实现以“地区名”为 key，若存在重名（如多个“朝阳区”），会覆盖。生产环境建议使用 adcode 或完整路径作为 key。
性能优化：若需高频查询，可对多边形建立 R-tree 空间索引（使用 rtree 库）。
数据：可以自定义区域，新增对应的 json 文件即可。

linux 系统监控

Wed, 24 Sep 2025 16:00:00 GMT

先写个记录日志的脚本

#!/bin/bash

# 监控 systemctl status x 的脚本
# 作者: Assistant
# 日期: 2024

# 配置变量
SERVICE_NAME="x"
LOG_FILE="/var/log/x_status.log"
MAX_LOG_SIZE=100  # 最大日志文件大小（MB），超过则轮转

# 获取当前时间戳
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

# 检查 systemctl 命令是否存在
if ! command -v systemctl &> /dev/null; then
    echo "[$TIMESTAMP] ERROR: systemctl command not found" >> "$LOG_FILE"
    exit 1
fi

# 检查服务是否存在
if ! systemctl list-units --full --all | grep -q "^${SERVICE_NAME}\."; then
    echo "[$TIMESTAMP] ERROR: Service '$SERVICE_NAME' not found" >> "$LOG_FILE"
    exit 1
fi

# 获取服务状态信息
STATUS_OUTPUT=$(systemctl status "$SERVICE_NAME" 2>&1)

# 写入日志文件
{
    echo "=== Status check at $TIMESTAMP ==="
    echo "$STATUS_OUTPUT"
    echo "=================================="
    echo ""
} >> "$LOG_FILE"

# 日志轮转功能（可选）
if [ -f "$LOG_FILE" ]; then
    # 获取当前日志文件大小（MB）
    CURRENT_SIZE=$(du -m "$LOG_FILE" 2>/dev/null | cut -f1)
    
    # 如果日志文件超过最大大小，进行轮转
    if [ "$CURRENT_SIZE" -gt "$MAX_LOG_SIZE" ]; then
        mv "$LOG_FILE" "${LOG_FILE}.old"
        echo "[$TIMESTAMP] Log file rotated due to size limit" >> "$LOG_FILE"
    fi
fi

echo "[$TIMESTAMP] Status check completed successfully"

创建服务文件 /etc/systemd/system/x-monitor.service

[Unit]
Description=Monitor X service status
After=network.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/monitor_x_status.sh
User=root

创建定时器文件 /etc/systemd/system/x-monitor.timer

[Unit]
Description=Run X service monitor every minute
Requires=x-monitor.service

[Timer]
OnCalendar=*:*:00
Persistent=true

[Install]
WantedBy=timers.target

启用并启动定时器

# 重新加载 systemd 配置
sudo systemctl daemon-reload

# 启用并启动定时器
sudo systemctl enable --now x-monitor.timer

# 查看定时器状态
sudo systemctl status x-monitor.timer

停止监控

systemctl disable --now x-monitor.timer

rust shimmy 使用

Tue, 16 Sep 2025 16:00:00 GMT

下载模型

pip install -U huggingface_hub -i https://pypi.tuna.tsinghua.edu.cn/simple

~~注册 huggingface，获得 Token~~

~~huggingface-cli login，使用 Token 登录~~

切换源：export HF_ENDPOINT=https://hf-mirror.com

huggingface-cli download bartowski/Llama-3.2-1B-Instruct-GGUF Llama-3.2-1B-Instruct-Q4_K_M.gguf --local-dir ./models

安装 shimmy

安装 rust

# 安装依赖
sudo apt install curl build-essential gcc
# 使用脚本下载并安装
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

安装 cmake

sudo apt update
sudo apt install cmake

安装使用 shimmy

cargo install shimmy --features huggingface
shimmy serve --bind 0.0.0.0:11435 &

注：使用的目录

Hugging Face cache: ~/.cache/huggingface/hub/

Ollama models: ~/.ollama/models/

Local directory: ./models/

Environment: SHIMMY_BASE_GGUF=path/to/model.gguf

全文检索 Tantivy

Fri, 12 Sep 2025 16:00:00 GMT

引入

tantivy = "0.22"
jieba-rs = "0.6"

分词器

一、三种模式对比总览

模式	名称	特点	适用场景	示例
cut()	精确模式	最细粒度切分，尽量不重复、不冗余	正常文本处理、文档索引	"我爱北京天安门" → ["我", "爱", "北京", "天安门"]
cut_all()	全模式	尽可能多地切出所有可能的词	快速召回、粗筛	"我爱北京天安门" → ["我", "爱", "北京", "天安门", "京天", "安门"]
cut_for_search()	搜索引擎模式	在精确基础上，进一步拆分长词，提升召回	Tantivy 搜索索引推荐使用	"我爱北京天安门" → ["我", "爱", "北京", "天安", "安门", "天安门"]

cut() —— 精确模式（默认）目标：最符合语言学规律的切分，避免歧义和冗余。策略：基于 HMM（隐马尔可夫模型）+ 词典匹配，优先选择概率最高的切分方式。适合：语义理解、摘要生成、正式文档处理。
cut_all() —— 全模式目标：把所有可能的词都切出来，不管是否合理。策略：暴力穷举所有出现在词典中的子串。适合：快速检索、关键词提取、非精准场景。
cut_for_search() —— 搜索引擎模式 ✅ 推荐用于 Tantivy！目标：在精确模式基础上，对长词进行二次拆分，提高搜索召回率。策略：保留完整词（如“天安门”）同时拆出其前缀/后缀组合（如“天安”、“安门”）避免无意义组合（如“京天”不会出现）

阶段	使用模式	说明
索引构建	cut_all()	把每个词及其子串都存入索引，最大化召回
查询解析	cut_for_search()	提高搜索召回率
展示结果	cut()	显示原始句子或精炼摘要时用精确模式

//! 中文分词器模块 - 提供高性能的中英文混合分词功能

use std::sync::Arc;

use jieba_rs::Jieba;
use lazy_static::lazy_static;
use tantivy::tokenizer::{Token, TokenStream, Tokenizer};

// 使用全局静态 Jieba 实例，避免重复初始化
lazy_static! {
    static ref JIEBA: Arc<Jieba> = {
        let jieba = Jieba::new();
        // 可以在这里加载自定义词典
        // 注意：jieba-rs 的 load_dict 需要可变引用和 BufRead
        // 如果需要加载自定义词典，应该在初始化时处理
        Arc::new(jieba)
    };
}

/// 分词模式
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SegmentationMode {
    /// 精确模式：适合文本分析
    // Precise,
    /// 搜索模式：适合搜索引擎（召回率高但较慢）
    Search,
    /// 快速模式：速度优先（推荐用于大量文本）
    // Fast,
    /// 全模式：速度较慢，但能识别更多的词汇
    All,
}

impl Default for SegmentationMode {
    fn default() -> Self {
        SegmentationMode::Search
    }
}

/// 快速中文分词器 - 针对性能优化
#[derive(Clone)]
pub struct FastChineseTokenizer {
    mode: SegmentationMode,
}

impl FastChineseTokenizer {
    /// 创建新的分词器
    pub fn new(mode: SegmentationMode) -> Self {
        FastChineseTokenizer { mode }
    }

    /// 创建精确模式分词器
    // pub fn precise() -> Self {
    //     Self::new(SegmentationMode::Precise)
    // }

    // /// 创建搜索模式分词器
    // pub fn search() -> Self {
    //     Self::new(SegmentationMode::Search)
    // }

    /// 创建快速模式分词器
    // pub fn fast() -> Self {
    //     Self::new(SegmentationMode::Fast)
    // }

    /// 创建全模式分词器
    pub fn all() -> Self {
        Self::new(SegmentationMode::All)
    }

    /// 执行分词
    pub fn segment(&self, text: &str) -> Vec<String> {
        match self.mode {
            SegmentationMode::Search => {
                // 搜索模式：使用 cut_for_search，召回率高
                JIEBA.cut_for_search(text, false).into_iter().map(|s| s.to_string()).collect()
            }
            // SegmentationMode::Precise => {
            //     // 精确模式：使用标准 cut
            //     JIEBA.cut(text, false).into_iter().map(|s| s.to_string()).collect()
            // }
            // SegmentationMode::Fast => {
            //     // 快速模式：使用 cut 并过滤短词
            //     JIEBA
            //         .cut(text, false)
            //         .into_iter()
            //         .filter(|s| {
            //             // 保留长度大于1的词，或者非ASCII字符（中文单字）
            //             s.len() > 1 || !s.chars().all(|c| c.is_ascii())
            //         })
            //         .map(|s| s.to_string())
            //         .collect()
            // }
            SegmentationMode::All => JIEBA.cut_all(text).into_iter().map(|s| s.to_string()).collect(),
        }
    }
}

impl Tokenizer for FastChineseTokenizer {
    type TokenStream<'a> = ChineseTokenStream<'a>;

    fn token_stream<'a>(&'a mut self, text: &'a str) -> Self::TokenStream<'a> {
        let tokens = self.segment(text);
        ChineseTokenStream::new(tokens)
    }
}

/// 中英文混合分词器
// #[derive(Clone)]
// pub struct ChineseEnglishTokenizer {
//     mode: SegmentationMode,
// }

// impl ChineseEnglishTokenizer {
//     /// 创建新的分词器
//     pub fn new() -> Self {
//         ChineseEnglishTokenizer { mode: SegmentationMode::default() }
//     }

//     /// 使用指定模式创建分词器
//     pub fn with_mode(mode: SegmentationMode) -> Self {
//         ChineseEnglishTokenizer { mode }
//     }

//     /// 执行分词
//     fn segment(&self, text: &str) -> Vec<String> {
//         match self.mode {
//             SegmentationMode::Search => JIEBA.cut_for_search(text, false).into_iter().map(|s| s.to_string()).collect(),
//             SegmentationMode::All => JIEBA.cut_all(text).into_iter().map(|s| s.to_string()).collect(),
//             // SegmentationMode::Precise => JIEBA.cut(text, false).into_iter().map(|s| s.to_string()).collect(),
//             // SegmentationMode::Fast => {
//             //     // 快速模式下，对中英文进行特殊处理
//             //     let mut tokens = Vec::new();
//             //     let mut current_word = String::new();
//             //     let mut is_english = false;

//             //     for ch in text.chars() {
//             //         if ch.is_ascii_alphanumeric() {
//             //             if !is_english && !current_word.is_empty() {
//             //                 // 从中文切换到英文，先处理中文部分
//             //                 let chinese_tokens = JIEBA.cut(&current_word, false).into_iter().map(|s| s.to_string());
//             //                 tokens.extend(chinese_tokens);
//             //                 current_word.clear();
//             //             }
//             //             is_english = true;
//             //             current_word.push(ch);
//             //         } else if ch.is_whitespace() {
//             //             if !current_word.is_empty() {
//             //                 tokens.push(current_word.clone());
//             //                 current_word.clear();
//             //             }
//             //             is_english = false;
//             //         } else {
//             //             if is_english && !current_word.is_empty() {
//             //                 // 从英文切换到中文，先保存英文部分
//             //                 tokens.push(current_word.clone());
//             //                 current_word.clear();
//             //             }
//             //             is_english = false;
//             //             current_word.push(ch);
//             //         }
//             //     }

//             //     // 处理最后的部分
//             //     if !current_word.is_empty() {
//             //         if is_english {
//             //             tokens.push(current_word);
//             //         } else {
//             //             let chinese_tokens = JIEBA.cut(&current_word, false).into_iter().map(|s| s.to_string());
//             //             tokens.extend(chinese_tokens);
//             //         }
//             //     }

//             //     tokens
//             // }
//         }
//     }
// }

// impl Default for ChineseEnglishTokenizer {
//     fn default() -> Self {
//         Self::new()
//     }
// }

// impl Tokenizer for ChineseEnglishTokenizer {
//     type TokenStream<'a> = ChineseTokenStream<'a>;

//     fn token_stream<'a>(&'a mut self, text: &'a str) -> Self::TokenStream<'a> {
//         let tokens = self.segment(text);
//         ChineseTokenStream::new(tokens)
//     }
// }

/// Token stream for Chinese text
pub struct ChineseTokenStream<'a> {
    tokens: Vec<String>,
    current_index: usize,
    current_offset: usize,
    token: Token,
    _phantom: std::marker::PhantomData<&'a ()>,
}

impl<'a> ChineseTokenStream<'a> {
    fn new(tokens: Vec<String>) -> Self {
        ChineseTokenStream {
            tokens,
            current_index: 0,
            current_offset: 0,
            token: Token::default(),
            _phantom: std::marker::PhantomData,
        }
    }
}

impl<'a> TokenStream for ChineseTokenStream<'a> {
    fn advance(&mut self) -> bool {
        while self.current_index < self.tokens.len() {
            let token_text = &self.tokens[self.current_index];
            self.current_index += 1;

            // 跳过空的token
            if token_text.trim().is_empty() {
                self.current_offset += token_text.len();
                continue;
            }

            let start = self.current_offset;
            let end = start + token_text.len();

            self.token.text.clear();
            self.token.text.push_str(token_text);
            self.token.offset_from = start;
            self.token.offset_to = end;
            self.token.position = self.token.position.wrapping_add(1);

            self.current_offset = end;
            return true;
        }
        false
    }

    fn token(&self) -> &Token {
        &self.token
    }

    fn token_mut(&mut self) -> &mut Token {
        &mut self.token
    }
}

// #[cfg(test)]
// mod tests {
// use std::time::Instant;

// use super::*;

// #[test]
// fn test_fast_tokenizer() {
//     let mut tokenizer = FastChineseTokenizer::fast();
//     let text = "我爱北京天安门";

//     let mut stream = tokenizer.token_stream(text);
//     let mut tokens = Vec::new();

//     while stream.advance() {
//         tokens.push(stream.token().text.clone());
//     }

//     assert!(!tokens.is_empty());
//     println!("Fast mode tokens: {:?}", tokens);
// }

// #[test]
// fn test_chinese_english_tokenizer() {
//     let mut tokenizer = ChineseEnglishTokenizer::new();
//     let text = "Hello世界，这是一个test测试";

//     let mut stream = tokenizer.token_stream(text);
//     let mut tokens = Vec::new();

//     while stream.advance() {
//         tokens.push(stream.token().text.clone());
//     }

//     assert!(!tokens.is_empty());
//     println!("Mixed text tokens: {:?}", tokens);

//     // 应该包含英文和中文的分词结果
//     assert!(tokens.iter().any(|t| t == "Hello"));
//     assert!(tokens.iter().any(|t| t.contains("世界") || t == "世界"));
// }

// #[test]
// fn test_segmentation_modes() {
//     let text = "中华人民共和国国家标准";

//     // 测试不同模式
//     let modes = vec![
//         (SegmentationMode::Fast, "Fast"),
//         (SegmentationMode::Precise, "Precise"),
//         (SegmentationMode::Search, "Search"),
//     ];

//     for (mode, name) in modes {
//         let mut tokenizer = FastChineseTokenizer::new(mode);
//         let mut stream = tokenizer.token_stream(text);
//         let mut tokens = Vec::new();

//         while stream.advance() {
//             tokens.push(stream.token().text.clone());
//         }

//         println!("{} mode tokens: {:?}", name, tokens);
//         assert!(!tokens.is_empty());
//     }
// }

// #[test]
// fn test_performance_comparison() {
//     let text = "我爱北京天安门，天安门上太阳升。伟大领袖毛主席，指引我们向前进。";
//     let iterations = 1000;

//     // 测试快速模式
//     let mut fast_tokenizer = FastChineseTokenizer::all();
//     let start = Instant::now();
//     for _ in 0..iterations {
//         let mut stream = fast_tokenizer.token_stream(text);
//         while stream.advance() {}
//     }
//     let fast_duration = start.elapsed();

//     // 测试搜索模式
//     let mut search_tokenizer = FastChineseTokenizer::search();
//     let start = Instant::now();
//     for _ in 0..iterations {
//         let mut stream = search_tokenizer.token_stream(text);
//         while stream.advance() {}
//     }
//     let search_duration = start.elapsed();

//     println!(
//         "All mode: {:?} for {} iterations",
//         fast_duration, iterations
//     );
//     println!(
//         "Search mode: {:?} for {} iterations",
//         search_duration, iterations
//     );

//     // 注意：实际性能可能因环境和数据而异
//     // 这里只验证两种模式都能正常工作
//     assert!(fast_duration.as_millis() > 0);
//     assert!(search_duration.as_millis() > 0);
// }

// #[test]
// fn test_english_only() {
//     let mut tokenizer = ChineseEnglishTokenizer::new();
//     let text = "Hello World This Is A Test";

//     let mut stream = tokenizer.token_stream(text);
//     let mut tokens = Vec::new();

//     while stream.advance() {
//         tokens.push(stream.token().text.clone());
//     }

//     assert!(!tokens.is_empty());
//     println!("English only tokens: {:?}", tokens);
// }

// #[test]
// fn test_chinese_only() {
//     let mut tokenizer = ChineseEnglishTokenizer::new();
//     let text = "这是一个纯中文的测试文本";

//     let mut stream = tokenizer.token_stream(text);
//     let mut tokens = Vec::new();

//     while stream.advance() {
//         tokens.push(stream.token().text.clone());
//     }

//     assert!(!tokens.is_empty());
//     println!("Chinese only tokens: {:?}", tokens);
// }
// }

搜索引擎

use std::{
    collections::HashMap, path::Path, sync::{Arc, RwLock}
};

use lazy_static::lazy_static;
use tantivy::{
    collector::TopDocs, doc, query::{BooleanQuery, Occur, Query, TermQuery}, schema::{Field, IndexRecordOption, Schema, TextFieldIndexing, TextOptions, Value as _}, Index, Result, TantivyDocument, Term
};

use super::chinese_tokenizer;

const INDEX_PATH: &str = "data/tantivy_index";
const ALL_TOKENIZER: &str = "all";
const FIELD_NAME: &str = "content";
const INDEX_WRITER_MEMORY: usize = 50_000_000;
const DOCUMENT_BATCH_SIZE: usize = 100;
const MAX_SEGMENT_CACHE_SIZE: usize = 10000;
const SEARCH_LIMIT: usize = 10;

lazy_static! {
    /// 全局分词缓存
    static ref SEGMENT_CACHE: Arc<RwLock<SegmentCache>> =
        Arc::new(RwLock::new(SegmentCache::new()));
}

pub struct SegmentCache {
    cache: HashMap<String, Vec<String>>,
    max_size: usize,
    hits: usize,
    misses: usize,
}

impl SegmentCache {
    /// 创建新的缓存实例
    pub fn new() -> Self {
        Self::with_capacity(MAX_SEGMENT_CACHE_SIZE)
    }

    /// 创建指定容量的缓存实例
    pub fn with_capacity(max_size: usize) -> Self {
        SegmentCache { cache: HashMap::new(), max_size, hits: 0, misses: 0 }
    }

    /// 获取缓存项
    fn get(&mut self, key: &str) -> Option<Vec<String>> {
        if let Some(value) = self.cache.get(key) {
            self.hits += 1;
            Some(value.clone())
        } else {
            self.misses += 1;
            None
        }
    }

    /// 插入缓存项
    fn insert(&mut self, key: String, value: Vec<String>) {
        // 如果缓存已满，清空缓存
        if self.cache.len() >= self.max_size {
            self.cache.clear();
        }
        self.cache.insert(key, value);
    }
}

/// create new index
///
/// delete if it exists
pub fn create_index() -> Result<(Schema, Index)> {
    let schema = build_schema();

    let path = Path::new(INDEX_PATH);
    if path.exists() {
        std::fs::remove_dir_all(path)?;
    }
    if !path.exists() {
        std::fs::create_dir_all(path)?;
    }
    let index = Index::create_in_dir(path, schema.clone())?;
    register_tokenizers(&index);

    Ok((schema, index))
}

pub async fn write_documents(index: &Index, schema: &Schema, contents: &[String]) -> tantivy::Result<()> {
    let mut index_writer = index.writer(INDEX_WRITER_MEMORY)?;
    let mut docs_batch = Vec::with_capacity(DOCUMENT_BATCH_SIZE);

    for content in contents {
        let doc = create_document(content, schema);
        docs_batch.push(doc);
        if docs_batch.len() >= DOCUMENT_BATCH_SIZE {
            for doc in docs_batch.drain(..) {
                index_writer.add_document(doc)?;
            }
        }
    }
    for doc in docs_batch {
        index_writer.add_document(doc)?;
    }

    index_writer.commit()?;
    Ok(())
}

pub async fn search(index: &Index, schema: &Schema, query: &str) -> anyhow::Result<Vec<String>> {
    let searcher = index.reader()?.searcher();
    let tantivy_query = build_query(query, schema)?;
    let top_docs = searcher.search(&tantivy_query, &TopDocs::with_limit(SEARCH_LIMIT))?;

    let mut results = vec![];
    for (_score, doc_address) in top_docs {
        let retrieved_doc: TantivyDocument = searcher.doc(doc_address)?;
        if let Some(content) = retrieved_doc
            .get_first(get_field(schema))
            .and_then(|field_value| field_value.as_str())
            .map(|s| s.to_string())
        {
            results.push(content);
        }
    }

    Ok(results)
}

fn build_query(input: &str, schema: &Schema) -> tantivy::Result<Box<dyn Query>> {
    let mut subqueries: Vec<(Occur, Box<dyn Query>)> = Vec::new();
    let segmented_words = segment_with_cache(input, chinese_tokenizer::SegmentationMode::Search);
    for word in segmented_words {
        let term_query = TermQuery::new(
            Term::from_field_text(get_field(schema), &word),
            IndexRecordOption::Basic,
        );
        subqueries.push((Occur::Should, Box::new(term_query)));
    }
    Ok(Box::new(BooleanQuery::new(subqueries)))
}

fn create_document(content: &str, schema: &Schema) -> TantivyDocument {
    doc! {
        get_field(schema) => content,
    }
}

fn get_field(schema: &Schema) -> Field {
    schema.get_field(FIELD_NAME).unwrap_or_else(|_| panic!("Field '{}' not found in schema", FIELD_NAME))
}

pub fn segment_with_cache(text: &str, mode: chinese_tokenizer::SegmentationMode) -> Vec<String> {
    let cache_key = format!("{}:{:?}", text, mode);

    // 尝试从缓存读取
    {
        let mut cache = SEGMENT_CACHE.write().unwrap();
        if let Some(cached) = cache.get(&cache_key) {
            return cached;
        }
    }

    // 如果缓存未命中，进行分词
    let segments = perform_segmentation(text, mode);

    // 存入缓存
    {
        let mut cache = SEGMENT_CACHE.write().unwrap();
        cache.insert(cache_key, segments.clone());
    }

    segments
}

fn perform_segmentation(text: &str, mode: chinese_tokenizer::SegmentationMode) -> Vec<String> {
    chinese_tokenizer::FastChineseTokenizer::new(mode).segment(text)
}

fn register_tokenizers(index: &Index) {
    let all_tokenizer = chinese_tokenizer::FastChineseTokenizer::all();

    index.tokenizers().register(ALL_TOKENIZER, all_tokenizer);
}

fn build_schema() -> Schema {
    let mut schema_builder = Schema::builder();

    let text_options = TextOptions::default()
        .set_indexing_options(
            TextFieldIndexing::default()
                .set_tokenizer(ALL_TOKENIZER)
                .set_index_option(IndexRecordOption::WithFreqsAndPositions),
        )
        .set_stored();

    schema_builder.add_text_field(FIELD_NAME, text_options);
    schema_builder.build()
}

封装

use std::{
    fs::{File, OpenOptions}, io::Write, path::Path, sync::Arc
};

use anyhow::Ok;
use memmap2::MmapOptions;
use tantivy::{schema::Schema, Index};

mod chinese_tokenizer;
mod tantivy_engine;
use lazy_static::lazy_static;
use memchr::memmem;

lazy_static! {
    pub static ref SEARCH_ENGINE: Arc<SearchEngine> = Arc::new(SearchEngine::new());
}

const DEFAULT_KNOWLEDGE_FILE: &str = "data/knowledge.txt";

#[derive(Debug, Clone)]
pub struct SearchEngine {
    index: Index,
    schema: Schema,
}

impl SearchEngine {
    fn new() -> Self {
        let (schema, index) = tantivy_engine::create_index().unwrap();
        Self { index, schema }
    }

    pub async fn init(&self) -> anyhow::Result<()> {
        if Path::new(DEFAULT_KNOWLEDGE_FILE).exists() {
            let content_str = std::fs::read_to_string(DEFAULT_KNOWLEDGE_FILE)?;
            let contents = content_str.split("\n").map(|s| s.trim().to_string()).collect::<Vec<String>>();
            tantivy_engine::write_documents(&self.index, &self.schema, &contents).await?;
        }
        Ok(())
    }

    pub async fn write(&self, content: &str) -> anyhow::Result<()> {
        if !Path::new(DEFAULT_KNOWLEDGE_FILE).exists() {
            std::fs::write(DEFAULT_KNOWLEDGE_FILE, content)?;
        } else {
            let needle = content.as_bytes();
            let file = File::open(DEFAULT_KNOWLEDGE_FILE)?;
            let mmap = unsafe { MmapOptions::new().map(&file)? };
            if memmem::find(&mmap, needle).is_some() {
                return Ok(());
            }

            let mut file = OpenOptions::new().create(true).append(true).open(DEFAULT_KNOWLEDGE_FILE)?;
            writeln!(file, "{}", content)?;
        }
        tantivy_engine::write_documents(&self.index, &self.schema, &vec![content.to_string()]).await?;
        Ok(())
    }

    pub async fn search(&self, query: &str) -> anyhow::Result<Vec<String>> {
        let results = tantivy_engine::search(&self.index, &self.schema, query).await?;
        Ok(results)
    }
}

使用

封装一个 mcp server tool 吧~

读、写笔记

#[tool(
    description = "Searches the user’s personal notes for content matching a natural language query. Call this tool when the user asks to find, look up, recall, or review anything they’ve written before — for example: “Where did I write about the trip to Japan?”, “Show me my todos from Monday”, “Find notes with the tag #design”, or “What did I say about the new API?” Do NOT call this tool for factual questions that aren’t about the user’s own notes (e.g., “Who invented the light bulb?”). This tool only accesses the user’s private note collection."
)]
async fn search_info(&self, Parameters(req): Parameters<QueryRequest>) -> Result<CallToolResult, McpError> {
    let results = SEARCH_ENGINE.search(&req.query).await.unwrap_or(vec!["未搜索到内容".to_string()]);
    Ok(CallToolResult::success(vec![Content::text(
        results.join("\n"),
    )]))
}

#[tool(
    description = "Creates a new personal note from user-provided content. Call this tool when the user says they want to save, record, log, or write down anything for future reference — e.g., “Save this idea: build a morning routine app”, “Note that my cat hates thunder”, or “Add to my todo list: call dentist”. Do not use for generating content, replying to questions, or casual chatting. Only invoke when the intent is to preserve information long-term."
)]
async fn record_info(&self, Parameters(req): Parameters<RecordRequest>) -> Result<CallToolResult, McpError> {
    let result = match SEARCH_ENGINE.write(&req.content).await {
        Ok(_) => "写入成功".to_string(),
        Err(err) => format!("写入失败: {}", err),
    };
    Ok(CallToolResult::success(vec![Content::text(result)]))
}

使用 NextCloud 搭建私有云盘

Thu, 11 Sep 2025 16:00:00 GMT

部署 `OnlyOffice`

docker run -d --restart=always --name onlyoffice -p 9002:80 -p 9001:443 onlyoffice/documentserver

获取秘钥 docker exec -it onlyoffice cat /etc/onlyoffice/documentserver/local.json

部署 `NextCloud`

docker run -d --name nextcloud --restart=always -v /storage02/app/nextcloud:/var/www/html -e TZ="Asia/Shanghai" -p 8002:80 nextcloud

安装 NextCloud 的 OnlyOffice 插件

离线方式则是进入 ONLYOFFICE - Apps - App Store - Nextcloud 页面下载对应版本的onlyoffice插件，然后将插件解压，将文件夹放入nextcloud容器的 /var/www/html/apps 目录里面，然后在nextcloud的应用里面就有onlyoffice了，然后启用即可。

个人中心->管理设置->ONLYOFFICE，进入到配置 onlyoffice 插件页面，将 onlyoffice 插件服务地址及其上一步获取的秘钥填入里面，并保存。（https 注意切换更多设置中为 https）

使用 https

# 进入容器
docker exec -it nextcloud bash
# 修改配置
vim /var/www/html/config/config.php
# 修改
'overwrite.cli.url' => 'https://cloud.42tr.cn',
'overwriteprotocol' => 'https',

GIS demo

Wed, 10 Sep 2025 16:00:00 GMT

【下载数据】

案例

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>Offline Map with tileserver-gl</title>
    <!-- 使用官方 Mapbox GL JS（但我们将绕过 token 验证） -->
    <script src="https://api.mapbox.com/mapbox-gl-js/v2.15.0/mapbox-gl.js"></script>
    <link href="https://api.mapbox.com/mapbox-gl-js/v2.15.0/mapbox-gl.css" rel="stylesheet" />
    <style>
        body { margin: 0; padding: 0; }
        #map { position: absolute; top: 0; bottom: 0; width: 100%; }
    </style>
</head>
<body>
<div id="map"></div>

<script>
    // 👇 虽然我们不使用 Mapbox 服务，但 mapbox-gl.js 仍强制检查 token
    //    我们给一个假的 token 避免报错（不会联网验证，因为源是本地的）
    mapboxgl.accessToken = 'no-token'; 

    // 创建地图
    const map = new mapboxgl.Map({
        container: 'map',
        // 使用 tileserver-gl 自动生成的 style.json
        style: 'http:/192.168.0.46:20001/styles/basic-preview/style.json',
        center: [116.4, 39.9], // 北京大致坐标 [lng, lat]
        zoom: 10,
        hash: true
    });

    // 添加导航控件
    map.addControl(new mapboxgl.NavigationControl());

    // 地图加载完成后打印信息
    map.on('load', () => {
        console.log('地图加载成功！');
    });

    // 捕获错误（调试用）
    map.on('error', (e) => {
        console.error('地图错误:', e);
    });
</script>
</body>
</html>

rime 输入法

Sun, 07 Sep 2025 16:00:00 GMT

安装

安装后到系统设置添加

python 数据库迁移

Sun, 27 Jul 2025 16:00:00 GMT

步骤

初始化

alembic init alembic
配置初始数据库

export DATABASE_URL='postgresql://postgres:password@localhost:5432/alembic_test1'
创建迁移脚本

alembic revision --autogenerate -m "init"

设置 env.py

from logging.config import fileConfig
from sqlalchemy import engine_from_config
from sqlalchemy import pool

from alembic import context

from open_webui.env import DATABASE_URL
from open_webui.models import Base
from open_webui.models import audios, auths, channels, chats, conference_table, config as config_model, courses, demos, document_stars, document_words, documents, feedbacks, file_chapters, files, folders, functions, groups, knowledge, memories, messages, models, ppt_tmpls, ppt_topics, ppts, prompts, references, tags, template, tools, translate_words, users
print("Tables in metadata:", Base.metadata.tables.keys())

# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config

# Interpret the config file for Python logging.
# This line sets up loggers basically.
if config.config_file_name is not None:
    fileConfig(config.config_file_name)

config.set_main_option('sqlalchemy.url', DATABASE_URL)
# add your model's MetaData object here
# for 'autogenerate' support
# from myapp import mymodel
# target_metadata = mymodel.Base.metadata
target_metadata = Base.metadata

# other values from the config, defined by the needs of env.py,
# can be acquired:
# my_important_option = config.get_main_option("my_important_option")
# ... etc.


def run_migrations_offline() -> None:
    """Run migrations in 'offline' mode.

    This configures the context with just a URL
    and not an Engine, though an Engine is acceptable
    here as well.  By skipping the Engine creation
    we don't even need a DBAPI to be available.

    Calls to context.execute() here emit the given string to the
    script output.

    """
    url = config.get_main_option("sqlalchemy.url")
    context.configure(
        url=url,
        target_metadata=target_metadata,
        literal_binds=True,
        dialect_opts={"paramstyle": "named"},
    )

    with context.begin_transaction():
        context.run_migrations()


def run_migrations_online() -> None:
    """Run migrations in 'online' mode.

    In this scenario we need to create an Engine
    and associate a connection with the context.

    """
    connectable = engine_from_config(
        config.get_section(config.config_ini_section, {}),
        prefix="sqlalchemy.",
        poolclass=pool.NullPool,
    )

    with connectable.connect() as connection:
        context.configure(
            connection=connection, target_metadata=target_metadata
        )

        with context.begin_transaction():
            context.run_migrations()


if context.is_offline_mode():
    run_migrations_offline()
else:
    run_migrations_online()

手动升级

alembic upgrade head

配置启动时执行升级

def run_migrations():
    logger.info("Running migrations")
    try:
        logger.info("Loading alembic configuration, path: %s", BACKEND_DIR / "alembic.ini")
        alembic_cfg = Config(BACKEND_DIR / "alembic.ini")

        # 支持 pyinstaller
        if getattr(sys, 'frozen', False):
            alembic_cfg.set_main_option('script_location', os.path.join(getattr(sys, '_MEIPASS', '.'), 'alembic'))
        command.upgrade(alembic_cfg, "head")
    except Exception as e:
        logger.exception(f"Error running migrations: {e}")

run_migrations()

windows smb 连不上问题

Sat, 12 Jul 2025 16:00:00 GMT

在Windows 11可能无法使用SMB功能的问题，请参考以下2种解决方法择一设置：

注意：此方法可能降低系统的安全性，建议仅在信任的网络环境中使用。

方法1. 启用不安全的访客登录：

a. 使用注册表编辑器：

    a1. 在Windows 的搜索框输入「注册表编辑器」并开启。

    a2. 点击进入此路径「HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\LanmanWorkstation」。

如果「LanmanWorkstation」不存在，请右键点击「Microsoft」，选择「新增」>「项」，并命名为「LanmanWorkstation」。

    a3. 右键点击「LanmanWorkstation」，选择「新增」>「DWORD（32 位）值」，命名为「AllowInsecureGuestAuth」。

    a4. 在右侧窗格中，右键点击「AllowInsecureGuestAuth」  > 点击「修改」，将「数值数据」设为「1」，然后按下「确定」。



b. 使用本地组策略编辑器：

    b1. 在键盘按下「 Win键 + R键」，输入 「gpedit.msc」，然后按下「确定」。

    b2. 点击进入此路径「计算机设置」>「系统模板」>「网络」>「Lanman 工作站」。

    b3. 在右侧窗格中，在「启用不安全的来宾登录」 单击右键 > 「编辑」。

    b4. 选择「已启用」，然后按下「确定」。

方法2. 关闭 SMB 签名要求：

a. 使用注册表编辑器：

    a1. 在Windows 的搜索框输入「注册表编辑器」并开启。

    a2. 点击进入此路径「HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\LanmanWorkstation\Parameters\RequireSecuritySignature」。

如果「Parameters」 下没有「RequireSecuritySignature」，请右键点击「Parameters」，选择「新增」>「DWORD（32 位）值」，并命名为「RequireSecuritySignature」。 

    a3. 右键点击「RequireSecuritySignature」 > 点击「修改」，将「数值数据」设为 0，然后按下「确定」。 



b. 使用 Windows PowerShell： 

    b1. 在Windows 的搜索框输入「Windows PowerShell」并以管理员身份运行。

    b2. 输入以下指令，输入完成后在键盘按下「Enter」 键即可。

Set-SmbClientConfiguration -RequireSecuritySignature $false

转载：https://www.asus.com.cn/support/faq/1054736/

rust 向量搜索

Sat, 12 Apr 2025 16:00:00 GMT

部署向量服务

在 raspberry pi 使用 docker 部署

向量数据库：qdrant
向量化服务：m3e
- M3E主要针对中文文本进行向量化处理，但也有一定的双语处理能力
- M3E属于小模型，资源使用不高，CPU也可以运行，适合私有化部署和资源受限的环境。

version: '2'
services:
  qdrant:
    image: qdrant/qdrant:v1.13.0
    ports:
      - "6333:6333"
      - "6334:6334"
    volumes:
      - "/disk/app/qdrant:/qdrant/storage"
    restart: on-failure

  m3e_api:
    container_name: m3e_api
    environment:
      TZ: Asia/Shanghai
      sk-key: 'sk-42tr'
    image: docker.io/gaord/m3e-large-api:231129
    restart: always
    ports:
      - "6200:6008"

使用

调用向量化 api

curl --location --request POST 'http://localhost:6200/v1/embeddings' --header 'Authorization: Bearer sk-42tr' --header 'Content-Type: application/json' --data-raw '{
  "model": "m3e",
  "input": ["laf是什么"]
}'

问题：使用树莓派 4b cpu 跑起来太慢了，以上调用就要花 6s 多，一个段落就要 1min，后续尝试部署到带 gpu/npu 的设备。

使用 qdrant

使用 rust client，当前代码中未使用向量化服务生成的结果

Cargo.toml

[package]
name = "test-qdrant"
version = "0.1.0"
edition = "2024"

[dependencies]
anyhow = "1.0.97"
qdrant-client = "1.13.0"
serde_json = "1.0.140"
tokio = { version = "1.44.2", features = ["rt-multi-thread"] }
tonic = "0.13.0"
once_cell = "1.19.0"
uuid = { version = "1", features = ["v4"] }

qd.rs

use once_cell::sync::Lazy;
use qdrant_client::qdrant::r#match::MatchValue;
use qdrant_client::qdrant::{
    Condition, CreateCollectionBuilder, Distance, Filter, PointStruct, ScalarQuantizationBuilder,
    SearchParamsBuilder, SearchPointsBuilder, UpsertPointsBuilder, Value, VectorParamsBuilder,
};
use qdrant_client::{Payload, Qdrant};

use std::collections::HashMap;
use std::sync::Arc;
use uuid::Uuid;

static COLLECTION_NAME: &str = "x";
static CLIENT: Lazy<Arc<Qdrant>> = Lazy::new(|| {
    let client = Qdrant::from_url("http://192.168.1.3:6334")
        .build()
        .expect("Failed to build Qdrant client");
    Arc::new(client)
});

pub async fn init() -> anyhow::Result<()> {
    CLIENT.delete_collection(COLLECTION_NAME).await?;
    CLIENT
        .create_collection(
            CreateCollectionBuilder::new(COLLECTION_NAME)
                .vectors_config(VectorParamsBuilder::new(10, Distance::Cosine))
                .quantization_config(ScalarQuantizationBuilder::default()),
        )
        .await?;

    let collection_info = CLIENT.collection_info(COLLECTION_NAME).await?;
    dbg!(collection_info);
    Ok(())
}

pub async fn add_points(payloads: Vec<Payload>) -> anyhow::Result<()> {
    let points: Vec<PointStruct> = payloads
        .into_iter()
        .map(|payload| PointStruct::new(Uuid::new_v4().to_string(), vec![12.; 10], payload))
        .collect();
    CLIENT
        .upsert_points(UpsertPointsBuilder::new(COLLECTION_NAME, points))
        .await?;
    Ok(())
}

pub async fn search(
    field: impl Into<String>,
    r#match: impl Into<MatchValue>,
) -> anyhow::Result<Vec<HashMap<String, Value>>> {
    let response = CLIENT
        .search_points(
            SearchPointsBuilder::new(COLLECTION_NAME, [12.; 10], 10)
                .filter(Filter::all([Condition::matches(field, r#match)]))
                .with_payload(true)
                .params(SearchParamsBuilder::default().exact(true)),
        )
        .await?;
    let payloads: Vec<HashMap<String, Value>> = response
        .result
        .into_iter()
        .map(|point| point.payload)
        .collect();
    Ok(payloads)
}

main.rs

use qdrant_client::Payload;
mod qd;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    qd::init().await?;
    let payload1: Payload = serde_json::json!(
        {
            "title": "为什么奥特曼不直接放大招打怪兽",
            "content": "奥特曼的技能是打怪兽，而不是放大招。"
        }
    )
    .try_into()
    .unwrap();
    let payload2: Payload = serde_json::json!(
        {
            "title": "同样是带小孩，二哈是二哈，边牧是边牧",
            "content": "二哈是二哈，边牧是边牧，它们都是可爱的宠物。"
        }
    )
    .try_into()
    .unwrap();

    qd::add_points(vec![payload1, payload2]).await?;
    let payloads = qd::search("title", "奥特曼".to_string()).await?;
    println!("{:?}", payloads);

    Ok(())
}

参考

leptos 全栈开发

Fri, 11 Apr 2025 16:00:00 GMT

步骤

cargo install cargo-leptos

报错：fatal error: "algorithm" file not found

解决：重装 xcode
```
sudo rm -rf /Library/Developer/CommandLineTools
Xcode-select --install
```
rustup target add wasm32-unknown-unknown
cargo leptos new --git leptos-rs/start

use the Leptos starter template - it comes preconfigured with all these ready from you

cargo leptos watch

build frontend to wasm, compile backend and start it.

报错：

it looks like the Rust project used to create this Wasm file was linked against
    version of wasm-bindgen that uses a different bindgen format than this binary:

      rust Wasm file schema version: 0.2.95
         this binary schema version: 0.2.100

解决：更新 Cargo.toml 中的 wasm-bindgen 版本 wasm-bindgen = "=0.2.95" 改为 wasm-bindgen = "=0.2.100"，然后执行 cargo update

项目成功启动，默认使用的 actix，不想用，换 axum。

使用 axum

cargo install cargo-leptos
cargo leptos new --git leptos-rs/start-axum
cd your_project_dir
rustup toolchain install nightly
rustup target add wasm32-unknown-unknown
cargo leptos watch

添加 tailwind

npm install tailwindcss
Create the file style/tailwind.css
```
@import "tailwindcss";
```

Update Cargo.toml

# IMPORTANT! Remove or comment-out
# style-file = "style/main.scss"

# Activates the tailwind build
tailwind-input-file = "style/tailwind.css"

Update src/app.rs to use tailwind.

编译

cargo leptos build -r

交叉编译

安装编译目标：rustup target add aarch64-unknown-linux-gnu
安装交叉编译工具链：brew tap messense/macos-cross-toolchains + brew install aarch64-unknown-linux-gnu（可能不需要）

创建 .cargo/config.toml

[target.aarch64-unknown-linux-gnu]
linker = "aarch64-unknown-linux-gnu-gcc"

编译 LEPTOS_BIN_TARGET_TRIPLE=aarch64-unknown-linux-gnu cargo leptos build --release

启动

拷贝到服务器

x-leptos-axum
site/

执行

export LEPTOS_OUTPUT_NAME="x-leptos-axum"
export LEPTOS_SITE_ROOT="site"
export LEPTOS_SITE_PKG_DIR="pkg"
export LEPTOS_SITE_ADDR="0.0.0.0:3000"
export LEPTOS_RELOAD_PORT="3001"
./x-leptos-axum

docx 生成

Mon, 31 Mar 2025 16:00:00 GMT

注意点

docx 文档携带的样式表不同，存在时直接配置 style 即可，不存在则要使用 doc.styles.add_style(style, 1) 配置
run.font.name = fontname 修改中文字体可能无效（测试时发现标题的字体修改失败），因为 docx 只修改 latin 字体，但 eastAsia 才控制中文 run._element.rPr.rFonts.set(qn("w:eastAsia"), fontname)

关键代码

class HTMLRequest(BaseModel):
    html: str
    type: Optional[str] = None
    template_id: Optional[str] = None

@router.post("/gen_template")
async def gen_template(request: HTMLRequest, bgtasks: BackgroundTasks):
    """
    制式输出
    """
    date_str = datetime.now().strftime("%Y%m%d_%H%M%S")
    output_filename = f"{date_str}_{str(uuid.uuid4())[:8]}.docx"
    output_path = os.path.join(STATIC_DIR, output_filename)

    if request.template_id is None:
        await gen_doc_without_template(request.html, output_path)
    else:
        await gen_doc_with_template(request.html, request.template_id, output_path)

    filename = output_filename
    filepath = output_path
    if request.type is not None and request.type == "wps":
        filepath = convert_docx_to_wps(output_path)
        filename = filename.replace(".docx", ".wps")
    elif request.type is not None and request.type == "pdf":
        filepath = convert_docx_to_pdf(output_path)
        filename = filename.replace(".docx", ".pdf")

    # 添加后台任务，返回文件后自动删除
    bgtasks.add_task(cleanup_file, output_path)
    if filepath != output_path:
        bgtasks.add_task(cleanup_file, filepath)
    return FileResponse(
        path = filepath,
        media_type = 'application/octet-stream',
        filename = filename,
        headers = {
            'Content-Disposition': f'attachment; filename="{quote(filename)}"'
        }
    )

FONT_NAME = {'h1': 'SimHei', 'h2': '楷体', 'h3': '仿宋', 'h4': '仿宋', 'p': '仿宋'}
FONT_SIZE = Pt(16)


# 首行缩进
def add_indent(paragraph, indent_chars=2):
    pPr = paragraph._element.get_or_add_pPr()
    ind = OxmlElement('w:ind')
    ind.set(qn("w:firstLine"), str(indent_chars * 300))  # 1个中文字符约300单位
    pPr.append(ind)

# 根据模板以及 html 生成 docx
async def gen_doc_with_template(html: str, template_id: str, output_path: str):
    template = Templates.get_template_by_id(template_id)
    if template is None:
        return
    filename = template.template_path.split("/")[-1]
    template_path = os.path.join(TEMPLATE_DIR, filename)
    doc = Document(template_path)
    available_styles = [s.name for s in doc.styles]
    for paragraph in doc.paragraphs:
        if "content" in paragraph.text:
            paragraph.clear()
            soup = BeautifulSoup(html, 'html.parser')
            def recursive_parse(element, paragraph):
                for child in element.children:
                    if not child.name:
                        continue
                    if child.name.startswith('h') and child.name[1:].isdigit():
                        heading = paragraph.insert_paragraph_before(child.get_text())
                        style = "Heading %s" % child.name[1:]
                        if style in available_styles:
                            heading.style = style
                        else:
                            heading.style = doc.styles.add_style(style, 1)
                        for run in heading.runs:
                            run.font.size = FONT_SIZE
                            run.font.name = FONT_NAME[child.name]
                            # 直接用 run.font.name = fontname 可能无效，因为 docx 只修改 latin 字体，但 eastAsia 才控制中文
                            run._element.rPr.rFonts.set(qn("w:eastAsia"), FONT_NAME[child.name])
                            run.font.color.rgb = RGBColor(0, 0, 0)
                            run.font.italic = False
                    elif child.name == 'p':
                        para = paragraph.insert_paragraph_before(child.get_text())
                        for run in para.runs:
                            run.font.size = FONT_SIZE
                            run.font.name = FONT_NAME[child.name]
                            run._element.rPr.rFonts.set(qn("w:eastAsia"), FONT_NAME[child.name])
                            run.font.color.rgb = RGBColor(0, 0, 0)
                        add_indent(para, indent_chars=2)
                    else:
                        recursive_parse(child, paragraph)

            recursive_parse(soup, paragraph)

    doc.save(output_path)

# 根据 html 生成 docx
async def gen_doc_without_template(html: str, output_path: str):
    soup = BeautifulSoup(html, 'html.parser')
    doc = Document()
    available_styles = [s.name for s in doc.styles]

    def recursive_parse(element, doc):
        for child in element.children:
            if child.name:
                if child.name.startswith('h') and child.name[1:].isdigit():
                    heading = doc.add_paragraph(child.get_text())
                    style = "Heading %s" % child.name[1:]
                    if style in available_styles:
                        heading.style = style
                    else:
                        heading.style = doc.styles.add_style(style, 1)
                    for run in heading.runs:
                        run.font.size = FONT_SIZE
                        run.font.name = FONT_NAME[child.name]
                        run._element.rPr.rFonts.set(qn("w:eastAsia"), FONT_NAME[child.name])
                        run.font.color.rgb = RGBColor(0, 0, 0)
                        run.font.italic = False
                elif child.name == 'p':
                    para = doc.add_paragraph(child.get_text())
                    for run in para.runs:
                        run.font.size = FONT_SIZE
                        run.font.name = FONT_NAME[child.name]
                        run._element.rPr.rFonts.set(qn("w:eastAsia"), FONT_NAME[child.name])
                        run.font.color.rgb = RGBColor(0, 0, 0)
                    add_indent(para, indent_chars=2)
                else:
                    recursive_parse(child, doc)

    recursive_parse(soup, doc)
    doc.save(output_path)


# 定义清理文件的函数
def cleanup_file(filepath: str):
    try:
        os.remove(filepath)
        log.info(f"已成功删除文件: {filepath}")
    except OSError as e:
        log.error(f"删除文件失败 {filepath}: {e}")

# docx 转 pdf
def convert_docx_to_pdf(input_path) -> str:
    output_path = input_path.replace(".docx", ".pdf")
    try:
        subprocess.run(["libreoffice", "--headless", "--convert-to", "pdf", input_path, "--outdir", STATIC_DIR], check=True)
        print(f"转换成功: {output_path}")
        return output_path
    except subprocess.CalledProcessError as e:
        print(f"转换失败: {e}")
        return ""

# docx 转 wps
def convert_docx_to_wps(input_path) -> str:
    output_path = input_path.replace(".docx", ".wps")
    try:
        subprocess.run(["libreoffice", "--headless", "--convert-to", "wps", input_path, "--outdir", STATIC_DIR], check=True)
        print(f"转换成功: {output_path}")
        return output_path
    except subprocess.CalledProcessError as e:
        print(f"转换失败: {e}")
        return ""

大模型文档处理之 doc

Tue, 18 Mar 2025 16:00:00 GMT

常用的文档处理工具如下

from langchain_community.document_loaders import (
    BSHTMLLoader,
    CSVLoader,
    Docx2txtLoader,
    OutlookMessageLoader,
    PyPDFLoader,
    TextLoader,
    UnstructuredEPubLoader,
    UnstructuredExcelLoader,
    UnstructuredMarkdownLoader,
    UnstructuredPowerPointLoader,
    UnstructuredRSTLoader,
    UnstructuredXMLLoader,
    YoutubeLoader,
)

问题：docx 可以用 Docx2txtLoader 处理，但是 doc 不行，估计是 doc 格式太老了，不想适配了。

尝试过的无效方案：

使用 from langchain_community.document_loaders import UnstructuredWordDocumentLoader
使用 pandoc（不支持 doc 的处理）

可行的解决方案：使用 LibreOffice

subprocess.check_output([SOFFICE_PATH, "--headless", "--convert-to", "docx", file_path, "--outdir", dir])

atrust vpn 多人使用

Sat, 15 Mar 2025 16:00:00 GMT

使用

以 windows 为例

windows 开启 vpn
windows 开启路由转发
- 以管理员身份运行 cmd
- 执行 reg add HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters /v IPEnableRouter /D 1 /f
- 或者进入注册表，将 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\IPEnableRoute设为1
- 进入服务，将 Routing and Remote Access 服务的启动类型更改为自动并启动服务
- 或者在 cmd 执行 sc config RemoteAccess start= auto 和 sc start RemoteAccess
mac 开启路由转发 sudo route add 172.0.0.0/8 192.168.2.2

参考

Open WebUI 开发

Mon, 10 Mar 2025 16:00:00 GMT

启动

下载源码
配置文件：cp -RPp .env.example .env
下载前端依赖：根目录下 npm install
构建前端代码(注意 node 版本)：根目录下 npm run build

下载后端依赖：backend 目录下

conda create --name open-webui python=3.11
conda activate open-webui
pip install -r requirements.txt -U

启动后端：backend 目录下 sh start.sh

遇到的问题

Docker 部署

镜像构建失败

The following signatures couldn't be verified because the public key is not available: NO_PUBKEY 0E98404D386FA1D9

可能为 Docker 版本问题，升级 Docker 版本（尝试升级到 20.10.9 解决）

镜像构建慢

修改源

RUN echo "deb http://mirrors.tuna.tsinghua.edu.cn/debian bookworm main contrib non-free non-free-firmware" > /etc/apt/sources.list && \
    echo "deb http://mirrors.tuna.tsinghua.edu.cn/debian bookworm-updates main contrib non-free non-free-firmware" >> /etc/apt/sources.list && \
    echo "deb http://mirrors.tuna.tsinghua.edu.cn/debian-security bookworm-security main contrib non-free non-free-firmware" >> /etc/apt/sources.list && \
    rm -rf /etc/apt/sources.list.d/* && \
    apt update && apt upgrade -y

打包成二进制

使用 pyinstaller 配置 main.spec

# -*- mode: python ; coding: utf-8 -*-
from PyInstaller.utils.hooks import collect_all, collect_submodules, collect_data_files
from PyInstaller.building.build_main import Tree

datas, binaries, hiddenimports = collect_all('chromadb')
datas += collect_data_files("unstructured")

hiddenimports+=[
    "onnxruntime",
    "tokenizers",
    "tqdm",
    "passlib.handlers.bcrypt",
]

excludes=['torch.utils.tensorboard']

a = Analysis(
    ['main.py'],
    pathex=[],
    binaries=binaries,
    datas=datas,
    hiddenimports=hiddenimports,
    hookspath=[],
    hooksconfig={},
    runtime_hooks=[],
    excludes=excludes,
    noarchive=False,
    optimize=0,
)

a.datas += [
  ('CHANGELOG.md', '../../CHANGELOG.md', 'DATA'),
  ('emoji/unicode_codes/emoji.json', '/root/anaconda3/envs/open-webui-clean/lib/python3.11/site-packages/emoji/unicode_codes/emoji.json', 'DATA')
]
a.datas += Tree('./static', prefix='static')
a.datas += Tree('../../build', prefix='build')
pyz = PYZ(a.pure)

exe = EXE(
    pyz,
    a.scripts,
    a.binaries,
    a.datas,
    [],
    name='main',
    debug=False,
    bootloader_ignore_signals=False,
    strip=False,
    upx=True,
    upx_exclude=[],
    runtime_tmpdir=None,
    console=True,
    disable_windowed_traceback=False,
    argv_emulation=False,
    target_arch=None,
    codesign_identity=None,
    entitlements_file=None,
)

执行 pyinstaller main.spec，构建的包在 dist/main

参考

【GPG error golang 1.19】

树莓派小车

Thu, 27 Feb 2025 16:00:00 GMT

安装

按教程来即可

使用

由于我使用的树莓派5，使用官方提供的镜像时发现在树莓派5上不可用，只能自己安装树莓派官方镜像后，使用网关提供的脚本自己运行 python。

遇到的问题与解决方式

原本的教程中最新的是树莓派4b，买了最新的树莓派5之后，发现与之前的树莓派有不同，在使用 raspblock 时会报错

Traceback (most recent call last):
  File "/usr/lib/python3/dist-packages/serial/serialposix.py", line 322, in open
    self.fd = os.open(self.portstr, os.O_RDWR | os.O_NOCTTY | os.O_NONBLOCK)
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
FileNotFoundError: [Errno 2] No such file or directory: '/dev/ttyAMA0'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "/home/ku/Documents/test.py", line 4, in <module>
    robot = Raspblock()
            ^^^^^^^^^^^
  File "/usr/local/lib/python3.11/dist-packages/Raspblock-0.0.1-py3.11.egg/Raspblock.py", line 12, in __init__
  File "/usr/lib/python3/dist-packages/serial/serialutil.py", line 244, in __init__
    self.open()
  File "/usr/lib/python3/dist-packages/serial/serialposix.py", line 325, in open
    raise SerialException(msg.errno, "could not open port {}: {}".format(self._port, msg))
serial.serialutil.SerialException: [Errno 2] could not open port /dev/ttyAMA0: [Errno 2] No such file or directory: '/dev/ttyAMA0'
Exception ignored in: <function Raspblock.__del__ at 0x7fff32f88c20>
Traceback (most recent call last):
  File "/usr/local/lib/python3.11/dist-packages/Raspblock-0.0.1-py3.11.egg/Raspblock.py", line 16, in __del__
AttributeError: 'Raspblock' object has no attribute 'ser'

解决方法：在配置文件中增加一行以打开ttyAMA0串口，修改 /boot/firmware/config.txt，添加一行 dtoverlay=uart0，保存后重启即可

参考

docker 迁移

Thu, 20 Feb 2025 16:00:00 GMT

关闭 docker 服务 systemctl stop docker.socket
迁移路径 rsync -avzP /var/lib/docker /disk/docker
备份数据目录 mv /var/lib/docker /var/lib/docker.bak
添加软链接 ln -s /disk/docker/ /var/lib/
重启 docker 服务 systemctl start docker
确认 docker 正常
删除备份目录 rm -rf /var/lib/docker.bak

ios 消息推送

Thu, 20 Feb 2025 16:00:00 GMT

docker 部署

docker run -dt --name bark -p 16009:8080 -v /disk/app/bark/data:/data finab/bark-server

ios 应用下载

下载 bark，添加服务器

发送请求

curl https://bark.ioiox.com/your_key/标题/内容

更多参见 bark 应用里的例子

Rust 日志

Wed, 19 Feb 2025 16:00:00 GMT

log - 日志门面

slf4j 是 Java 的日志门面库，log 是 Rust 的日志门面库，由官方积极维护可以放心使用。相应的日志 API 已成为事实上的标准，被其它日志框架所使用，有了日志门面开发者可以很方便切换自己的日志框架。

A lightweight logging facade.

The log crate provides a single logging API that abstracts over the actual logging implementation. Libraries can use the logging API provided by this crate, and the consumer of those libraries can choose the logging implementation that is most suitable for its use case.

If no logging implementation is selected, the facade falls back to a “noop” implementation that ignores all log messages. The overhead in this case is very small - just an integer load, comparison and jump.

A log request consists of a target, a level, and a body. A target is a string which defaults to the module path of the location of the log request, though that default may be overridden. Logger implementations typically use the target to filter requests based on some user configuration.

使用

引入

[dependencies]
log = "0.4"

或

cargo add log

使用

use log::{info, warn,error,trace};

fn main() {
    // 记录日志
    info!("This is an info message");
    warn!("This is a warning message");
    error!("This is an error message");
    trace!("This is an trace message");
}

运行上面的示例，实际上看不到任何输出。因为 log 仅仅是日志门面库，它并不具备完整的日志库功能！因为 log 仅仅是日志门面库，对于库和应用的开发者来说使用方法是有区别的，这也是 log 包这么设计的优势所在。

除了以上常用的，log 还提供了 log! 和 log_enabled! 宏，后者用于确定一条消息在当前模块中，对于给定的日志级别是否能够被记录。

use log::Level::Debug;
use log::{debug, log_enabled};

// 判断能否记录 Debug 消息
if log_enabled!(Debug) {
    let data = expensive_call();
     // 下面的日志记录较为昂贵，因此我们先在前面判断了是否能够记录，能，才继续这里的逻辑
    debug!("expensive debug data: {} {}", data.x, data.y);
}
if log_enabled!(target: "Global", Debug) {
   let data = expensive_call();
   debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);
}

而 log! 宏就简单的多，它是一个通用的日志记录方式，因此需要我们手动指定日志级别：

use log::{log, Level};

let data = (42, "Forty-two");
let private_data = "private";

log!(Level::Error, "Received errors: {}, {}", data.0, data.1);
log!(target: "app_events", Level::Warn, "App warning: {}, {}, {}",
    data.0, data.1, private_data);

库的开发者

作为库的开发者，你只要在库中使用门面库即可，将具体的日志库交给用户去选择和绑定：

use log::{info, trace, warn};
pub fn deal_with_something() {
    // 开始处理

    // 记录一些日志
    trace!("a trace log");
    info!("a info long: {}", "abc");
    warn!("a warning log: {}, retrying", err);

    // 结束处理
}

应用开发者

如果是应用开发者，就需要去选择一个具体的日志库了。

目前已经有了不少日志库实现，官方在 github 上也推荐了一些，主要分为以下几类：

简单的最小记录器，如 env_logger 等
复杂的可配置框架，如 log4rs 等
其他设施的适配器，如 syslog、db_logger 等
对于 WebAssembly 二进制文件：console_log
对于动态库：需要在日志上构造一个 FFI 安全包装器，以便在库中进行初始化。
实用程序，如 alterable_logger 等

日志库开发者

对于日志库开发者而言，自然要实现自己的 Log 特征:

use log::{Record, Level, Metadata};
struct SimpleLogger;
impl log::Log for SimpleLogger {
    fn enabled(&self, metadata: &Metadata) -> bool {
        metadata.level() <= Level::Info
    }
    fn log(&self, record: &Record) {
        if self.enabled(record.metadata()) {
            println!("{} - {}", record.level(), record.args());
        }
    }
    fn flush(&self) {}
}

除此之外，还需要包装下 set_logger 和 set_max_level：

use log::{SetLoggerError, LevelFilter};
static LOGGER: SimpleLogger = SimpleLogger;
pub fn init() -> Result<(), SetLoggerError> {
    log::set_logger(&LOGGER)
        .map(|()| log::set_max_level(LevelFilter::Info))
}

然后在 main 函数里设置全局记录器：

use log::{info, warn,error,trace};

fn main() {
    //设置日志
    init();
    // 记录日志
    info!("This is an info message");
    warn!("This is a warning message");
    error!("This is an error message");
    trace!("This is an trace message");
}

运行后终端输出如下，因为设置日志等级为Info，所以没有输出Trace等级日志：

INFO - This is an info message
WARN - This is a warning message
ERROR - This is an error message

log4rs

log4rs 是一个高度可配置的日志框架，以 Java 的 Logback 和 log4j 库为模型。

使用

添加依赖

cargo add log4rs

添加配置文件

在项目根目录下，创建一个 log4rs.yaml 配置文件，并添加以下内容：

refresh_rate: 30 seconds

appenders:
  stdout:
    kind: console
    encoder:
      pattern: "{d(%Y-%m-%d %H:%M:%S.%f)} [{l}] {t} - {m}{n}"
  
  rolling_file:
    kind: rolling_file
    path: logs/test.log
    append: true 
    encoder:
      pattern: "{d(%Y-%m-%d %H:%M:%S.%f)} [{l}] {t} - {m}{n}"
    policy:
      kind: compound
      trigger:
        kind: size
        limit: 10 mb
      roller:        
        kind: fixed_window
        pattern: logs/test.{}.log
        base: 1
        count: 5
        
root:
  level: info 
  appenders:
    - stdout
    - rolling_file

上面配置文件设定日志输出到控制台、文件，文件按10 mb大小滚动，只保留最近五个文件。各个配置字段的具体含义可以参考配置：

refresh_rate：用于确定 log4rs 扫描配置文件以查找更改的频率，如果发现更改，记录器将自动重新配置
appender：负责将日志收集到文件、控制台或系统日志, 可配置多个
stdout、rolling_file：追加器的唯一标识字符串，自己随便定义，它的 kind 字段只支持console、file、rolling_file 三种实现
encoder：负责将 log 信息转换为合适的格式, 如固定格式的平文本或json
pattern：编码模板，格式可配置，具体格式详见pattern
policy：策略字段，策略必须具有 kind 字段，默认（且仅受支持）策略为 kind: compound
trigger：触发器字段用于指示何时滚动日志文件，支持 size 和 time 两种类型，这里使用的是按大小

使用

use log::*;
use log4rs;

fn main() {
    log4rs::init_file("log4rs.yaml", Default::default()).unwrap();

    for i in 1..=1000 {
        info!("This is loop iteration {}", i);
    }
}

运行结果

2024-04-01 15:43:28.596832500 [INFO] hello_world - This is loop iteration 1

参考

Rust 实现日志记录功能

服务监控

Wed, 19 Feb 2025 16:00:00 GMT

安装

安装 node-export

docker run -d --restart=always -p 9100:9100 prom/node-exporter

验证：访问 http://服务器IP:9100/metrics

安装 Prometheus

准备 /disk/app/prometheus/prometheus.yml，IP地址 替换成 node-exporter 所在服务器地址

global:
  scrape_interval: 60s
  evaluation_interval: 60s
 
scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets: ['localhost:9090']
        labels:
          instance: prometheus
 
  - job_name: linux
    static_configs:
      - targets: ['IP地址:9100']
        labels:
          instance: localhost

创建 docker 容器 docker run -d --restart=always -p 9090:9090 -v /disk/app/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus

验证：访问 http://IP地址:9090

安装 grafana

docker run -d --restart=always --name grafana -p 3000:3000 grafana/grafana

访问 192.168.1.3:3000，用户名密码都是 admin

添加数据源

下载ID为11074的模板文件使用下载的模板文件创建仪表盘效果

web 粒子效果

Fri, 07 Feb 2025 16:00:00 GMT

<html>
    <head> </head>
    <body>
        <canvas id="canvas"></canvas>
        <script>
            class Vector2 {
                constructor(x, y) {
                    this.x = x;
                    this.y = y;
                }
                set(x, y) {
                    this.x = x;
                    this.y = y;
                    return this;
                }
                clone() {
                    return new Vector2(this.x, this.y);
                }
                add(v) {
                    this.x += v.x;
                    this.y += v.y;
                    return this;
                }
                sub(v) {
                    this.x -= v.x;
                    this.y -= v.y;
                    return this;
                }
                mult(v) {
                    this.x *= v.x;
                    this.y *= v.y;
                    return this;
                }
                magnitude() {
                    return Math.sqrt(this.x * this.x + this.y * this.y);
                }
                setFromScalarAngle(scalar, angle) {
                    this.x = Math.cos(angle) * scalar;
                    this.y = Math.sin(angle) * scalar;
                }
            }

            class Particle {
                constructor(canvas, x, y, scalar, direction, radius, color) {
                    this.canvas = canvas;
                    this.position = new Vector2(x, y);
                    this.velocity = new Vector2();
                    this.velocity.setFromScalarAngle(scalar, direction);
                    this.radius = radius;
                    this.color = color;
                    this.range = 100;
                }
                update() {
                    this.position.add(this.velocity);

                    if (this.position.x - this.range > this.canvas.width) {
                        this.position.x = this.canvas.width / 2;
                        this.position.y = this.canvas.height / 2;
                    }
                    if (this.position.x + this.range < 0) {
                        this.position.x = this.canvas.width / 2;
                        this.position.y = this.canvas.height / 2;
                    }
                    if (this.position.y - this.range > this.canvas.height) {
                        this.position.x = this.canvas.width / 2;
                        this.position.y = this.canvas.height / 2;
                    }
                    if (this.position.y + this.range < 0) {
                        this.position.x = this.canvas.width / 2;
                        this.position.y = this.canvas.height / 2;
                    }
                }
            }

            window.onload = function () {
                var canvas = document.getElementById("canvas"),
                    ctx = canvas.getContext("2d"),
                    width = (canvas.width = window.innerWidth),
                    height = (canvas.height = window.innerHeight),
                    particles = [],
                    particleNum = 100,
                    colors = [
                        "#0952BD",
                        "#A5BFF0",
                        "#118CD6",
                        "#1AAEE8",
                        "#F2E8C9",
                    ];

                window.onresize = () => {
                    width = canvas.width = window.innerWidth;
                    height = canvas.height = window.innerHeight;
                };

                function randomIntFromRange(min, max) {
                    return Math.floor(Math.random() * (max - min + 1) + min);
                }
                function randomColor(colors) {
                    return colors[Math.floor(Math.random() * colors.length)];
                }

                for (let i = 0; i < particleNum; i++) {
                    particles.push(
                        new Particle(
                            canvas,
                            canvas.width / 2,
                            canvas.height / 2,
                            Math.random() * 8 + 2,
                            Math.random() * Math.PI * 2,
                            randomIntFromRange(5, 7),
                            randomColor(colors),
                        ),
                    );
                }

                function draw() {
                    for (let i = 0; i < particleNum; i++) {
                        var p = particles[i];
                        p.update();
                        ctx.save();
                        ctx.beginPath();
                        ctx.arc(
                            p.position.x,
                            p.position.y,
                            p.radius,
                            0,
                            Math.PI * 2,
                        );
                        ctx.shadowColor = p.color;
                        ctx.shadowBlur = 5;
                        ctx.shadowOffsetX = 0;
                        ctx.shadowOffsetY = 0;
                        ctx.globalAlpha = "1";
                        ctx.fillStyle = p.color;
                        ctx.fill();
                        ctx.restore();
                    }
                }

                render();

                function render() {
                    ctx.fillStyle = "hsla(260,40%,5%,.2)";
                    ctx.fillRect(0, 0, width, height);
                    draw();
                    requestAnimationFrame(render);
                }
            };
        </script>
    </body>
</html>

豆包文字转语音

Sat, 25 Jan 2025 16:00:00 GMT

F12 查看逻辑

通过 webservice，先发送请求，内容为需要转为语音的文字

{"event":"text","text":"以下分别从给朋友、家人、同事三个角度，为你创作新春祝福：\n\n### 给朋友\n宝子，龙年新春到啦！愿你在这新的一年，像龙一样威风凛凛，活力满满！所有的倒霉事都被龙尾巴一扫而光，好事则如烟花般噼里啪啦接踵而至。愿你去想去的地方，见想见的人，做想做的事，每一天都能笑出鹅叫，快乐到飞起！新的一年，咱们继续一起疯，一起闹，一起把生活折腾得热气腾腾！ \n\n### 给家人\n亲爱的家人们，龙年钟声敲响，新春佳节已至。在这祥龙贺岁的美好时刻，愿咱们一家人如同龙行四海般，运势亨通，生活顺意。希望长辈们身体硬朗，吃嘛嘛香，尽享天伦之乐；孩子们活泼聪慧，学业如芝麻开花节节高；而我们这些中坚力量，事业腾飞，工作轻松又多金。一家人整整齐齐，和和美美，一起迎接龙年里每一个灿烂的日子，让幸福的笑声永远在咱们家中回荡。 \n\n### 给同事\n各位同事，祥龙贺岁，福满人间！值此新春佳节，愿我们在龙年里，如同蛟龙得水，在工作的海洋中畅快遨游，业绩如飞龙在天，一飞冲天。新的一年，咱们携手共进，以龙的精神，攻坚克难，让项目顺利推进，让团队蒸蒸日上。也希望大家在忙碌工作之余，能尽情享受生活的美好，阖家欢乐，幸福安康，共同开启龙年的辉煌篇章！ "}

webservice 就会返回 mp3 的二进制文件，拼接在一起即完整的 mp3.

完整代码，仅供参考

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"

	"github.com/gorilla/websocket"
)

// 文字转语音
func main() {
	// WebSocket 服务的地址 (wss:// 或 ws://)
	url := "wss://ws-samantha.doubao.com/samantha/audio/tts?speaker=zh_female_taozi_conversation_v4_wvae_bigtts&format=aac&speech_rate=0&pitch=0&version_code=20800&language=zh&device_platform=web&aid=497858&real_aid=497858&pc_version=1.51.82&pkg_type=release_version&device_id=7464034169136465444&web_id=7464034176154175012&tea_uuid=7464034176154175012&use-olympus-account=1&region=CN&sys_region=CN&samantha_web=1"
	// 自定义请求头
	headers := http.Header{}
        // TODO: 放入 cookie
	headers.Add("cookie", "")

	// 创建 WebSocket 连接
	conn, _, err := websocket.DefaultDialer.Dial(url, headers)
	if err != nil {
		log.Fatalf("连接 WebSocket 失败: %v", err)
	}
	defer conn.Close()

	fmt.Println("已连接到 WebSocket")

	// 向服务端发送消息 (如果需要)
	err = conn.WriteMessage(websocket.TextMessage, []byte(`{"event":"text","text":"以下分别从给朋友、家人、同事三个角度，为你创作新春祝福：\n\n### 给朋友\n宝子，龙年新春到啦！愿你在这新的一年，像龙一样威风凛凛，活力满满！所有的倒霉事都被龙尾巴一扫而光，好事则如烟花般噼里啪啦接踵而至。愿你去想去的地方，见想见的人，做想做的事，每一天都能笑出鹅叫，快乐到飞起！新的一年，咱们继续一起疯，一起闹，一起把生活折腾得热气腾腾！ \n\n### 给家人\n亲爱的家人们，龙年钟声敲响，新春佳节已至。在这祥龙贺岁的美好时刻，愿咱们一家人如同龙行四海般，运势亨通，生活顺意。希望长辈们身体硬朗，吃嘛嘛香，尽享天伦之乐；孩子们活泼聪慧，学业如芝麻开花节节高；而我们这些中坚力量，事业腾飞，工作轻松又多金。一家人整整齐齐，和和美美，一起迎接龙年里每一个灿烂的日子，让幸福的笑声永远在咱们家中回荡。 \n\n### 给同事\n各位同事，祥龙贺岁，福满人间！值此新春佳节，愿我们在龙年里，如同蛟龙得水，在工作的海洋中畅快遨游，业绩如飞龙在天，一飞冲天。新的一年，咱们携手共进，以龙的精神，攻坚克难，让项目顺利推进，让团队蒸蒸日上。也希望大家在忙碌工作之余，能尽情享受生活的美好，阖家欢乐，幸福安康，共同开启龙年的辉煌篇章！ "}	`))
	if err != nil {
		log.Fatalf("发送消息失败: %v", err)
	}

	// 创建文件用于保存接收到的数据
	os.Remove("output.mp3")
	file, err := os.Create("output.mp3")
	if err != nil {
		log.Fatalf("创建文件失败: %v", err)
	}
	file.Close()
	file, err = os.OpenFile("output.mp3", os.O_APPEND|os.O_WRONLY, 0644) // 替换为目标文件名
	if err != nil {
		log.Fatalf("创建文件失败: %v", err)
	}
	defer file.Close()

	// 接收消息
outer:
	for {
		messageType, message, err := conn.ReadMessage()
		if err != nil {
			log.Fatalf("读取消息失败: %v", err)
		}

		// 根据消息类型处理
		switch messageType {
		case websocket.TextMessage:
			fmt.Printf("收到文本消息: %s\n", string(message))
			if string(message) == `{"event":"sentence_end","code":0,"message":""}` {
				break outer
			}
		case websocket.BinaryMessage:
			fmt.Printf("收到二进制消息: %x\n", message)
			_, err = file.Write(message)
			if err != nil {
				log.Fatalf("写入文件失败: %v", err)
			}

		default:
			fmt.Println("收到未知消息类型")
		}
	}
}

旁路由配置

Mon, 20 Jan 2025 16:00:00 GMT

网络拓扑

避坑：Docker 运行 OpenWrt 容器时在进行包含 “杀死 OpenWrt Docker 容器进程” 的操作的时候确实会出现这个问题。目前还不清楚是哪方面的原因。

解决办法：关闭容器后尽快删除容器。

OpenWrt 使用

安装 OpenWrt

为了方便树莓派用于其他用途，使用 docker 的方式

下载镜像包 openwrt-22.03.5-armvirt-64-default-rootfs.tar.gz，来源：https://archive.openwrt.org/releases/22.03.5/targets/armvirt/64/
解压得到 tar 包 gunzip openwrt-22.03.5-armvirt-64-default-rootfs.tar.gz
导入镜像 docker import openwrt-22.03.5-armvirt-64-default-rootfs.tar openwrt

推荐：或者直接在创建 docker 容器时使用 docker run --restart always --name openwrt -d --network openwrt --privileged registry.cn-shanghai.aliyuncs.com/suling/openwrt:armv8 /sbin/init

x86 架构使用 docker run --restart always --name openwrt -d --network openwrt --privileged registry.cn-shanghai.aliyuncs.com/suling/openwrt:x86_64 /sbin/init
打开网卡混杂模式，使网卡可以接收任何流量，添加到启动文件 ip link set eth0 promisc on，执行 ifconfig eth0 网卡 flag 信息有 PROMISC 表示开启成功

eth0: flags=4419<UP,BROADCAST,RUNNING,PROMISC,MULTICAST> mtu 1500
创建docker网络，网络驱动程序为macvlan，网络命名为openwrt，子网和网关根据实际情况修改 docker network create -d macvlan --subnet=192.168.3.0/24 --gateway=192.168.3.1 -o parent=eth0 openwrt
创建 docker 容器 docker run --name openwrt -d --network openwrt --privileged openwrt /sbin/init

如果报错 Error response from daemon: failed to create the macvlan port: operation not supported，执行 apt install linux-modules-extra-raspi，linux-modules-extra-raspi 是树莓派 Ubuntu Arm 的不常用扩展，Ubuntu 最新的包管理中默认不包含扩展；因此需要单独安装，安装后需要重启树莓派

修改容器网络配置

docker exec -it openwrt bash
vi /etc/config/network

# 修改 lan 配置
config interface 'lan'
        option ifname 'eth0'
        option proto 'static'
        option netmask '255.255.255.0'
        option ip6assign '60'
        option ipaddr '192.168.1.99'
        option gateway '192.168.1.1'
        option dns '192.168.1.1'

# 修改完成后重启容器的网络
/etc/init.d/network restart

重启完成后访问 http://192.168.1.99 ，使用账户 root 和密码 password 即可进入管理页面

OpenWrt 配置
- 登录后在网络-接口中修改 LAN 接口，在底层基本设置中选择忽略此接口，使用默认路由器做 DHCP 服务器

OpenWrt 安装 OpenClash 插件

OpenClash Github

下载地址

下载 luci-app-openclash 插件，打开 OpenWrt 管理界面，进入系统列表页找到文件传输，选择上传 luci-app-openclash_0.38.7-beta_all.ipk 插件，并在上传文件列表进行安装，如下图：

进入服务-OpenClash，选择配置文件订阅，新增订阅；输入订阅的链接地址，保存并更新即可；这样以 OpenWrt 为网关的设备就可以通过 OpenClash 访问特定的资源了

启动

设置路由器的网关和 dns

参考

消息队列知识总结

Thu, 16 Jan 2025 16:00:00 GMT

基础概念

Broker 节点：一个 Broker 就是一个 Kafka 服务端进程。在生产环境下，通常会运行多个 Broker 组成一个 Kafka 集群，并且将每一个 Broker 都部署在不同的机器上，以提高系统的可用性。
Partition 分区：为了提高性能，在 Kafka 中，可以将一个 Topic 划分成多个 Partition，类似于分区、分片的概念。每一个 Partition 是一组有序的消息，同一个 Topic 的多个 Partition 可以存储在不同的 Broker 上。Kafka 中的分区编号从 0 开始，生产者生产的每一个消息只能被发送到一个分区中。
Topic 主题：在 Kafka 中，发送消息的系统 A 和获取消息的系统 B 在发送/获取消息的时候，都需要指定一个 Topic。Topic 是逻辑上的一个容器，我们可以在 Kafka 中创建若干个 Topic，然后根据业务和消息类型，将消息发送到不同的 Topic 当中。
Message 消息：消息系统最重要的主题无疑是消息本身，消息是 Kafka 主要处理的对象。最简单的消息系统处理流程就是：系统 A 将消息发送给 Kafka，系统 B 再从 Kafka 获取消息。
Producer 生产者：生产消息
Consumer 消费者：消费消息
Replication 副本：Replica 是 Kafka 实现高可用另一个特性。每一个 Partition 可以有多个 Replica 副本，提供存储冗余。将每个 Partition 的多个副本保存在不同的 Broker 中，其中一个是 Leader Replica，其余为 Follower Replica。当一个 Broker 宕机后，如果造成了 Leader Replica 不可用，那么会从 Follower 中选举出一个新的 Leader。生产者和消费者与 Partition 交互的时候，都只会与 Leader 交互，Follower 只充当数据副本的角色。当生产者发送一个消息后，只有当所有的 Replica 都收到消息并告知 Leader 之后，这个消息才能被消费者读取到。
Offset 消息位移：在 Topic 的消费过程中，由于消息需要被不同的组进行多次消费，所以消费完的消息并不会立即被删除，这就需要为每个消费组在每个队列上维护一个消费位置，这个位置之前的消息都被消费过，之后的消息都没有被消费过，每成功消费一条消息，消费位置就加一。
Consumer Group 消费者组：为了实现高吞吐量，在 Kafka 中，可以让若干个消费者组成一个消费者组，共同消费同一个 Topic 下不同 Partition 的消息，以实现更高的吞吐量，不同 Consumer Group 实现不同的功能，Group A 用于实时分析日志，Group B 用于将数据存储到数据库。
Rebalance 重平衡：当 Kafka 的某个主题的消费者组中，有一个消费者不可用后，其他消费者会自动重新分配订阅的主题分区，这个过程叫做 Rebalance，是 Kafka 实现消费者端高可用的重要手段。
Coordinator 协调员：Consumer 维护与 Coordinator 之间的心跳，这样 Coordinator 就能感知到 Consumer 的状态，在 Consumer 故障的时候及时触发 Rebalance。

消息模型

早期的消息队列，就是按照“队列”的数据结构来设计的。我们一起看下这个图，Producer 发消息就是入队操作，Consumer 收消息就是出队也就是删除操作，服务端存放消息的容器自然就称为“队列”。这就是最初的一种消息模型：队列模型。如果有多个生产者往同一个队列里面发送消息，这个队列中可以消费到的消息，就是这些生产者生产的所有消息的合集。消息的顺序就是这些生产者发送消息的自然顺序。如果有多个消费者接收同一个队列的消息，这些消费者之间实际上是竞争的关系，每个消费者只能收到队列中的一部分消息，也就是说任何一条消息只能被其中的一个消费者收到。

如果需要将一份消息数据分发给多个消费者，要求每个消费者都能收到全量的消息，例如，对于一份订单数据，风控系统、分析系统、支付系统等都需要接收消息。这个时候，单个队列就满足不了需求，一个可行的解决方式是，为每个消费者创建一个单独的队列，让生产者发送多份。

显然这是个比较蠢的做法，同样的一份消息数据被复制到多个队列中会浪费资源，更重要的是，生产者必须知道有多少个消费者。为每个消费者单独发送一份消息，这实际上违背了消息队列“解耦”这个设计初衷。

为了解决这个问题，演化出了另外一种消息模型：“发布 - 订阅模型（Publish-Subscribe Pattern）”。

几乎所有的消息队列产品都使用一种非常朴素的“请求 - 确认”机制，确保消息不会在传递过程中由于网络或服务器故障丢失。具体的做法也非常简单。在生产端，生产者先将消息发送给服务端，也就是 Broker，服务端在收到消息并将消息写入主题或者队列中后，会给生产者发送确认的响应。如果生产者没有收到服务端的确认或者收到失败的响应，则会重新发送消息；在消费端，消费者在收到消息并完成自己的消费业务逻辑（比如，将数据保存到数据库中）后，也会给服务端发送消费成功的确认，服务端只有收到消费确认后，才认为一条消息被成功消费，否则它会给消费者重新发送这条消息，直到收到对应的消费成功确认。这个确认机制很好地保证了消息传递过程中的可靠性，但是，引入这个机制在消费端带来了一个不小的问题。什么问题呢？为了确保消息的有序性，在某一条消息被成功消费之前，下一条消息是不能被消费的，否则就会出现消息空洞，违背了有序性这个原则。也就是说，每个主题在任意时刻，至多只能有一个消费者实例在进行消费，那就没法通过水平扩展消费者的数量来提升消费端总体的消费性能。为了解决这个问题，Kafka 在 Topic 下增加了 Partition 的概念。每个 Topic 包含多个 Partition，通过多个 Partition 来实现多实例并行生产和消费。

存储机制

同一个topic下有多个不同partition，每个partition为一个目录，partiton命名规则为topic名称+有序序号，第一个partiton序号从0开始，序号最大值为partitions数量减1。

每个partion(目录)相当于一个巨型文件被平均分配到多个大小相等segment(段)数据文件中。但每个段segment file消息数量不一定相等，这种特性方便old segment file快速被删除。
每个partiton只需要支持顺序读写就行了，segment文件生命周期由服务端配置参数决定。

partion中segment file组成和物理结构。

segment file组成：由2大部分组成，分别为index file和data file，此2个文件一一对应，成对出现，后缀”.index”和“.log”分别表示为segment索引文件、数据文件.
segment文件命名规则：partion全局的第一个segment从0开始，后续每个segment文件名为上一个segment文件最后一条消息的offset值。数值最大为64位long大小，19位数字字符长度，没有数字用0填充。

index file 和 data file 的对应关系

message 物理结构

关键字	解释说明
8 byte offset	在parition(分区)内的每条消息都有一个有序的id号，这个id号被称为偏移(offset),它可以唯一确定每条消息在parition(分区)内的位置。即offset表示partiion的第多少message
4 byte message size	message大小
4 byte CRC32	用crc32校验message
1 byte “magic”	表示本次发布Kafka服务程序协议版本号
1 byte “attributes”	表示为独立版本、或标识压缩类型、或编码类型。
4 byte key length	表示key的长度,当key为-1时，K byte key字段不填
K byte key	可选
value bytes payload	表示实际消息数据。

在partition中如何通过offset查找message

例如读取offset=368776的message，需要通过下面2个步骤查找。

第一步查找segment file 上述图2为例，其中00000000000000000000.index表示最开始的文件，起始偏移量(offset)为0.第二个文件00000000000000368769.index的消息量起始偏移量为368770 = 368769 + 1.同样，第三个文件00000000000000737337.index的起始偏移量为737338=737337 + 1，其他后续文件依次类推，以起始偏移量命名并排序这些文件，只要根据offset 二分查找文件列表，就可以快速定位到具体文件。当offset=368776时定位到00000000000000368769.index|log
第二步通过segment file查找message 通过第一步定位到segment file，当offset=368776时，依次定位到00000000000000368769.index的元数据物理位置和00000000000000368769.log的物理偏移地址，然后再通过00000000000000368769.log顺序查找直到offset=368776为止。

这样做的优点，segment index file 采取稀疏索引存储方式，它减少索引文件大小，通过 mmap（内存映射文件）可以直接内存操作，稀疏索引（即不为每一条数据建索引）为数据文件的每个对应 message 设置一个元数据指针,它比稠密索引节省了更多的存储空间，但查找起来需要消耗更多的时间。

Kafka 高性能 IO 实现

使用批量消息提升服务端处理能力

Kafka 的 Producer 只提供了单条发送的 send() 方法，并没有提供任何批量发送的接口。但实际上，Kafka 的客户端 SDK 在实现消息发送逻辑的时候，采用了异步批量发送的机制。当你调用 send() 方法发送一条消息之后，无论你是同步发送还是异步发送，Kafka 都不会立即就把这条消息发送出去。它会先把这条消息，存放在内存中缓存起来，然后选择合适的时机把缓存中的所有消息组成一批，一次性发给 Broker。
在服务端，Kafka 不会把一批消息再还原成多条消息，再一条一条地处理，这样太慢了。在 Broker 整个处理流程中，无论是写入磁盘、从磁盘读出来、还是复制到其他副本这些流程中，批消息都不会被解开，一直是作为一条“批消息”来进行处理的。
在消费时，消息同样是以批为单位进行传递的，Consumer 从 Broker 拉到一批消息后，在客户端把批消息解开，再一条一条交给用户代码处理。

构建批消息和解开批消息分别在发送端和消费端的客户端完成，不仅减轻了 Broker 的压力，最重要的是减少了 Broker 处理请求的次数，提升了总体的处理能力。

使用顺序读写提升磁盘 IO 性能

相比于网络传输和内存，磁盘 IO 的速度是比较慢的。对于消息队列的服务端来说，性能的瓶颈主要在磁盘 IO 这一块。

对于磁盘来说，它有一个特性，就是顺序读写的性能要远远好于随机读写。在 SSD（固态硬盘）上，顺序读写的性能要比随机读写快几倍，如果是机械硬盘，这个差距会达到几十倍。为什么呢？

操作系统每次从磁盘读写数据的时候，需要先寻址，也就是先要找到数据在磁盘上的物理位置，然后再进行数据读写。如果是机械硬盘，这个寻址需要比较长的时间，因为它要移动磁头，这是个机械运动，机械硬盘工作的时候会发出咔咔的声音，就是移动磁头发出的声音。

顺序读写相比随机读写省去了大部分的寻址时间，它只要寻址一次，就可以连续地读写下去，所以说，性能要比随机读写要好很多。

Kafka 就是充分利用了磁盘的这个特性。它的存储设计非常简单，对于每个分区，它把从 Producer 收到的消息，顺序地写入对应的 log 文件中，一个文件写满了，就开启一个新的文件这样顺序写下去。消费的时候，也是从某个全局的位置开始，也就是某一个 log 文件中的某个位置开始，顺序地把消息读出来。

这样一个简单的设计，充分利用了顺序读写这个特性，极大提升了 Kafka 在使用磁盘时的 IO 性能。

利用 PageCache 加速消息读写

PageCache 是现代操作系统都具有的一项基本特性。通俗地说，PageCache 就是操作系统在内存中给磁盘上的文件建立的缓存。无论我们使用什么语言编写的程序，在调用系统的 API 读写文件的时候，并不会直接去读写磁盘上的文件，应用程序实际操作的都是 PageCache，也就是文件在内存中缓存的副本。

应用程序在写入文件的时候，操作系统会先把数据写入到内存中的 PageCache，然后再一批一批地写到磁盘上。读取文件的时候，也是从 PageCache 中来读取数据，这时候会出现两种可能情况。

一种是 PageCache 中有数据，那就直接读取，这样就节省了从磁盘上读取数据的时间；另一种情况是，PageCache 中没有数据，这时候操作系统会引发一个缺页中断，应用程序的读取线程会被阻塞，操作系统把数据从文件中复制到 PageCache 中，然后应用程序再从 PageCache 中继续把数据读出来，这时会真正读一次磁盘上的文件，这个读的过程就会比较慢。

用户的应用程序在使用完某块 PageCache 后，操作系统并不会立刻就清除这个 PageCache，而是尽可能地利用空闲的物理内存保存这些 PageCache，除非系统内存不够用，操作系统才会清理掉一部分 PageCache。清理的策略一般是 LRU 或它的变种算法，这个算法我们不展开讲，它保留 PageCache 的逻辑是：优先保留最近一段时间最常使用的那些 PageCache。

Kafka 在读写消息文件的时候，充分利用了 PageCache 的特性。一般来说，消息刚刚写入到服务端就会被消费，按照 LRU 的“优先清除最近最少使用的页”这种策略，读取的时候，对于这种刚刚写入的 PageCache，命中的几率会非常高。

也就是说，大部分情况下，消费读消息都会命中 PageCache，带来的好处有两个：一个是读取的速度会非常快，另外一个是，给写入消息让出磁盘的 IO 资源，间接也提升了写入的性能。

ZeroCopy：零拷贝技术

我们知道，在服务端，处理消费的大致逻辑是这样的：

首先，从文件中找到消息数据，读到内存中；
然后，把消息通过网络发给客户端。

这个过程中，数据实际上做了 2 次或者 3 次复制：

从文件复制数据到 PageCache 中，如果命中 PageCache，这一步可以省掉；
从 PageCache 复制到应用程序的内存空间中，也就是我们可以操作的对象所在的内存；
从应用程序的内存空间复制到 Socket 的缓冲区，这个过程就是我们调用网络应用框架的 API 发送数据的过程。

Kafka 使用零拷贝技术可以把这个复制次数减少一次，上面的 2、3 步骤两次复制合并成一次复制。直接从 PageCache 中把数据复制到 Socket 缓冲区中，这样不仅减少一次数据复制，更重要的是，由于不用把数据复制到用户内存空间，DMA 控制器可以直接完成数据复制，不需要 CPU 参与，速度更快。

数据压缩

什么情况适合数据压缩？

不压缩直接传输需要的时间是：传输未压缩数据的耗时。
使用数据压缩需要的时间是：压缩耗时 + 传输压缩数据耗时 + 解压耗时。

压缩和解压的操作都是计算密集型的操作，非常耗费 CPU 资源。如果你的应用处理业务逻辑就需要耗费大量的 CPU 资源，就不太适合再进行压缩和解压。

又比如说，如果你的系统的瓶颈是磁盘的 IO 性能，CPU 资源又很闲，这种情况就非常适合在把数据写入磁盘前先进行压缩。

Kafka 是否开启压缩，这是可以配置，它也支持配置使用哪一种压缩算法。原因我们在上面说过，不同的业务场景是否需要开启压缩，选择哪种压缩算法是不能一概而论的。所以，Kafka 的设计者把这个选择权交给使用者。

在开启压缩时，Kafka 选择一批消息一起压缩，每一个批消息就是一个压缩分段。使用者也可以通过参数来控制每批消息的大小。在 Kafka 中，生产者生成一个批消息发给服务端，在服务端中是不会拆分批消息的。那按照批来压缩，意味着，在服务端也不用对这批消息进行解压，可以整批直接存储，然后整批发送给消费者。最后，批消息由消费者进行解压。

在服务端不用解压，就不会耗费服务端宝贵的 CPU 资源，同时还能获得压缩后，占用传输带宽小，占用存储空间小的这些好处，这是一个非常聪明的设计。

实现分布式事务

给消息服务器发送一个“半消息”，这个半消息不是说消息内容不完整，它包含的内容就是完整的消息内容，半消息和普通消息的唯一区别是，在事务提交之前，对于消费者来说，这个消息是不可见的。如果在第四步提交事务消息时失败了怎么办？对于这个问题，Kafka 和 RocketMQ 给出了 2 种不同的解决方案。

Kafka 的解决方案比较简单粗暴，直接抛出异常，让用户自行处理。我们可以在业务代码中反复重试提交，直到提交成功，或者删除之前创建的订单进行补偿。
在 RocketMQ 中的事务实现中，增加了事务反查的机制来解决事务消息提交失败的问题。如果在提交或者回滚事务消息时发生网络异常，RocketMQ 的 Broker 没有收到提交或者回滚的请求，Broker 会定期去 Producer 上反查这个事务对应的本地事务的状态，然后根据反查结果决定提交或者回滚这个事务。为了支撑这个事务反查机制，我们的业务代码需要实现一个反查本地事务状态的接口，告知 RocketMQ 本地事务是成功还是失败。

消息丢失

检测消息丢失

如果是 IT 基础设施比较完善的公司，一般都有分布式链路追踪系统，使用类似的追踪系统可以很方便地追踪每一条消息。如果没有这样的追踪系统，这里我提供一个比较简单的方法，来检查是否有消息丢失的情况。

我们可以利用消息队列的有序性来验证是否有消息丢失。原理非常简单，在 Producer 端，我们给每个发出的消息附加一个连续递增的序号，然后在 Consumer 端来检查这个序号的连续性。

如果没有消息丢失，Consumer 收到消息的序号必然是连续递增的，或者说收到的消息，其中的序号必然是上一条消息的序号 +1。如果检测到序号不连续，那就是丢消息了。还可以通过缺失的序号来确定丢失的是哪条消息，方便进一步排查原因。

大多数消息队列的客户端都支持拦截器机制，你可以利用这个拦截器机制，在 Producer 发送消息之前的拦截器中将序号注入到消息中，在 Consumer 收到消息的拦截器中检测序号的连续性，这样实现的好处是消息检测的代码不会侵入到你的业务代码中，待你的系统稳定后，也方便将这部分检测的逻辑关闭或者删除。

如果是在一个分布式系统中实现这个检测方法，有几个问题需要你注意。

首先，像 Kafka 和 RocketMQ 这样的消息队列，它是不保证在 Topic 上的严格顺序的，只能保证分区上的消息是有序的，所以我们在发消息的时候必须要指定分区，并且，在每个分区单独检测消息序号的连续性。

如果你的系统中 Producer 是多实例的，由于并不好协调多个 Producer 之间的发送顺序，所以也需要每个 Producer 分别生成各自的消息序号，并且需要附加上 Producer 的标识，在 Consumer 端按照每个 Producer 分别来检测序号的连续性。

Consumer 实例的数量最好和分区数量一致，做到 Consumer 和分区一一对应，这样会比较方便地在 Consumer 内检测消息序号的连续性。

确保不丢消息

生产阶段：在这个阶段，从消息在 Producer 创建出来，经过网络传输发送到 Broker 端。

当你的代码调用发消息方法时，消息队列的客户端会把消息发送到 Broker，Broker 收到消息后，会给客户端返回一个确认响应，表明消息已经收到了。客户端收到响应后，完成了一次正常消息的发送。有些消息队列在长时间没收到发送确认响应后，会自动重试，如果重试再失败，就会以返回值或者异常的方式告知用户。
存储阶段：在这个阶段，消息在 Broker 端存储，如果是集群，消息会在这个阶段被复制到其他的副本上。

如果对消息的可靠性要求非常高，可以通过配置 Broker 参数来避免因为宕机丢消息。对于单个节点的 Broker，需要配置 Broker 参数，在收到消息后，将消息写入磁盘后再给 Producer 返回确认响应，这样即使发生宕机，由于消息已经被写入磁盘，就不会丢失消息，恢复后还可以继续消费。例如，在 RocketMQ 中，需要将刷盘方式 flushDiskType 配置为 SYNC_FLUSH 同步刷盘。如果是 Broker 是由多个节点组成的集群，需要将 Broker 集群配置成：至少将消息发送到 2 个以上的节点，再给客户端回复发送确认响应。这样当某个 Broker 宕机时，其他的 Broker 可以替代宕机的 Broker，也不会发生消息丢失。
消费阶段: 在这个阶段，Consumer 从 Broker 上拉取消息，经过网络传输发送到 Consumer 上。

消费阶段采用和生产阶段类似的确认机制来保证消息的可靠传递，客户端从 Broker 拉取消息后，执行用户的消费业务逻辑，成功后，才会给 Broker 发送消费确认响应。

消息重复

在 MQTT 协议中，给出了三种传递消息时能够提供的服务质量标准，这三种服务质量从低到高依次是：

At most once: 至多一次。消息在传递时，最多会被送达一次。换一个说法就是，没什么消息可靠性保证，允许丢消息。一般都是一些对消息可靠性要求不太高的监控场景使用，比如每分钟上报一次机房温度数据，可以接受数据少量丢失。
At least once: 至少一次。消息在传递时，至少会被送达一次。也就是说，不允许丢消息，但是允许有少量重复消息出现。
Exactly once：恰好一次。消息在传递时，只会被送达一次，不允许丢失也不允许重复，这个是最高的等级。

现在常用的绝大部分消息队列提供的服务质量都是 At least once，包括 RocketMQ、RabbitMQ 和 Kafka 都是这样。也就是说，消息队列很难保证消息不重复。

用幂等性解决重复消息问题

一个幂等的方法，使用同样的参数，对它进行多次调用和一次调用，对系统产生的影响是一样的。所以，对于幂等的方法，不用担心重复执行会对系统造成任何改变。

消息积压

原因：

生产变快了/消费变慢了
系统中的某个部分出现了性能问题

预防：

优化消费端处理逻辑，增加处理速度
水平扩容，增加消费端的并发数

注：在扩容 Consumer 的实例数量的同时，必须同步扩容主题中的分区数量，确保 Consumer 的实例数和分区数量是相等的。因为对于消费者来说，在每个分区上实际上只能支持单线程消费。

处理：

查看日志是否有消费失败后重复消费，问题消息加入死信队列

死信队列（DLQ - Dead-Letter-Queue）是一种特殊类型的消息队列，用于临时存储软件系统由于错误而无法处理的消息。消息队列是支持分布式系统中的异步通信的软件组件。借助它们，您可以在软件服务之间发送任何数量的消息，且不需要消息接收器始终处于可用。死信队列特别用于存储没有目的地或无法由预期接收器处理的错误的消息。
没有错误的话就打印堆栈看是否卡住了（死锁/资源等待）
水平扩容

常见问题

如何保证消息的严格顺序

由于消息队列只能保证 Partition 中的顺序，有以下方法来保证消息的顺序。

方法一：Partition 配置成 1，生产者和消费者也只能是一个实例，这样才能保证全局严格顺序。
方法二：如果需要保证局部严格顺序，可以这样来实现。在发送端，我们使用账户 ID 作为 Key，采用一致性哈希算法计算出队列编号，指定队列来发送消息。一致性哈希算法可以保证，相同 Key 的消息总是发送到同一个队列上，这样可以保证相同 Key 的消息是严格有序的。如果不考虑队列扩容，也可以用队列数量取模的简单方法来计算队列编号。

参考

docker 镜像源

Wed, 15 Jan 2025 16:00:00 GMT

tee /etc/docker/daemon.json <<EOF
{
  "registry-mirrors": [
        "https://hub.urlsa.us.kg",
        "https://hub.haod.eu.org"
  ]
}
EOF

:::note{title="来源"} https://hub.chxza.eu.org/#/ :::

redis 知识总结

Sun, 12 Jan 2025 16:00:00 GMT

官方介绍： Redis 取自 Remote Dictionary Server.

Redis is an in-memory database that persists on disk. The data model is key-value, but many different kind of values are supported: Strings, Lists, Sets, Sorted Sets, Hashes, Streams, HyperLogLogs, Bitmaps.

源码

查看 Github 源码

源码结构

以 redis 8.0 分析

.codespell 代码拼写检查
.github github 相关
- ISSUE_TEMPLATE issue 模板
- workflows github actions 配置文件
deps dependencies 三方依赖
- fast_float 高性能的浮点数解析库，用于将字符串高效解析为浮点数
- fpconv 浮点数到字符串转换工具，优化性能
- hdr_histogram 高效的数据结构和工具库，用于记录和分析具有极高动态范围的数值分布
- hiredis c 语言客户端
- jemalloc 高性能内存分配器，在性能和内存碎片控制方面表现良好
- linenoise 轻量级的行编辑库，用于实现 Redis CLI 的交互功能
- lua Lua 解释器，支持服务器端脚本功能
modules 模块相关代码，Redis 的一个重要扩展机制，允许开发者以插件的形式扩展 Redis 的功能，而无需修改核心代码
- redisbloom 布隆过滤器
- redisearch 高性能的全文搜索引擎，了解不多，后续有机会尝试 TODO
- redisjson 提供对JSON数据的原生支持
- redistimeseries 开源的时序数据数据库
src 核心目录
- commands 关于 Redis 命令和所有关于它们的元数据，可以通过 COMMAND 命令获取
- modules 实现 Redis module 的示例代码
- acl.c 用户权限管理
- adlist.c/adlist.h 一个通用的双链表实现
- ae.c/ae.h 一个简单的事件驱动编程库，针对不同系统平台，需要使用不同的IO多路复用函数
- ae_epoll.c 基于 ae.c 实现的 epoll（IO多路复用）
- ae_evport.c 基于 ae.c 实现的 eport（IO多路复用）
- ae_kqueue.c 基于 ae.c 实现的 kqueue（IO多路复用）
- ae_select.c 基于 ae.c 实现的 select（IO多路复用）
- anet.c/anet.h 一个更加简单的使用 POSIX 网络标准库（相较于内核提供的原生接口）
- aof.c AOF支持，将客户端执行的命令追加到 AOF 文件中
- asciilogo.h ASCII 码的 logo
- atomicvar.h 原子计数器
- bio.c/bio.h Background I/O service，该机制用于处理 Redis 的后台任务（如AOF-Append Only File、RDB-Redis Database持久化等），从而避免这些操作阻塞主线程，提高系统的响应性和并发性
- bitops.c Bit operations
- blocked.c 支持阻塞操作
- call_reply.c/call_reply.h 负责命令响应
- childinfo.c
- cli_command.c/cli_command.h redis cli 使用
- cli_common.c/cli_common.h cli 通用方法
- cluster.c/cluster.h redis 集群实现
- cluster_legacy.c/cluster_legacy.h redis 集群API实现
- commands.c/commands.def/commands.h 命令相关，def文件由 generate-command-code.py 生成
- config.c/config.h 配置文件获取、配置命令实现
- connection.c/connection.h/connhelpers.h connection layer framework
  
  Redis 从 6.0 版本开始引入了连接层框架（Connection Layer Framework）。这个框架为 Redis 的网络层实现带来了更多的灵活性和扩展性，允许开发者更容易地为 Redis 集成自定义的协议或者进行网络相关的扩展。
- crc16.c/crc16_slottable.h CRC16（Cyclic Redundancy Check 16）校验算法，用于集群槽位计算
- crc64.c/crc64.h CRC64（Cyclic Redundancy Check 64）校验算法，用于 RDB/AOF 文件校验数据完整性
- crcspeed.c/crcspeed.h 加速 CRC 计算
- db.c RDB 数据库实现
- debug.c/debugmacro.h 调试实现
- defrag.c 内存碎片整理
- dict.c/dict.h hash table 实现
- ebuckets.c/ebuckets.h ebuckets用于存储设置了过期时间的项目,支持添加、删除和活动过期的基本API
- endianconv.c/endianconv.h 大小字节序转换
- eval.c 负责 Lua 脚本执行
- evict.c Maxmemory指令处理（LRU驱逐和其他策略）
- expire.c Implementation of EXPIRE (keys with fixed time to live)
- fmacros.h 跨平台的功能宏定义
- fmtargs.h 参数格式化
- function_lua.c/functions.c/functions.h Lua 脚本引擎，实现与 Redis Functions 相关的逻辑
- geo.c/geo.h/geohash.c/geohash.h/geohash_helper.c/geohash_helper.h geo 实现
- hyperloglog.c hyperloglog 实现
- intset.c/intset.h 整数集合数据结构的实现，用于优化整数 SET，以节省内存
- iothread.c IO 多线程实现
- kvstore.c/kvstore.h *基于索引的 kv 存储实现`
- latency.c/latency.h Latency monitor API 及其实现
- lazyfree.c 惰性删除实现
- listpack.c/listpack.h/listpack_malloc.h 一种用于向后遍历字符串列表的序列化格式和实现
- localtime.c 时间时区处理
- logreqres.c 实现了将客户端的请求和响应记录到文件中的接口
- lolwut.c/lolwut.h/lolwut5.c/lolwut6.c lolwut API 及其实现~
- lzf.h/lzfP.h/lzf_c.c/lzf_d.c 对字符串和 RDB 文件进行压缩时使用的 LZF 压缩算法的实现
- memtest.c 测试内存读写正确性和稳定性，检测系统内存是否存在错误
- mkreleasehdr.h 生成与发布版本相关的头文件
- module.c redis module 实现
- monotonic.c/monotonic.h 获取单调时间
- mstr.c/mstr.h 数据类型 string 的实现
- mt19937-64.c/mt19937-64.h Mersenne Twister 64 位版本（MT19937-64）实现（伪随机数生成器）
- multi.c 事务实现
- networking.c 客户端网络操作库, 用于实现命令请求接收、发送命令回复等工作，文件中的函数大多为 write, read,close 等函数的包装，以及各种协议的分析和构建函数
- notify.c 实现通知机制，处理与发布订阅（Pub/Sub）相关的操作以及键的过期和其他通知事件
- object.c 关键文件，负责 Redis 中各种数据类型对象的管理和处理
- pqsort.c 修改后的 NetBSD-libc-qsort 实现，以支持Redis范围的部分排序
- pubsub.c 发布订阅（Pub/Sub）实现
- quicklist.c/quicklist.h A doubly linked list of listpacks
- rand.c/rand.h 伪随机数生成器
- rax.c/rax.h/rax_malloc.h A radix tree implementation
- rdb.c/rdb.h RDB 持久化实现
- redis-benchmark.c 性能测试
- redis-check-aof.c AOF 文件合法性检查
- redis-check-rdb.c RDB 文件合法性检查
- redis-cli.c redis cli
- redis-trib.rb Redis集群管理的Ruby脚本工具，用于创建、检查、修复和删除集群
- redisassert.c/redisassert.h redis 的断言
- redismodule.h redis module 接口
- release.c 记录和生成 Redis 的发行版本信息
- replication.c 异步复制实现
- resp_parser.c/resp_parser.h 处理 RESP (REdis Serialization Protocol) 协议，解析和处理客户端请求的 RESP 消息格式
- rio.c/rio.h 对文件 I/O 函数的包装，在普通 I/O 函数的基础上增加了显式缓存、以及计算校验和等功能
- script.c/script.h Lua 脚本执行相关的核心文件之一
- script_lua.c/script_lua.h Lua 脚本执行相关的核心文件之一，通常与 script.c 文件共同工作来实现 Lua 脚本的加载、执行、缓存管理以及错误处理等功能
- sds.c/sds.h/sdsalloc.h A C dynamic strings library
- sentinel.c redis 哨兵实现
- server.c/server.h 负责服务器的启动、维护和关闭等事项
- setcpuaffinity.c/setproctitle.c 进程环境设置
- sha1.c/sha1.h SHA1 校验和计算
- sha256.c/sha256.h SHA256 校验和计算
- siphash.c siphash 实现
- slowlog.c/slowlog.h slowlog 慢查询 API 及其实现
- socket.c 负责处理 Redis 服务器与客户端之间的网络通信
- solarisfixes.c 针对 Solaris 系统的补丁
- sort.c sort 命令实现
- sparkline.c/sparkline.h ASCII sparkline 图表
- stream.h Redis Stream 结构体与接口定义
- strl.c 字符串处理操作
- syncio.c 同步socket和文件io处理
- syscheck.c/syscheck.h 系统检查
- t_hash.c Redis Hash 数据结构
- t_list.c Redis List 数据结构
- t_set.c Redis Set 数据结构
- t_stream.c Redis Stream 数据结构
- t_string.c Redis String 数据结构
- t_zset.c Redis Zset 数据结构
- testhelp.c 测试辅助宏
- threads_mngr.c/threads_mngr.h 实现与多线程管理相关的功能。Redis 自 6.0 版本开始引入了多线程支持，用于提高某些操作（例如 I/O 操作）的性能
- timeout.c 连接超时、请求超时、以及相关超时机制的管理
- tls.c TLS/SSL（传输层安全协议）相关功能
- tracking.c Client side caching: keys tracking and invalidation
- unix.c unix socket connection implementation
- util.c/util.h 辅助函数
- valgrind.sup Valgrind 抑制文件（suppressions file），用于屏蔽 Valgrind 工具报告的一些特定的、已知的内存使用警告
- version.h 记录 Redis 版本号
- ziplist.c/ziplist.h Ziplist 数据结构的实现
- zipmap.c/zipmap.h Zipmap 数据结构的实现
- zmalloc.c/zmalloc.h total amount of allocated memory aware version of malloc()
- crccombine.c/crccombine.h CRC 计算用
- eventnotifier.c/eventnotifier.h An event notifier based on eventfd or pipe
- iothread.c The threaded io implementation
tests 测试相关
utils 工具脚本等

关系型数据库知识

Fri, 10 Jan 2025 16:00:00 GMT

关系数据库（Relational database），是建立在 关系模型 基础上的数据库，借助于集合代数等数学概念和方法来处理数据库中的数据。现实世界中的各种实体以及实体之间的各种联系均用关系模型来表示。关系模型是由埃德加·科德于1970年首先提出的，并配合“科德十二定律”。现如今虽然对此模型有一些批评意见，但它还是数据存储的传统标准。标准数据查询语言SQL就是一种基于关系数据库的语言，这种语言执行对关系数据库中数据的检索和操作。关系模型由关系数据结构、关系操作集合、关系完整性约束三部分组成。常见的关系型数据库：MySQL、PostgreSQL、Oracle、Microsoft SQL Server、SQLite、MariaDB。

Mysql 架构

连接层

连接层接收请求，分配一个线程来处理连接，并进行身份验证。

客户端连接的建立与处理：当客户端发起连接请求时，MySQL会创建一个专用的线程（以操作系统级别的线程实现）来为该客户端服务。这些服务线程使用线程池里的长连接服务多个用户请求，减少了线程切换的开销。
安全认证：当客户端连接到MySQL服务器时，服务器首先需要验证客户端的身份。
连接资源管理：MySQL支持可配置的最大连接数。当到达最大连接数时，新的连接请求会被拒绝。符合条件的客户端可以设置连接超时时间、客户端闲置关闭时间等参数。同时，可以通过"mysql.user"表配置特定用户对于数据库的操作权限。
线程管理：MySQL会自动创建和管理连接线程，其中包括以线程数作为上限的线程池。线程池的目的是复用连接线程，避免了线程切换和创建的开销。此外，MySQL使用异步I/O机制和协程，尽可能提高了并发和吞吐量。

服务层

服务层是MySQL中的核心组件，负责提供各种数据库操作所需的基本功能。

SQL语法处理

从客户端接收来自连接层的SQL查询请求，并进行初始分析、解析和预处理。
- SQL解析器：服务层的SQL解析器主要进行语法解析。解析器会根据MySQL词法分析器和语法分析器的解析规则，将查询语句解析成一个字符串表示的树状结构，用于存储语法单位（词素）及它们之间的关系。
- SQL预处理：在构建完成解析树后，预处理模块对解析树进行优化和处理。这包括检查权限、完整性约束、函数调用和数据类型等。在预处理阶段，还可能对查询进行改写，例如将"UNION"操作转换为"JOIN"操作，或者将子查询转换为连接操作。
事务管理

确保在执行一系列操作时满足 ACID 原则。
- 事务隔离：定义了事务间数据访问的隔离程度，包括：Read Uncommitted、Read Committed、Repeatable Read(Default)、SERIALIZABLE。
- 锁管理：在事务过程中，可能需要对数据加锁，以确保数据的一致性。MySQL支持的锁类型包括共享锁、排它锁、意向锁、行锁、表锁等。
- Undo日志：通过Undo日志实现了事务回滚操作，当事务执行中途出现异常或用户发出回滚请求时，可以通过Undo日志回滚数据到事务开始前的状态。
- Redo日志：为了保证事务的持久性，在事务执行过程中，修改的数据首先写入到Redo日志中，再更新到磁盘文件上。在系统恢复过程中，可以通过Redo日志进行数据恢复。
缓存管理

MySQL优化器使用缓存来提高查询速度。
- 查询缓存：MySQL会将查询语句和其结果缓存在内存中。当收到一个相同的查询请求时，先检查缓存中是否有匹配的结果。如果有匹配结果，则直接返回，并跳过剩余的处理步骤。如果没有匹配，将继续执行下一个步骤。
- 表缓存：用于存储表的元数据，如表的结构定义。当查询需要表信息时，优先从表缓存中获取，避免磁盘操作。
- 线程缓存：用于复用服务器的连接线程。当一个连接关闭后，它的线程会被放回线程缓存池中，供新的连接使用。线程池意味着减少了创建和销毁线程的开销。
- 缓冲池：主要用于InnoDB存储引擎，缓冲池管理缓存的数据页，包括数据和索引。当需要访问这些页时，可以直接从缓冲池读取，提高访问速度。

引擎层

引擎层负责存储数据和执行SQL语句。通过标准API与服务层交互，实现数据的存储和查询。

InnoDB

默认存储引擎，提供了事务支持、行级锁定、外键约束等功能，主要用于高并发、高可靠性的OLTP场景。
MyISAM

通常用于只读数据表，适用于简单查询和全文索引。其不支持事务、行级锁等功能，适用于OLAP场景。
Memory

支持哈希和B树索引，它将数据存储在内存中，易受到系统断电或宕机等影响，具有较高的写性能但不适用于大规模数据分布。
其他

Archive、NDB Cluster 等其他存储引擎，它们分别适用于存档表、分布式数据库等不同场景。

Mysql 语句执行流程

主要步骤：

语法分析

语法分析器会对SQL语句进行分析，检查其是否符合语法规则。如果SQL语句不符合语法规则，MySQL将会返回一个错误消息。详细的来说又可分为以下几步：

词法分析：主要负责从SQL语句中提取关键字，比如：查询的表，字段名，查询条件等等。词法分析器会将SQL语句分割成一个个的词法单元（token），并为每个token赋予一个类型（type）和值（value）。
语法规则：主要判断SQL语句是否合乎MySQL的语法。语法规则模块会使用yacc工具生成的语法分析器，根据MySQL的语法规则（grammar rule）来检查词法单元是否符合语法要求。
语义分析：主要负责检查SQL语句的语义是否正确，比如：表名和字段名是否存在，数据类型是否匹配，函数是否合法等。语义分析器会根据数据字典（data dictionary）和目录（catalog）来验证SQL语句的有效性。

查询优化

SQL语句在查询优化阶段会经历以下步骤：

查询重写：MySQL会对SQL语句进行一些语法和逻辑上的变换，以便于后续的优化和执行。例如，将子查询转换为连接，将or条件转换为union，将in条件转换为exists等。
查询分解：MySQL会将一条复杂的SQL语句分解为多个简单的子查询，每个子查询可以单独优化和执行。例如，将union查询分解为多个select查询，将关联子查询分解为独立的select查询等。
预处理：MySQL会对SQL语句进行一些基本的检查和处理，例如检查语法错误，解析参数，分配内部资源等。
优化器：根MySQL会根据统计信息和成本模型，为SQL语句选择一个最佳的执行计划。执行计划包括了连接顺序，访问方法，索引选择，排序策略等。

执行SQL语句

执行器会按照执行计划的步骤，逐步执行SQL语句。执行器会根据查询语句，从磁盘读取数据，并将其存储在内存中。然后，执行器会对数据进行排序、分组、聚合等操作，最终生成查询结果。主要步骤如下：

打开表：MySQL会根据执行计划中涉及到的表，打开相应的表文件，并为每个表分配一个表句柄（table handle）。
锁定表：MySQL会根据SQL语句的类型（读或写）和事务的隔离级别，为涉及到的表加上相应的锁（共享锁或排他锁）。锁的作用是保证数据的一致性和并发性。
读取数据：MySQL会根据执行计划中选择的访问方法（全表扫描或索引扫描），从存储引擎中读取数据。
过滤数据：MySQL会根据执行计划中的过滤条件（where，group by，having，order by，limit等），对读取到的数据进行过滤和处理。过滤条件可以减少返回给客户端的数据量，提高查询效率。
返回结果：MySQL会将过滤后的数据返回给客户端，并释放相关的资源（表句柄，锁等）。客户端可以接收到结果集，并进行后续的操作。

可以通过 show profile 查看执行过程。

InnoDB 存储结构

InnoDB 是 MySQL 默认的存储引擎，它提供了事务支持、行级锁、外键约束等功能，适用于高并发、高可靠性的 OLTP 场景。InnoDB的底层结构主要由两部分组成：内存结构和磁盘结构。

内存结构

InnoDB的内存结构主要包括：

缓冲池（Buffer Pool）
更改缓冲区（Change Buffer）
日志缓冲区（Log Buffer）
自适应哈希索引（Adaptive Hash Index）

缓冲池（Buffer Pool）

主要用于缓存表数据和索引数据，加快访问速度。缓冲池是 InnoDB 内存结构中最重要的部分，通常占用宿主机 80% 的内存。缓冲池被分成多个页，每页默认大小为 16KB，每页可以存放多条记录。缓冲池中的页按照 LRU（最近最少使用）算法进行淘汰，同时也被分成两个子链表：New Sublist 和 Old Sublist，分别存放访问频繁和不频繁的页。

New Sublist：占用缓冲池5/8的空间，存放最近被访问过的页。当一个新的页被读入缓冲池时，会被放在New Sublist的最前端。当一个已经存在于缓冲池的页被访问时，如果它在New Sublist中，则不会改变位置；如果它在Old Sublist中，则会被移动到New Sublist的最前端。
Old Sublist：占用缓冲池3/8的空间，存放较久未被访问过的页。当一个已经存在于缓冲池的页被访问时，如果它在Old Sublist中，则会被移动到New Sublist的最前端；如果它在New Sublist中，则不会改变位置。
淘汰策略：当缓冲池已满时，需要淘汰一些页来腾出空间。淘汰策略是从Old Sublist的尾部开始扫描，找到第一个没有被修改过（clean）且没有被锁定（unlocked）的页，并将其淘汰出缓冲池。

更改缓冲区（Change Buffer）

主要用于缓存对非聚集索引的修改操作，减少磁盘I/O。更改缓冲区是缓冲池的一部分，当对非聚集索引进行插入、删除或更新时，不会立即修改磁盘上的索引页，而是先记录在写缓冲中。当缓冲池中的数据页被刷新到磁盘时，会将写缓冲中的修改操作合并到相应的索引页中。

修改缓冲类型：
- Insert Buffer：用于记录对非聚集索引进行插入操作时产生的新条目（entry）。
- Delete Buffer：用用于记录对非聚集索引进行删除操作时需要删除的条目（entry）。
- Update Buffer：用于记录对非聚集索引进行更新操作时需要删除和插入的条目（entry）。
修改缓冲结构：修改缓冲是由多个段（segment）组成的，每个段有一个位图（bitmap），用于标记哪些页有写缓冲条目（entry）。每个段都有一个根页（root page），用于存储修改缓冲条目（entry）。每个根页都有一个B+树结构，用于按照空间ID（space ID）和页号（page number）排序修改缓冲条目（entry）。
写缓冲合并：当缓冲池中的数据页被刷新到磁盘时，会触发修改缓冲的合并操作。合并操作的步骤如下：
- 根据数据页的空间ID（space ID）和页号（page number），在修改缓冲中查找是否有对应的条目（entry）。
- 如果有，就将修改缓冲中的条目（entry）应用到磁盘上的索引页中，完成修改操作。
- 如果没有，就直接刷新数据页到磁盘，不做任何修改操作。
- 将修改缓冲中已经合并的条目（entry）删除，释放空间。

日志缓冲区（Log Buffer）

主要用于缓存 Redo Log，保证事务的持久性。日志缓冲是一个循环使用的内存区域，默认大小为 16MB，可以通过参数innodb_log_buffer_size来调整。当事务提交时，会将日志缓冲中的 Redo Log 刷新到磁盘上的 Redo Log 文件中。日志缓冲中的 Redo Log 也会在以下情况下被刷新：日志缓冲已满、每秒钟一次、每个事务检查点一次。

Redo Log：一种物理日志，记录了对数据页进行的物理修改操作。可以用于恢复事务在崩溃或异常情况下未完成的修改操作，保证数据的完整性和一致性。
Redo Log 格式：由多个固定大小的日志块（log block）组成，每个日志块默认大小为512字节。每个日志块包含以下信息：
- 日志块头（log block header）：占用 12 字节，包含了日志块编号（log block number），校验和（checksum），数据长度（data length）等信息。
- 日志记录（log record）：占用不定长度，包含了对数据页进行的物理修改操作的详细信息。例如，修改了哪个数据页，修改了哪个偏移量，修改前后的值是什么等。
- 日志块尾（log block tail）：占用4字节，包含了日志块编号（log block number）的副本。
Redo Log 文件：磁盘上存储 Redo Log 的文件，通常有两个或多个，以实现循环写入和备份。可以通过参数 innodb_log_files_in_group 来指定数量，通过参数 innodb_log_file_size 来指定大小。Redo Log 文件中有一个特殊的位置叫做检查点（checkpoint），表示到这个位置之前的所有 Redo Log 都已经被应用到数据文件中，可以被覆盖或删除。

自适应哈希索引（Adaptive Hash Index）

主要用于加速等值查询，提高查询效率。自适应哈希索引是InnoDB根据查询频率和模式自动建立的一种哈希索引，可以将某些B+树索引转换为哈希索引，从而减少树的搜索次数。自适应哈希索引是可选的，可以通过参数innodb_adaptive来开启或关闭。

原理：当 InnoDB 发现某个 B+ 树索引被频繁用于等值查询时，就会为该索引建立一个对应的哈希索引。哈希索引是一种基于键值对的索引，可以通过哈希函数快速定位到数据页的位置。哈希索引比 B+ 树索引更简单，更高效，但只能用于等值查询，不能用于范围查询或排序查询。
结构：由多个分区（partition）组成，每个分区有一个哈希表（hash table），用于存储键值对。每个键值对包含以下信息：
- key：由 B+ 树索引的键值和空间ID（space ID）组成。
- value：由数据页的页号（page number）和记录的偏移量（offset）组成。
使用：当 InnoDB 执行一个等值查询时，会先在自适应哈希索引中查找是否有匹配的键值对。如果有，就直接定位到数据页的位置，并获取记录。如果没有，就回退到 B+ 树索引中进行搜索。

磁盘结构

Tablespace 表空间

表空间是InnoDB存储引擎逻辑结构的最高层，所有的数据都存放在表空间中。表空间分类：

系统表空间(System tablespace)：InnoDB 默认表空间，通常存储在ibdata1文件中，也可以分成多个文件。系统表空间包含了 InnoDB的数据字典，双写缓冲区，Change Buffer 和 undo log 等重要信息。系统表空间是共享的，可以存储多个表的数据和索引。系统表空间的大小是不可缩小的，只能通过重建整个数据库来减小。
临时表空间(temporary tablespace)：用于存储临时表的数据和索引，例如在执行复杂查询时产生的中间结果。临时表空间通常存储在ibtmp1文件中，可以配置为自动扩展或固定大小。临时表空间不会持久化到磁盘，每次数据库重启后都会被清空。
常规表空间(general tablespace)：一种共享表空间，可以存储多个表的数据和索引。常规表空间可以在任意位置创建多个文件，文件的扩展方式可以是自动扩展或预分配。常规表空间可以用于跨数据库存储数据，或者将不同类型或大小的表分开存储。
undo 表空间(undo tablespace)：包含 undo log 撤销记录的集合，用于事务回滚和一致性读。undo log 记录了数据页修改前的值，用于恢复未提交或已回滚的事务所做的修改，或者提供给其他事务一个数据修改前的快照。undo 表空间可以有多个文件组成，文件存储在 innodb_undo_directory 指定的目录下，以 undofile 开头命名。
文件每表表空间(file-per-table tablespace)：文件每表表空间是一种独占表空间，含单个 InnoDB 表的数据和索引，并存储在文件系统中自己的数据文件中。文件每表表空间的文件名与表名相同，以.ibd为扩展名，位于数据库目录下。文件每表表空间可以实现单个表的压缩，加密，传输和优化等操作。

Data Dictionary 数据字典

数据字典包含用于跟踪对象，如表、索引、列等元数据的内部系统表。元数据实际上位于 InnoDB 系统表空间中。InnoDB 使用数据字典来管理和访问数据库对象，并检查用户对对象的权限。数据字典在数据库启动时加载到内存中，并在数据库关闭时刷新到磁盘上。

Doublewrite Buffer 双写缓冲区

双写缓冲区位于系统表空间中的存储区域，用于保证数据页在写入磁盘时不会损坏。InnoDB 在 Buffer Pool 中刷新页面时，会将数据页写入Doublewrite Buffer 后才会写入磁盘。如果在写入 OS Cache 或者磁盘 mysql 进程奔溃后， InnoDB 启动崩溃恢复能从 Doublewrite Buffer 找到完整的副本用来恢复。

Redo Log 重做日志

基于磁盘的数据结构，在崩溃恢复期间用于纠正不完整事务写入的数据。MySQL以循环方式写入重做日志文件，默认会产生 ib_logfile0 和 ib_logfile1 两个文件。InnoDB 在提交事务之前刷新事务的 redo log，InnoDB 使用组提交（group commit）技术来提高性能。重做日志记录了数据页的物理修改，而不是逻辑修改，这样可以减少日志的大小和恢复的时间。重做日志可以通过 innodb_log_file_size 和 innodb_log_files_in_group 参数来调整大小和数量。

Change Buffer 修改缓冲区

更改缓冲区是Buffer Pool中的一部分，用于缓存对辅助索引页的修改。当InnoDB需要修改一个辅助索引页时，如果该页在Buffer Pool中，则直接修改；如果该页不在Buffer Pool中，则将修改记录在Change Buffer中，而不是从磁盘读取该页。这样可以减少磁盘I/O操作，提高性能。Change Buffer中的修改会在后台或者检查点时合并到辅助索引页中。Change Buffer的大小可以通过innodb_change_buffer_max_size参数来调整。

InnoDB 磁盘空间管理结构

Tablespace 表空间：InnoDB存储数据和索引的逻辑单位，它由一个或多个文件组成。表空间可以分为系统表空间（System Tablespace），通用表空间（General Tablespace），文件表空间（File-Per-Table Tablespace）和临时表空间（Temporary Tablespace）。
Segment 段：段是表空间中分配和管理空间的单位，它由一个或多个连续或不连续的区（Extent）组成。段可以分为数据段（Data Segment），索引段（Index Segment），回滚段（Rollback Segment），撤销日志段（Undo Log Segment）和系统段（System Segment）。
Extend 区：区是段中分配空间的单位，它由一组连续的页（Page）组成。每个区的大小固定为 1MB，包含 64 个页。
Page 页：页是 InnoDB 在磁盘和内存之间传输数据的基本单位，它由一个固定大小的块（Block）组成。每个页的大小默认为16KB，可以通过参数 innodb_page_size 来调整。页可以分为不同的类型，根据存储的内容而定，比如数据页（Data Page），索引页（Index Page），系统页（System Page），事务系统页（Transaction System Page），撤销日志页（Undo Log Page）等。
Row 行：行是InnoDB存储数据记录的最小单位，它由一个或多个列（Column）组成。每个行的大小不能超过半个页。行可以分为两种格式，根据存储方式而定，比如紧凑格式（Compact Format）和动态格式（Dynamic Format）。

Mysql 的数据结构

数据结构怎么设计由数据的存储方式决定，数据存储方式有两种：内存（小数据量）、磁盘（大数据量），数据量决定基本都是要用磁盘的。磁盘的运转方式：寻址 -> 读盘（io）到内存 -> 寻址 -> 读盘 -> ... -> 寻址 -> 读盘（取到数据），其中读盘是最耗时的（每次读盘会读 16k）。

可以做索引的数据结构：数组、链表、红黑树、B树、B+树。对数据库来说，时间复杂度达到 O(n) 是不能接受的。

数组：增 O(1)、删 O(n)、改 O(1)、查 O(n)

链表：增 O(1)、删 O(n)、改 O(n)、查 O(n)

红黑树：增 O(logn)、删 O(logn)、改 O(logn)、查 O(logn)。红黑树相对来说已经比较好了，但是红黑树高度较高，查找数据时，需要的次数多，即磁盘 io 比较多，会导致效率低。改进点：

常见面试题

in 和 exist 的区别，哪个速度更快？

in 语句只执行一次，确定给定的值是否与子查询或列表中的值相匹配。in 在查询的时候，首先查询子查询的表，然后将内表和外表做一个笛卡尔积，然后按照条件进行筛选。所以相对内表比较小的时候，in 的速度较快。

exist 语句执行n次（外表行数），指定一个子查询，检测行的存在。遍历循环外表，检查外表中的记录有没有和内表的的数据一致的。匹配得上就放入结果集。

in 和 exists 的区别：如果子查询得出的结果集记录较少，主查询中的表较大且又有索引时应该用 in，反之如果外层的主查询记录较少，子查询中的表大，又有索引时使用 exists。其实我们区分 in 和 exists 主要是造成了驱动顺序的改变（这是性能变化的关键），如果是 exists，那么以外层表为驱动表，先被访问，如果是 in，那么先执行子查询，所以我们会以驱动表的快速返回为目标，那么就会考虑到索引及结果集的关系，另外 in 是不对 NULL 进行处理。in 是把外表和内表作 hash 连接，而 exists 是对外表作 loop 循环，每次 loop 循环再对内表进行查询。一直以来认为 exists 比 in 效率高的说法是不准确的。

如果查询语句使用 not in，那么内外表都进行全表扫描，没有用到索引；而 not exists 的子查询依然能用到表上的索引。所以无论那个表大，用 not exists 都比 not in 要快。

参考

地理位置搜索

Tue, 07 Jan 2025 16:00:00 GMT

如何索引一个地理位置？地理位置由经度、维度组成，常用的索引结构都是一维的，从这方面入手，需要将二维的位置信息转化成一维的。

方式一：使用 `geohash`

geohash 是一种将经纬度编码为字符串的算法，它将经纬度映射到一个64位的整数上，从而实现对地理位置的索引。参考：GeoHash核心原理解析

简单来说，先把地图展开，然后按照一定的精度，将地图分成 n 个区域，每个区域的点计算得到的 hash 值是相同的，并且每块区域周围的 8 个区域的 hash 值也是可以计算的。

当我们想要搜索一个点附近有哪些别的点时，只需要计算其 hash，就可以找到其所在的区域。在其区域附近找，需要遍历的就很少。

问题点：每个区域都是矩形，但是距离一个点相同距离的点形成的是圆形，在搜索附近的位置点时会有问题。如：点所在区域的右上角的区域有个点，但不一定这个点比区域右边的右边的点近，说起来有点绕，看图~

不管矩形怎么设计都可能有这样的问题，这就导致在向外扩张搜索区域时，不好判断扩张方式。

查看 rust demo 源码

方式二：使用 R 树

参考：维基百科 R-tree

R树是用来做空间数据存储的树状数据结构。例如给地理位置，矩形和多边形这类多维数据建立索引。R树的核心思想是聚合距离相近的节点并在树结构的上一层将其表示为这些节点的最小外接矩形，这个最小外接矩形就成为上一层的一个节点。R树的“R”代表“Rectangle（矩形）”。因为所有节点都在它们的最小外接矩形中，所以跟某个矩形不相交的查询就一定跟这个矩形中的所有节点都不相交。

rust 开源库：rstar

查看 rust demo 源码

方式三：使用 redis、elasticsearch 等中间件

参考：Redis GEO & 实现原理深度分析

不是重点，不做详细介绍。

尾

Haversine 公式可以用于计算两个地理位置之间的距离。

Rust 去除对 openssl 的依赖

Tue, 31 Dec 2024 16:00:00 GMT

背景

开发时碰到的问题，使用 github actions 进行 CI，构建的可执行文件在目标服务器报错：

./x: error while loading shared libraries: libssl.so.3: cannot open shared object file: No such file or directory

原因是 reqwest 库依赖 openssl。reqwest 需要依赖 OpenSSL 库来处理 TLS/SSL 连接，这是因为 HTTPS（安全的 HTTP）通信协议依赖于 SSL/TLS 加密标准来保证数据传输的安全性。

解决方法

步骤一

Rustls 是一个纯 Rust 编写的现代 TLS 库，旨在成为一个内存安全的 OpenSSL 替代品；它使用 ring 进行加密，使用 webpki 进行证书验证。 Rustls 旨在提供良好的加密安全级别，无需配置即可实现该安全性，并且不提供不安全的功能或过时的加密技术。在 Cargo.toml 中，给 reqwest 库设置 features = ["rustls-tls"] 并禁用了默认特性（default-features = false）。

[dependencies]
reqwest = { version = "0.12.9", features = ["json", "rustls-tls"], default-features = false }

修改之后重新执行 CI，发现还是相同的报错，检查之后发现 lettre 依赖 native-tls，而 native-tls 在 Linux 和其他 Unix 系统也依赖 openssl，同时也修改。

[dependencies]
lettre = { version = "0.11.11", default-features = false, features = ["builder", "smtp-transport", "rustls-tls"] }

注：可以使用 cargo tree 查看依赖树。

步骤二

上面的修改已经解决了对 openssl 的依赖问题，但是修改后发现可执行文件还是报错：

./x: /lib64/libm.so.6: version `GLIBC_2.38' not found (required by ./x)
./x: /lib64/libm.so.6: version `GLIBC_2.27' not found (required by ./x)
./x: /lib64/libm.so.6: version `GLIBC_2.29' not found (required by ./x)
./x: /lib64/libm.so.6: version `GLIBC_2.35' not found (required by ./x)
./x: /lib64/libc.so.6: version `GLIBC_2.32' not found (required by ./x)
./x: /lib64/libc.so.6: version `GLIBC_2.25' not found (required by ./x)
./x: /lib64/libc.so.6: version `GLIBC_2.18' not found (required by ./x)
./x: /lib64/libc.so.6: version `GLIBC_2.33' not found (required by ./x)
./x: /lib64/libc.so.6: version `GLIBC_2.28' not found (required by ./x)
./x: /lib64/libc.so.6: version `GLIBC_2.34' not found (required by ./x)

这个错误表明，在运行编译后的二进制文件时，所运行的系统上的 GNU C Library (glibc) 的版本低于编译该二进制文件时所依赖的版本（2.38）。要解决这个问题，第一种办法是降低编译时的 glibc 版本或者升级运行时的 glibc 版本。第二种办法是让程序不要动态链接到系统库，可以通过使用 musl 工具链静态编译。修改编译脚本。

rustup target add x86_64-unknown-linux-musl
cargo build --target x86_64-unknown-linux-musl --release

这会生成一个与 glibc 无关的静态链接二进制文件，可以在任何 Linux 系统上运行。编译报错

ring@0.17.8: Compiler family detection failed due to error: ToolNotFound: Failed to find tool. Is musl-gcc installed?

这个错误表明，在尝试用 musl 工具链编译 ring 时，musl-gcc 工具未找到。ring 在某些环境中需要 musl-gcc 来生成与 musl 静态链接的代码。安装工具即可 apt-get install musl-tools。

修改后成功运行。

微信机器人

Sun, 08 Dec 2024 16:00:00 GMT

技术选择

总的来说有三种选择：

第一种是通过 PC Hook 的方式注入 dll 注入到微信中
第二种是通过操作你的电脑来处理
另一种是使用企业微信，通过网页 API 的方式已不支持

PC Hook

之前使用过的方式，优点是比较难被检测，缺点是 dll 与微信版本号必须一致以及需要 Windows 电脑。当前可用的项目：wechatferry 腾讯一直增加各种手段进行检测，以前使用的微信被检测到之后就被制裁了 T_T 参考：以前写的项目 firefly

操作电脑

操作电脑的方式要占用电脑，不优雅也不方便，源码写起来也麻烦，不考虑。

企业微信

参考：

企业微信开发者中心
企业微信管理页面通过自建应用，管理微信客服的方式，可以在外部群中引入微信客服，在后端编写代码处理用户问题。无法主动给用户发消息，用户提问后，最多发送五条回答。微信客服工作台没有办法直接接管企业微信用户。机器人则只能在内部群使用，也不方便。无法直接使用，需要企业微信账号。

Email Assistant - X

Mon, 02 Dec 2024 16:00:00 GMT

自动部署

name: Rust CI and Deploy

on:
  push:
    branches:
      - main  # 监听 main 分支的推送

jobs:
  build-and-deploy:
    environment: 
      name: 42tr
    runs-on: ubuntu-latest

    steps:
    - name: Checkout repository
      uses: actions/checkout@v2

    - name: Set up Rust
      uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
        override: true

    - name: Build project
      run: cargo build --release
    
    - name: copy file via ssh password
      uses: appleboy/scp-action@master
      with:
        host: ${{secrets.SERVER_HOST}}
        username: ${{ secrets.SERVER_USER }}
        password: ${{ secrets.SERVER_PASSWORD }}
        port: 22
        source: "target/release/x"
        target: "/home/x/"
      
    - name: copy file via ssh password
      uses: appleboy/scp-action@master
      with:
        host: ${{secrets.SERVER_HOST}}
        username: ${{ secrets.SERVER_USER }}
        password: ${{ secrets.SERVER_PASSWORD }}
        port: 22
        source: "Dockerfile"
        target: "/home/x/"

    - name: Deploy to CentOS server
      uses: appleboy/ssh-action@master
      with:
        host: ${{ secrets.SERVER_HOST }}
        username: ${{ secrets.SERVER_USER }}
        password: ${{ secrets.SERVER_PASSWORD }}
        port: 22
        script: |
          cd /home/x/
          mv target/release/x ./
          rm -rf target
          docker stop kex >> /dev/null 2>&1
          docker rm kex >> /dev/null 2>&1
          docker rmi x >> /dev/null 2>&1
          docker build -t x .
          docker run -d --restart unless-stopped -p 8080:8080 -e EMAIL_AUTHORIZE_CODE=${{ secrets.EMAIL_AUTHORIZE_CODE }} --name=kex x ./x

遇到的问题

Q: ./x: error while loading shared libraries: libssl.so.3: cannot open shared object file: No such file or directory

A: install openssl from https://openssl-library.org/source/ download ./config make make install

Q: error while carry out ./config

Can't locate IPC/Cmd.pm in @INC (you may need to install the IPC::Cmd module) (@INC contains: /home/openssl-3.4.0/util/perl /usr/local/lib64/perl5 /usr/local/share/perl5 /usr/lib64/perl5/vendor_perl /usr/share/perl5/vendor_perl /usr/lib64/perl5 /usr/share/perl5 /home/openssl-3.4.0/external/perl/Text-Template-1.56/lib) at /home/openssl-3.4.0/util/perl/OpenSSL/config.pm line 19. BEGIN failed--compilation aborted at /home/openssl-3.4.0/util/perl/OpenSSL/config.pm line 19. Compilation failed in require at /home/openssl-3.4.0/Configure line 23. BEGIN failed--compilation aborted at /home/openssl-3.4.0/Configure line 23.

A: yum install perl-IPC-Cmd

Q: 执行报错

Configuring OpenSSL version 3.4.0 for target linux-x86_64 Using os-specific seed configuration Created configdata.pm Running configdata.pm Can't locate Getopt/Long.pm in @INC (you may need to install the Getopt::Long module) (@INC contains: /usr/local/lib64/perl5 /usr/local/share/perl5 /usr/lib64/perl5/vendor_perl /usr/share/perl5/vendor_perl /usr/lib64/perl5 /usr/share/perl5) at configdata.pm line 34986. BEGIN failed--compilation aborted at configdata.pm line 34986.

A: yum install perl-Getopt-Long

Q: error while carry out ./make install

Can't locate Pod/Html.pm in @INC (you may need to install the Pod::Html module)

A: yum install perl-Pod-Html

Q: error while carry out ./make

Can't locate Data/Dumper.pm in @INC (@INC contains: Configurations . /home/openssl-3.4.0/util/../Configurations /home/openssl-3.4.0/util/perl /home/openssl-3.4.0/Configurations /usr/local/lib64/perl5 /usr/local/share/perl5 /usr/lib64/perl5/vendor_perl /usr/share/perl5/vendor_perl /usr/lib64/perl5 /usr/share/perl5 /home/openssl-3.4.0/external/perl/Text-Template-1.56/lib /home/openssl-3.4.0/util/../external/perl/Text-Template-1.56/lib) at exporters/cmake/OpenSSLConfig.cmake.in line 5.

A: 安装依赖

yum install perl-Data-Dumper
ln -sf /home/openssl-3.4.0/libssl.so.3 /usr/lib64/libssl.so.3
ln -sf /home/openssl-3.4.0/libcrypto.so.3 /usr/lib64/libcrypto.so.3

改用 docker，Dockerfile 如下

FROM ubuntu
RUN apt-get update && apt-get install -y ca-certificates
COPY ./x /tmp/x
WORKDIR /tmp/
RUN chmod +x x

旧版本的 ubuntu 也会有 openssl 问题，由于 docker 现在使用不方便，服务器改用 ubuntu 新版本。对依赖 openssl 的库，使用 rustls-tls 特性，可以去除对 openssl 的依赖。但是 native-tls 也会依赖 openssl，使用 cargo tree 查看项目中是否仍有 openssl 或 native-tls 相关的依赖。

制作简历

Tue, 29 Oct 2024 16:00:00 GMT

制作简历的方式：word 文档、markdown、latex、html。

word 文档

word 文档是最常用的方式，但是需要手动调整格式，比较麻烦。
markdown

markdown 是一种轻量级的文本格式，可以借助工具生成 html。markdown 的语法比较简单，可以参考 markdown 语法。
latex

latex 是一种公式编辑工具，可以借助工具生成 html。latex 的语法比较复杂，可以参考 latex 语法。latex 可以使用 overleaf 进行编辑，里面有很多模板可以使用。但是想要自己定制的话还是要熟悉 latex 语法，很不方便。
html

作为 web 全栈，html 自然不用多说，写好后通过网页打印成 pdf 即可。注意去掉页眉和页脚，显示背景图像。源码参考

生成打卡图片

Mon, 30 Sep 2024 16:00:00 GMT

大体效果如下~

go 版本

第一版

package main

import (
        _ "embed"
        "encoding/json"
        "fmt"
        "image"
        "image/color"
        "image/draw"
        "image/jpeg"
        "image/png"
        "io"
        "log"
        "math"
        "net/http"
        "os"
        "path/filepath"
        "strings"
        "test0405/img"
        "time"

        "golang.org/x/image/colornames"
        "golang.org/x/image/font"
        "golang.org/x/image/font/opentype"
        "golang.org/x/image/font/sfnt"
        "golang.org/x/image/math/fixed"
)

//go:embed Pacifico-Regular.ttf
var PACIFICO_TTF_SOURCE string
var PACIFICO_TTF *sfnt.Font

//go:embed fontawesome-webfont.ttf
var AWESOME_REGULAR_TTF_SOURCE string
var AWESOME_REGULAR_TTF *sfnt.Font

//go:embed KleeOne-SemiBold.ttf
var KLEE_ONE_TTF_SOURCE string
var KLEE_ONE_TTF *sfnt.Font

func init() {
        var err error
        PACIFICO_TTF, err = opentype.Parse([]byte(PACIFICO_TTF_SOURCE))
        if err != nil {
                panic(err)
        }
        AWESOME_REGULAR_TTF, err = opentype.Parse([]byte(AWESOME_REGULAR_TTF_SOURCE))
        if err != nil {
                panic(err)
        }
        KLEE_ONE_TTF, err = opentype.Parse([]byte(KLEE_ONE_TTF_SOURCE))
        if err != nil {
                panic(err)
        }
}

func readImg(path string) image.Image {
        // 打开背景图片
        file, err := os.Open(path)
        if err != nil {
                panic(err)
        }
        defer file.Close()
        var img image.Image
        if filepath.Ext(path) == "png" {
                img, err = png.Decode(file)
        } else {
                img, _, err = image.Decode(file)
        }

        if err != nil {
                panic(err)
        }
        return img
}

func min(a, b int) int {
        if a < b {
                return a
        }
        return b
}

func main() {
        // img.Cut("wallhaven-zyrq1v.jpg")
        // img.Resize("wallhaven-6dz777.png")
        img.Resize("wallhaven-725qz3.jpeg")
        bgImg := readImg("bg.png")

        width, height := bgImg.Bounds().Max.X, bgImg.Bounds().Max.Y
        fmt.Println(width, height)

        // 创建一个新的 RGBA 图片，大小与背景图片相同
        rgba := image.NewRGBA(bgImg.Bounds())

        // 将背景图片绘制到 RGBA 图片上
        draw.Draw(rgba, bgImg.Bounds(), bgImg, image.Point{}, draw.Src)

        // 绘制黑色半透明遮罩
        black := color.RGBA{0, 0, 0, 97} // 0.3 * 255 = 76，这里的 76 为黑色透明度
        draw.Draw(rgba, rgba.Bounds(), &image.Uniform{black}, image.Point{}, draw.Over)

        drawTitle(rgba, width, height)
        drawCalendar(rgba, width, height)
        drawWork(rgba, width, height, []string{"English words: 44", "Blog", "2007. Find Original Array From..."})

        drawHealthData(rgba, width, height)
        if err := drawEnglish(rgba, width, height); err != nil {
                panic(err)
        }
        // 将生成的图片保存到文件
        outputFile, err := os.Create("output.jpg")
        if err != nil {
                panic(err)
        }
        defer outputFile.Close()
        jpeg.Encode(outputFile, rgba, nil)
}

func getFace(f *opentype.Font, size float64) font.Face {
        face, err := opentype.NewFace(f, &opentype.FaceOptions{
                Size:    size,
                DPI:     size * 3,
                Hinting: font.HintingFull,
        })
        if err != nil {
                panic(err)
        }
        return face
}

func drawTitle(img *image.RGBA, width, height int) {
        size := float64(min(width, height)) * 0.06
        face := getFace(PACIFICO_TTF, size)
        x, y := float64(width)*0.05, float64(height)*0.25
        d := &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: face,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        d.DrawString("K'")
}

func drawCalendar(img *image.RGBA, width, height int) {
        m := min(width, height)

        size := float64(m) * 0.15 / 6.5
        // 绘制日历
        face := getFace(AWESOME_REGULAR_TTF, size)
        x, y := int(float64(width)*0.05), int(float64(height)*0.7)
        d := &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: face,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        d.DrawString("\uf073")
        // 绘制时间
        face = getFace(KLEE_ONE_TTF, size)
        x = int(float64(width) * 0.1)
        d = &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: face,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        time := time.Now().Format("January 02, 2006")
        d.DrawString(time)
}

func drawLeetcode(img *image.RGBA, width, height int, works []string) {
        data := `{"query":"\n    query questionOfToday {\n  todayRecord {\n    date\n    userStatus\n    question {\n      questionId\n      frontendQuestionId: questionFrontendId\n      difficulty\n      title\n      titleCn: translatedTitle\n      titleSlug\n      paidOnly: isPaidOnly\n      freqBar\n      isFavor\n      acRate\n      status\n      solutionNum\n      hasVideoSolution\n      topicTags {\n        name\n        nameTranslated: translatedName\n        id\n      }\n      extra {\n        topCompanyTags {\n          imgUrl\n          slug\n          numSubscribed\n        }\n      }\n    }\n    lastSubmission {\n      id\n    }\n  }\n}\n    ","variables":{},"operationName":"questionOfToday"}`
        resp, err := http.Post("https://leetcode.cn/graphql/", "application/json", strings.NewReader(data))
        if err != nil {
                log.Fatalln(err.Error())
                return
        }
        defer resp.Body.Close()
        body, err := io.ReadAll(resp.Body)
        if err != nil {
                log.Fatalln(err.Error())
                return
        }
        type Question struct {
                QuestionId string `json:"questionId"`
                Difficulty string `json:"difficulty"`
                Title      string `json:"title"`
        }
        type Record struct {
                Question Question `json:"question"`
        }
        type Data struct {
                TodayRecord []Record `json:"todayRecord"`
        }
        type Rsp struct {
                Data Data `json:"data"`
        }
        var rsp Rsp
        if err = json.Unmarshal(body, &rsp); err != nil {
                log.Fatalln(err.Error())
                return
        }
        records := rsp.Data.TodayRecord
        if len(records) == 0 {
                log.Fatalln("no record")
                return
        }
        // question := rsp.Data.TodayRecord[0].Question
        // return question.QuestionId + ". " + question.Title, nil
        return
}

func drawWork(img *image.RGBA, width, height int, works []string) {
        m := min(width, height)
        size := float64(m) * 0.15 / 6.5
        // 绘制日历
        face := getFace(KLEE_ONE_TTF, size)
        for i, work := range works {
                x, y := int(float64(width)*0.05), int(float64(height)*(0.75+0.05*float64(i)))
                col := image.NewUniform(color.White)
                if strings.Contains(work, ".") {
                        col = image.NewUniform(colornames.Yellow)
                }
                d := &font.Drawer{
                        Dst:  img,
                        Src:  col,
                        Face: face,
                        Dot: fixed.Point26_6{
                                X: fixed.Int26_6(x * 64),
                                Y: fixed.Int26_6(y * 64),
                        },
                }
                d.DrawString(work)
        }
}

func drawHealthData(img *image.RGBA, width, height int) {
        kcal, exercise, stand := 737, 95, 10
        kcalTotal, exerciseTotal, standTotal := 520, 30, 8

        x := int(float64(width) * 0.73)
        size := float64(min(width, height)) * 0.15 / 8
        face := getFace(KLEE_ONE_TTF, size)
        y := int(float64(height) * 0.78)
        d := &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: face,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        d.DrawString(fmt.Sprintf("%3d/%3d KCAL", kcal, kcalTotal))
        y = int(float64(height)*0.78) + int(size*1.5)
        d = &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: face,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        d.DrawString(fmt.Sprintf("%3d/%2d   MIN", exercise, exerciseTotal))
        y = int(float64(height)*0.78) + int(size*3)
        d = &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: face,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        d.DrawString(fmt.Sprintf("  %2d/%d    HRS", stand, standTotal))

        x, y = int(float64(width)*0.8), int(float64(height)*0.8)
        m := float64(min(width, height))

        drawRing(img, x, y, int(m*0.17), int(m*0.025), color.RGBA{255, 0, 0, 255}, color.RGBA{255, 251, 251, 255}, float64(kcal)/float64(kcalTotal))
        drawRing(img, x, y, int(m*0.14), int(m*0.025), color.RGBA{0, 128, 0, 255}, color.RGBA{0, 255, 127, 255}, float64(exercise)/float64(exerciseTotal))
        drawRing(img, x, y, int(m*0.11), int(m*0.025), color.RGBA{30, 144, 250, 255}, color.RGBA{135, 206, 255, 255}, float64(stand)/float64(standTotal))

}

// 绘制圆环
// img 图纸
// x, y 中心点
// r 半径
// startColor, endColor 开始、结束颜色
// percent 圆环百分比
func drawRing(img *image.RGBA, x, y, r, thickness int, startColor, endColor color.RGBA, percent float64) {
        abs := func(num float64) float64 {
                if num < 0 {
                        return -num
                }
                return num
        }
        angle := func(x, y int) float64 {
                angle := math.Atan2(float64(x), float64(-y))
                if angle < 0 {
                        angle += 2 * math.Pi
                }
                return angle
        }
        for i := -r; i <= r; i++ {
                for j := -r; j <= r; j++ {
                        // 不处于圆环不绘制
                        if i*i+j*j > r*r || math.Sqrt(float64(i*i+j*j)) < float64(r-thickness) {
                                continue
                        }
                        // 小于半径根据角度计算颜色
                        if angle(i, j) > 2*math.Pi*percent {
                                continue
                        }
                        p := abs(math.Atan(float64(j)/float64(i))) * 2 / math.Pi
                        color := color.RGBA{
                                startColor.R + uint8(float64(endColor.R-startColor.R)*p),
                                startColor.G + uint8(float64(endColor.G-startColor.G)*p),
                                startColor.B + uint8(float64(endColor.B-startColor.B)*p),
                                255,
                        }
                        img.Set(x+i, y+j, color)
                }
        }
}

func drawEnglish(img *image.RGBA, width, height int) error {
        url := "http://open.iciba.com/dsapi"
        resp, err := http.Get(url)
        if err != nil {
                return err
        }
        defer resp.Body.Close()

        body, err := io.ReadAll(resp.Body)
        if err != nil {
                return err
        }
        type Rsp struct {
                Content string `json:"content"`
        }
        var rsp Rsp
        err = json.Unmarshal(body, &rsp)
        if err != nil {
                return err
        }
        content := rsp.Content

        size := float64(min(width, height)) * 0.15 / 6.5
        face := getFace(KLEE_ONE_TTF, size)
        nContents := []string{}

        // contents := strings.Split(content, ".")
        contents := []string{content[:len(content)-1]}
        for _, content := range contents {
                if content == "" {
                        continue
                }
                content += "."
                words := strings.Split(content, " ")
                temp := ""
                for _, word := range words {
                        if word == "" {
                                continue
                        }
                        if len(temp)+len(word) > 40 {
                                nContents = append(nContents, temp)
                                temp = ""
                        }
                        if len(temp) > 0 {
                                temp += " "
                        }
                        temp += word
                }
                if len(temp) > 0 {
                        nContents = append(nContents, temp)
                }
        }
        contents = nContents
        for i, c := range contents {
                if c == "" {
                        continue
                }
                x, y := int(float64(width)*0.05), int(float64(height)*0.9)+int(size*float64(i))
                d := &font.Drawer{
                        Dst:  img,
                        Src:  image.NewUniform(color.White),
                        Face: face,
                        Dot: fixed.Point26_6{
                                X: fixed.Int26_6(x * 64),
                                Y: fixed.Int26_6(y * 64),
                        },
                }
                d.DrawString(c)
        }
        // d.DrawString(content)
        return nil
}

第二版

package main

import (
        _ "embed"
        "encoding/json"
        "fmt"
        "image"
        "image/color"
        "image/draw"
        "image/jpeg"
        "image/png"
        "io"
        "math"
        "net/http"
        "os"
        "path/filepath"
        "strings"
        "test0405/img"
        "time"

        "golang.org/x/image/colornames"
        "golang.org/x/image/font"
        "golang.org/x/image/font/opentype"
        "golang.org/x/image/font/sfnt"
        "golang.org/x/image/math/fixed"
)

//go:embed Pacifico-Regular.ttf
var PACIFICO_TTF_SOURCE string
var PACIFICO_TTF *sfnt.Font

//go:embed fontawesome-webfont.ttf
var AWESOME_REGULAR_TTF_SOURCE string
var AWESOME_REGULAR_TTF *sfnt.Font

//go:embed fa-solid-900.ttf
var AWESOME_SOLID_TTF_SOURCE string
var AWESOME_SOLID_TTF *sfnt.Font

//go:embed KleeOne-SemiBold.ttf
var KLEE_ONE_TTF_SOURCE string
var KLEE_ONE_TTF *sfnt.Font

//go:embed TaiWanQuanZiKu.ttf
var TAIWAN_QUANZI_KU_TTF_SOURCE string
var TAIWAN_QUANZI_KU_TTF *sfnt.Font

//go:embed RampartOne-Regular.ttf
var RAMPTONE_TTF_SOURCE string
var RAMPTONE_TTF *sfnt.Font

func init() {
        var err error
        PACIFICO_TTF, err = opentype.Parse([]byte(PACIFICO_TTF_SOURCE))
        if err != nil {
                panic(err)
        }
        AWESOME_REGULAR_TTF, err = opentype.Parse([]byte(AWESOME_REGULAR_TTF_SOURCE))
        if err != nil {
                panic(err)
        }
        AWESOME_SOLID_TTF, err = opentype.Parse([]byte(AWESOME_SOLID_TTF_SOURCE))
        if err != nil {
                panic(err)
        }
        KLEE_ONE_TTF, err = opentype.Parse([]byte(KLEE_ONE_TTF_SOURCE))
        if err != nil {
                panic(err)
        }
        TAIWAN_QUANZI_KU_TTF, err = opentype.Parse([]byte(TAIWAN_QUANZI_KU_TTF_SOURCE))
        if err != nil {
                panic(err)
        }
        RAMPTONE_TTF, err = opentype.Parse([]byte(RAMPTONE_TTF_SOURCE))
        if err != nil {
                panic(err)
        }
}

func readImg(path string) image.Image {
        // 打开背景图片
        file, err := os.Open(path)
        if err != nil {
                panic(err)
        }
        defer file.Close()
        var img image.Image
        if filepath.Ext(path) == "png" {
                img, err = png.Decode(file)
        } else {
                img, _, err = image.Decode(file)
        }

        if err != nil {
                panic(err)
        }
        return img
}

func min(a, b int) int {
        if a < b {
                return a
        }
        return b
}

func main() {
        // img.Cut("wallhaven-zyrq1v.jpg")
        // img.Resize("wallhaven-6dz777.png")
        // img.Resize("wallhaven-2kpe5y.jpg")
        img.Resize("wallhaven-k7y68m.png")
        bgImg := readImg("bg.png")

        width, height := bgImg.Bounds().Max.X, bgImg.Bounds().Max.Y
        fmt.Println(width, height)

        // 创建一个新的 RGBA 图片，大小与背景图片相同
        rgba := image.NewRGBA(bgImg.Bounds())

        // 将背景图片绘制到 RGBA 图片上
        draw.Draw(rgba, bgImg.Bounds(), bgImg, image.Point{}, draw.Src)

        // 绘制黑色半透明遮罩
        black := color.RGBA{0, 0, 0, 97} // 0.3 * 255 = 76，这里的 76 为黑色透明度
        draw.Draw(rgba, rgba.Bounds(), &image.Uniform{black}, image.Point{}, draw.Over)

        drawRectangle(width, height, 0.02, 0.43, 0.96, 0.4, rgba)  // 新闻框
        drawRectangle(width, height, 0.52, 0.2, 0.46, 0.185, rgba) // LeetCode日历框

        // 绘制标题、天气、LeetCode日历、日历、工作内容
        drawTitle(rgba, width, height)
        drawWeather(rgba, width, height)
        drawLeetCodeCalendar(rgba, width, height)
        drawCalendar(rgba, width, height)
        drawWork(rgba, width, height, []string{`1. OpenAI开放语言模型最快下周亮相`, `2. 英伟达市值达4万亿美元，创历史新高`, `3. 微软35%新产品代码由AI编写`, `4. Meta收购雷朋母公司股权，加码AI智能眼镜`, `5. 苹果计划2025年推出升级版Vision Pro`, `6. 美国设立AI教育学院，培训40万教师`, `7. OpenAI等资助AI教师培训，总额2300万美元`})

        // 将生成的图片保存到文件
        outputFile, err := os.Create("output.jpg")
        if err != nil {
                panic(err)
        }
        defer outputFile.Close()
        jpeg.Encode(outputFile, rgba, nil)
}

func drawRectangle(width, height int, startPercentX, startPercentY, widthPercent, heightPercent float64, rgba *image.RGBA) {
        // 绘制一个圆角的灰色透明矩形，使用 draw.Draw 绘制，透明度为 0.7
        rectX := int(float64(width) * startPercentX)
        rectY := int(float64(height) * startPercentY)
        rectWidth := int(float64(width) * widthPercent)
        rectHeight := int(float64(height) * heightPercent)
        radius := int(float64(min(rectWidth, rectHeight)) * 0.1) // 圆角半径

        // 创建一个灰色半透明颜色
        grayColor := color.RGBA{0, 0, 0, 100} // 0.7 * 255 = 178.5 约等于 179，这里的 179 为灰色透明度

        // 创建圆角矩形遮罩
        mask := image.NewAlpha(image.Rect(0, 0, width, height))

        // 绘制圆角矩形到遮罩上
        for y := 0; y < height; y++ {
                for x := 0; x < width; x++ {
                        // 检查点是否在矩形范围内
                        if x >= rectX && x < rectX+rectWidth && y >= rectY && y < rectY+rectHeight {
                                // 检查是否在四个角的圆角区域内
                                inRect := true

                                // 左上角
                                if x < rectX+radius && y < rectY+radius {
                                        dx := float64(rectX + radius - x)
                                        dy := float64(rectY + radius - y)
                                        inRect = (dx*dx + dy*dy) <= float64(radius*radius)
                                }
                                // 右上角
                                if x >= rectX+rectWidth-radius && y < rectY+radius {
                                        dx := float64(x - (rectX + rectWidth - radius - 1))
                                        dy := float64(rectY + radius - y)
                                        inRect = (dx*dx + dy*dy) <= float64(radius*radius)
                                }
                                // 左下角
                                if x < rectX+radius && y >= rectY+rectHeight-radius {
                                        dx := float64(rectX + radius - x)
                                        dy := float64(y - (rectY + rectHeight - radius - 1))
                                        inRect = (dx*dx + dy*dy) <= float64(radius*radius)
                                }
                                // 右下角
                                if x >= rectX+rectWidth-radius && y >= rectY+rectHeight-radius {
                                        dx := float64(x - (rectX + rectWidth - radius - 1))
                                        dy := float64(y - (rectY + rectHeight - radius - 1))
                                        inRect = (dx*dx + dy*dy) <= float64(radius*radius)
                                }

                                if inRect {
                                        mask.SetAlpha(x, y, color.Alpha{255})
                                }
                        }
                }
        }

        // 使用遮罩绘制灰色半透明矩形
        draw.DrawMask(rgba, rgba.Bounds(), &image.Uniform{grayColor}, image.Point{}, mask, image.Point{}, draw.Over)
}

func getFace(f *opentype.Font, size float64) font.Face {
        face, err := opentype.NewFace(f, &opentype.FaceOptions{
                Size:    size,
                DPI:     size * 3,
                Hinting: font.HintingFull,
        })
        if err != nil {
                panic(err)
        }
        return face
}

func drawTitle(img *image.RGBA, width, height int) {
        size := float64(min(width, height)) * 0.04
        face := getFace(PACIFICO_TTF, size)
        x, y := float64(width)*0.77, float64(height)*0.9
        d := &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: face,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        d.DrawString("42tr")
}

func drawLeetCodeTitle(img *image.RGBA, width, height int) {
        size := float64(min(width, height)) * 0.03
        face := getFace(RAMPTONE_TTF, size)
        x, y := float64(width)*0.58, float64(height)*0.24
        d := &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: face,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        d.DrawString("LeetCode")
}

func drawLeetCodeCalendar(img *image.RGBA, width, height int) {
        drawLeetCodeTitle(img, width, height)
        m := min(width, height)
        size := float64(m) * 0.12 / 6.5
        face := getFace(AWESOME_SOLID_TTF, size)
        x, y := float64(width)*0.58, float64(height)*0.27

        cal := [32]int{}
        cal[0] = -1
        cal[9] = 1
        cal[10] = 1
        cal[11] = 1
        cal[12] = 2
        cal[13] = 1
        cal[14] = 1
        doneColor := image.NewUniform(colornames.Greenyellow)
        for i, done := range cal {
                if done == -1 {
                        continue
                }
                color := image.NewUniform(color.White)
                if done == 1 {
                        color = doneColor
                } else if done == 2 {
                        color = image.NewUniform(colornames.Red)
                }
                xx := x + float64(i%7)*float64(m)*0.33/6.5
                yy := y + float64(i/7)*float64(m)*0.33/6.5
                d := &font.Drawer{
                        Dst:  img,
                        Src:  color,
                        Face: face,
                        Dot: fixed.Point26_6{
                                X: fixed.Int26_6(xx * 64),
                                Y: fixed.Int26_6(yy * 64),
                        },
                }
                d.DrawString("\uf111")
        }
}

func drawWeather(img *image.RGBA, width, height int) {
        m := min(width, height)

        size := float64(m) * 0.2 / 6.5
        face := getFace(AWESOME_SOLID_TTF, size)

        bigSize := float64(m) * 0.3 / 6.5
        bigFace := getFace(AWESOME_SOLID_TTF, bigSize)
        x, y := float64(width)*0.06, float64(height)*0.18
        d := &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: bigFace,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        d.DrawString("\uf185")
        x = float64(width) * 0.15
        for i := range []int{0, 1, 2} {
                x += float64(width) * 0.06
                d = &font.Drawer{
                        Dst:  img,
                        Src:  image.NewUniform(color.White),
                        Face: face,
                        Dot: fixed.Point26_6{
                                X: fixed.Int26_6(x * 64),
                                Y: fixed.Int26_6(y * 64),
                        },
                }
                if i == 0 {
                        d.DrawString("\uf185")
                } else {
                        d.DrawString("\uf73d")
                }

        }
}

func drawCalendar(img *image.RGBA, width, height int) {
        m := min(width, height)

        size := float64(m) * 0.25 / 6.5
        // 绘制日历
        face := getFace(AWESOME_REGULAR_TTF, size)
        x, y := int(float64(width)*0.05), int(float64(height)*0.1)
        d := &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: face,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        d.DrawString("\uf073")
        // 绘制时间
        face = getFace(KLEE_ONE_TTF, size)
        x = int(float64(width) * 0.15)
        d = &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: face,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        time := time.Now().Format("January 02, 2006")
        d.DrawString(time)
}

func drawWork(img *image.RGBA, width, height int, works []string) {
        m := min(width, height)
        size := float64(m) * 0.2 / 6.5
        faceTitle := getFace(TAIWAN_QUANZI_KU_TTF, float64(m)*0.19/6.5)
        faceContent := getFace(TAIWAN_QUANZI_KU_TTF, float64(m)*0.17/6.5)

        y := int(float64(height) * 0.48)

        for _, work := range works {
                if work == "" {
                        continue
                }

                // Determine color based on content
                col := image.NewUniform(colornames.Violet)
                face := faceContent
                if strings.Contains(work, ".") {
                        col = image.NewUniform(colornames.Yellow)
                        face = faceTitle
                }

                // Split work into chunks of max 30 characters
                var chunks []string
                work := []rune(work)
                for len(work) > 0 {
                        chunkSize := min(28, len(work))
                        chunks = append(chunks, string(work[:chunkSize]))
                        work = work[chunkSize:]
                }

                // Draw each chunk on a separate line
                for _, chunk := range chunks {
                        x := int(float64(width) * 0.07)

                        d := &font.Drawer{
                                Dst:  img,
                                Src:  col,
                                Face: face,
                                Dot: fixed.Point26_6{
                                        X: fixed.Int26_6(x * 64),
                                        Y: fixed.Int26_6(y * 64),
                                },
                        }
                        d.DrawString(chunk)

                        // Move to next line with appropriate spacing
                        y += int(size * 1.5)
                }

                // Add some extra spacing between different work items
                y += int(size * 0.5)
        }
}

func drawHealthData(img *image.RGBA, width, height int) {
        kcal, exercise, stand := 737, 95, 10
        kcalTotal, exerciseTotal, standTotal := 520, 30, 8

        x := int(float64(width) * 0.73)
        size := float64(min(width, height)) * 0.15 / 8
        face := getFace(KLEE_ONE_TTF, size)
        y := int(float64(height) * 0.78)
        d := &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: face,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        d.DrawString(fmt.Sprintf("%3d/%3d KCAL", kcal, kcalTotal))
        y = int(float64(height)*0.78) + int(size*1.5)
        d = &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: face,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        d.DrawString(fmt.Sprintf("%3d/%2d   MIN", exercise, exerciseTotal))
        y = int(float64(height)*0.78) + int(size*3)
        d = &font.Drawer{
                Dst:  img,
                Src:  image.NewUniform(color.White),
                Face: face,
                Dot: fixed.Point26_6{
                        X: fixed.Int26_6(x * 64),
                        Y: fixed.Int26_6(y * 64),
                },
        }
        d.DrawString(fmt.Sprintf("  %2d/%d    HRS", stand, standTotal))

        x, y = int(float64(width)*0.8), int(float64(height)*0.8)
        m := float64(min(width, height))

        drawRing(img, x, y, int(m*0.17), int(m*0.025), color.RGBA{255, 0, 0, 255}, color.RGBA{255, 251, 251, 255}, float64(kcal)/float64(kcalTotal))
        drawRing(img, x, y, int(m*0.14), int(m*0.025), color.RGBA{0, 128, 0, 255}, color.RGBA{0, 255, 127, 255}, float64(exercise)/float64(exerciseTotal))
        drawRing(img, x, y, int(m*0.11), int(m*0.025), color.RGBA{30, 144, 250, 255}, color.RGBA{135, 206, 255, 255}, float64(stand)/float64(standTotal))

}

// 绘制圆环
// img 图纸
// x, y 中心点
// r 半径
// startColor, endColor 开始、结束颜色
// percent 圆环百分比
func drawRing(img *image.RGBA, x, y, r, thickness int, startColor, endColor color.RGBA, percent float64) {
        abs := func(num float64) float64 {
                if num < 0 {
                        return -num
                }
                return num
        }
        angle := func(x, y int) float64 {
                angle := math.Atan2(float64(x), float64(-y))
                if angle < 0 {
                        angle += 2 * math.Pi
                }
                return angle
        }
        for i := -r; i <= r; i++ {
                for j := -r; j <= r; j++ {
                        // 不处于圆环不绘制
                        if i*i+j*j > r*r || math.Sqrt(float64(i*i+j*j)) < float64(r-thickness) {
                                continue
                        }
                        // 小于半径根据角度计算颜色
                        if angle(i, j) > 2*math.Pi*percent {
                                continue
                        }
                        p := abs(math.Atan(float64(j)/float64(i))) * 2 / math.Pi
                        color := color.RGBA{
                                startColor.R + uint8(float64(endColor.R-startColor.R)*p),
                                startColor.G + uint8(float64(endColor.G-startColor.G)*p),
                                startColor.B + uint8(float64(endColor.B-startColor.B)*p),
                                255,
                        }
                        img.Set(x+i, y+j, color)
                }
        }
}

func drawEnglish(img *image.RGBA, width, height int) error {
        url := "http://open.iciba.com/dsapi"
        resp, err := http.Get(url)
        if err != nil {
                return err
        }
        defer resp.Body.Close()

        body, err := io.ReadAll(resp.Body)
        if err != nil {
                return err
        }
        type Rsp struct {
                Content string `json:"content"`
        }
        var rsp Rsp
        err = json.Unmarshal(body, &rsp)
        if err != nil {
                return err
        }
        content := rsp.Content

        size := float64(min(width, height)) * 0.15 / 6.5
        face := getFace(KLEE_ONE_TTF, size)
        nContents := []string{}

        // contents := strings.Split(content, ".")
        contents := []string{content[:len(content)-1]}
        for _, content := range contents {
                if content == "" {
                        continue
                }
                content += "."
                words := strings.Split(content, " ")
                temp := ""
                for _, word := range words {
                        if word == "" {
                                continue
                        }
                        if len(temp)+len(word) > 40 {
                                nContents = append(nContents, temp)
                                temp = ""
                        }
                        if len(temp) > 0 {
                                temp += " "
                        }
                        temp += word
                }
                if len(temp) > 0 {
                        nContents = append(nContents, temp)
                }
        }
        contents = nContents
        for i, c := range contents {
                if c == "" {
                        continue
                }
                x, y := int(float64(width)*0.05), int(float64(height)*0.9)+int(size*float64(i))
                d := &font.Drawer{
                        Dst:  img,
                        Src:  image.NewUniform(color.White),
                        Face: face,
                        Dot: fixed.Point26_6{
                                X: fixed.Int26_6(x * 64),
                                Y: fixed.Int26_6(y * 64),
                        },
                }
                d.DrawString(c)
        }
        // d.DrawString(content)
        return nil
}

html 版本

<html>
    <head>
        <script src="./html2canvas.min.js"  crossorigin="anonymous" referrerpolicy="no-referrer" ></script>
        <!-- <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/4.7.0/css/font-awesome.css"> -->
        <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"
        integrity="sha512-SfTiTlX6kk+qitfevl/7LibUOeJWlt9rbyDn92a1DqWOw9vWG2MFoays0sgObmWazO5BQPiFucnnEAjpAB+/Sw==" crossorigin="anonymous" referrerpolicy="no-referrer" />
        <script src="echart.min.js"></script>
        <link rel="preload" href="Virgil.woff2" as="font" type="font/woff2" crossorigin="anonymous">
        <link rel="preload" href="Cascadia.woff2" as="font" type="font/woff2" crossorigin="anonymous">

        <style>
/* http://www.eaglefonts.com/fg-virgil-ttf-131249.htm */
@font-face {
  font-family: "Virgil";
  src: url("Virgil.woff2");
  font-display: swap;
}

/* https://github.com/microsoft/cascadia-code */
@font-face {
  font-family: "Cascadia";
  src: url("Cascadia.woff2");
  font-display: swap;
}
#all {
    font-size: 40px;
    font-family: "Cascadia";
}
#gradient {
    background: radial-gradient(transparent 50%, black), linear-gradient(transparent, black);
    opacity: .3;
    position: fixed;
    border-radius: 15px;
    top: 0;
    height: 1920px;
    width: 1440px;
    z-index: -1;
}
#content {
    /* align-items: center; */
    display: flex;
    height: 640px;
    width: 1440px;
}
#capture {
    /* padding: 10px; */
    position: fixed;
    border-radius: 15px;
    background-image:url('wallhaven-zyrq1v.jpg');
    background-size: cover;
    background-position: center center;
    z-index: -2;
    border: none;
    height: 1920px;
    width: 1440px;
}
        </style>
    </head>
    <body style="margin: 0px;">
        <div id="all" style="padding: 0px; height: 1920px; width: 1440px;border-radius:3px;">

            <div id="capture">
                <div id="gradient"></div>
            </div>
            <div id="content">
                <div id="chart" style="position: absolute; top: 1170; left: 690px; width: 750px; height: 750px;"></div>
                <div >
                    <p style="color: #fff; margin-left: 120px; font-size: 200px; font-weight: bold;font-family: 'Virgil';">K'</p>
                </div>
                <div style="position: absolute; top: 1350px; margin-left: 90px;">
                    <!-- fa fa-calendar-o -->
                    <i class="fa fa-calendar-check-o" style="color: white;"></i> <p style="color: #fff; display: inline;">January 19, 2023</p>
                    <p style="color: #fff;">English word: 43</p>
                    <!-- <p style="color: #fff;">Rust: axum & sqlx</p> -->
                    <!-- <p style="color: #fff;">System Architecture: SPOOLING</p> -->
                    <p style="color: #fff;">System Architecture: exam review</p>
                    <p style="color: rgb(0, 175, 155);">Strong Password Checker II</p>
                    <!-- <p style="color: rgb(255, 184, 0);">Evaluate the Bracket Pairs <br>of a String</p> -->
                    <!-- <p style="color: rgb(255, 45, 85);">Number of Different <br>Subsequences GCDs</p> -->
                    <!-- We all carry something with us. -->
                    <p style="color: #fff; font-weight: bold;">Don't let anybody tell you <br>they are better than you.</p>
                </div>
            </div>
        </div>
        <script>
var kcal = 713, min = 108, hr = 10
var mychart = echarts.init(document.getElementById("chart"))
var option = {
    backgroundColor: null,
    title: [
        {
            text: kcal+'/700KCAL\n'+min+'/60 MIN\n '+hr+'/6  HRS',
            textStyle: {
                color: '#fff',
                fontSize: 33,
                // fontWeight: 'bold',
                fontFamily: "Cascadia"
            },
            itemGap: 10,
            left: '35%',
            top: '44%',
        },
    ],
    angleAxis: {
        polarIndex: 0,
        min: 0,
        max: 100,
        show: false,
        boundaryGap: ['50%', '50%'],
        startAngle: 90,
    },
    radiusAxis: {
        type: 'category',
        show: true,
        axisLabel: {
            show: false,
        },
        axisLine: {
            show: false,
        },
        axisTick: {
            show: false,
        },
    },
    polar: [
        {
            center: ['50%', '50%'], //中心点位置
            radius: '100%', //图形大小
        },
    ],
    xAxis: {
        show: false,
        type: 'value',
    },
    yAxis: [
        {
            type: 'category',
            inverse: true,
            axisLabel: {
                show: false,
                textStyle: {
                    color: '#444444',
                },
            },
            splitLine: {
                show: false,
            },
            axisTick: {
                show: false,
            },
            axisLine: {
                show: false,
            },
        },
    ],
    series: [
        {
            type: 'bar',
            z: 10,
            data: [hr*100/6],
            showBackground: true,
            backgroundStyle: {
                borderWidth: 10,
                width: 2,
            },
            coordinateSystem: 'polar',
            roundCap: true,
            barWidth: '10%', //大的占比环
            itemStyle: {
                normal: {
                    opacity: 1,
                    // color: '#0000ff',
                    color: new echarts.graphic.LinearGradient(
                        1, 0, 0, 1,       //4个参数用于配置渐变色的起止位置, 这4个参数依次对应右/下/左/上四个方位. 而0 0 0 1则代表渐变色从正上方开始
                        [
                            {offset: 0, color: '#87cefa'},
                            {offset: 0.5, color: '#1e90ff'},
                            // {offset: 1, color: '#ddd'}
                        ]                //数组, 用于配置颜色的渐变过程. 每一项为一个对象, 包含offset和color两个参数. offset的范围是0 ~ 1, 用于表示位置
                    )
                },
            },
        },
        {
            type: 'bar',
            z: 10,
            data: [min*10/6],
            showBackground: true,
            coordinateSystem: 'polar',
            roundCap: true,
            barWidth: '10%', //大的占比环
            itemStyle: {
                normal: {
                    opacity: 1,
                    // color: '#00ff00',
                    color: new echarts.graphic.LinearGradient(
                        1, 0, 0, 1,       //4个参数用于配置渐变色的起止位置, 这4个参数依次对应右/下/左/上四个方位. 而0 0 0 1则代表渐变色从正上方开始
                        [
                            {offset: 0, color: '#00ff7f'},
                            {offset: 0.5, color: '#008000'},
                            // {offset: 1, color: '#ddd'}
                        ]                //数组, 用于配置颜色的渐变过程. 每一项为一个对象, 包含offset和color两个参数. offset的范围是0 ~ 1, 用于表示位置
                    )
                },
            },
        },
        {
            type: 'bar',
            z: 10,
            data: [kcal/7],
            showBackground: true,
            coordinateSystem: 'polar',
            roundCap: true,
            barWidth: '10%', //大的占比环
            itemStyle: {
                normal: {
                    opacity: 1,
                    // color: '#ff0000',
                    color: new echarts.graphic.LinearGradient(
                        1, 0, 0, 1,       //4个参数用于配置渐变色的起止位置, 这4个参数依次对应右/下/左/上四个方位. 而0 0 0 1则代表渐变色从正上方开始
                        [
                            {offset: 0, color: '#fffafa'},
                            {offset: 0.5, color: '#ff0000'},
                            // {offset: 1, color: '#ddd'}
                        ]                //数组, 用于配置颜色的渐变过程. 每一项为一个对象, 包含offset和color两个参数. offset的范围是0 ~ 1, 用于表示位置
                    )
                },
            },
        },
    ],
};

mychart.setOption(option);

            var opts = {
                backgroundColor: null,//设置图片背景为透明
                allowTaint: true, useCORS: true
            };
            function genImg() {
                html2canvas(document.querySelector("#all"), opts).then(canvas => {
                    document.body.appendChild(canvas)
                    var base64 = canvas.toDataURL();
                    console.log(base64)
                    var textNode = document.createTextNode('这是一段文本');
                    document.body.appendChild(textNode)
                    // const base64 = canvas.toDataURL('image/png')
                    // console.log(base64)

                });
            }
            setTimeout("genImg()", 1000)

        </script>

    </body>
</html>

使用 html 写博客

Fri, 16 Aug 2024 16:00:00 GMT

实现

前端框架

vue3 + vite + naive-ui
访客计数

使用不蒜子

问题：访问子页的流量未统计。
允许被搜索引擎爬取

根目录设置 robots.txt

google：判断是否被索引：搜索 site:42tr.github.io，未被索引会提示使用 google search consoloe，验证网站所有权，添加站点地图 sitemap.xml，完成后过一天再看。
Github Actions 自动部署

生成一个 Personal access token，加入到该仓库的 new repository secret，Name 为 ACCESS_KEY，Value 为 token，在代码目录新建 .github/workflows/pages.yml，内容如下

name: GitHub Actions Build and Deploy
on:
  push:
    branches:
      - 42tr
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout 🛎️
        uses: actions/checkout@v2.3.1
        with:
          persist-credentials: false

      - name: Install and Build 🔧
        run: |
          npm install
          npm run build
      - name: Deploy 🚀
        uses: JamesIves/github-pages-deploy-action@3.7.1
        with:
          ACCESS_TOKEN: ${{ secrets.ACCESS_KEY }}
          BRANCH: gh-pages
          FOLDER: dist
          CLEAN: true

开发中遇到的问题

打包发布到 github.io 的文件无法加载

问题原因：打包后生成的文件名以下划线开头，无法返回。

解决方案：修改 vite.config.ts

export default defineConfig({
    plugins: [vue()],
    build: {
        rollupOptions: {
            output: {
                // 入口文件名
                // entryFileNames: `assets/[name].js`,
                // 块文件名：不能下划线开头，增加一个 main 前缀
                chunkFileNames: `assets/main-[name]-[hash].js`,
                // 资源文件名 css 图片等等
                // assetFileNames: `assets/[name]-[hash].[ext]`,
            }
        }
    }
})

解决发布缓存问题——增加唯一标识，如时间戳

const timestamp = new Date().getTime()

export default defineConfig({
  build: {
    rollupOptions: {
      output: {
        // 入口文件名
        entryFileNames: `assets/[name].${timestamp}.js`,
        // 块文件名
        chunkFileNames: `assets/[name]-[hash].${timestamp}.js`,
        // 资源文件名 css 图片等等
        assetFileNames: `assets/[name]-[hash].${timestamp}.[ext]`,
      },
    },
  }
})

Leptos 初识

Thu, 01 Feb 2024 16:00:00 GMT

A cutting-edge Rust framework for the modern web.

About

Leptos is a full-stack, isomorphic Rust web framework leveraging fine-grained reactivity to build declarative user interfaces.

创建项目

cargo new hello_leptos
cd hello_leptos
cargo add leptos
cargo install trunk
rustup target add wasm32-unknown-unknown

添加依赖 leptos = { version = "0.6.5", features = ["csr"] }

下载失败需要设置 rust 源

# 放到 `$HOME/.cargo/config` 文件中
[source.crates-io]
registry = "https://github.com/rust-lang/crates.io-index"

# 替换成你偏好的镜像源
replace-with = 'sjtu'
#replace-with = 'ustc'

# 清华大学
[source.tuna]
registry = "https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"

# 中国科学技术大学
[source.ustc]
registry = "git://mirrors.ustc.edu.cn/crates.io-index"

# 上海交通大学
[source.sjtu]
registry = "https://mirrors.sjtug.sjtu.edu.cn/git/crates.io-index"

# rustcc社区
[source.rustcc]
registry = "git://crates.rustcc.cn/crates.io-index"

[net]
git-fetch-with-cli=true

启动 trunk serve --open

使用 cargo leptos

安装 nightly 版本 rust
rustup target add wasm32-unknown-unknown
创建 cargo leptos new --git leptos-rs/start
启动 cargo leptos serve
构建 cargo leptos build

树莓派搭建 nas 服务器

Thu, 25 Jan 2024 16:00:00 GMT

准备

硬件

树莓派 4b
磁盘阵列盒 CM461

挂载

启动磁盘阵列盒，设置 raid 模式（reset 10s）
格式化磁盘 mkfs -t ext4 /dev/sdb，挂载磁盘 mount /dev/sdb /disk

开启 smb

安装
```
apt-get install samba samba-common-bin
```
添加用户 useradd smb，设置密码 smbpasswd -a smb

查看 smb 用户: pdbedit -L

删除 smb 用户: pdbedit -x <username>

修改配置 /etc/samba/smb.conf，添加

[disk]
 path = /disk/
 guest ok = yes
 browseable = yes
 writeable = yes
 create mask = 0777
 # 设置可访问的用户，非必选
 valid users = root
 directory mask = 0777

重启 smb 服务 systemctl restart smbd

连接

windows

输入 \\ip 即可

如果修改过用户，连接时会报错，multi user，在 cmd 执行 net use * /del /y 清除即可 windows 外网链接问题
mac

mount -t smbfs //<user>:<pwd>@<ip>:<port>/<dir> <local_dir>

finder 远程连接

部署影音服务器软件

Plex
emby
Jellyfin

免费，安装 sudo docker run -d -p 8096:8096 -v /disk/app/jellyfin/config:/config -v /disk/resource:/media jellyfin/jellyfin

树莓派应用开发

Wed, 10 Jan 2024 16:00:00 GMT

设置开机自启

创建服务单元

vi /etc/systemd/system/firefly.service

[Unit]
Description=My Executable Service
After=network.target

[Service]
ExecStart=/root/app/ff/firefly
Restart=always
User=root
Group=root
Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

[Install]
WantedBy=multi-user.target

设置开机自启

systemctl start firefly
systemctl enable firefly

内网穿透

使用 frp

公网服务器

下载安装

# 创建安装目录
mkdir frp_service
# 切换目录
cd frp_service/
# 下载frp
wget https://github.com/fatedier/frp/releases/download/v0.24.1/frp_0.24.1_linux_amd64.tar.gz
# 解压
tar -zxvf frp_0.24.1_linux_amd64.tar.gz
# 切换目录
cd frp_0.24.1_linux_amd64/
# 删除客户端配置文件
rm -f frpc frpc.ini
# 修改配置文件,vi命令也行
vim frps.ini

frp.ini

[common]
# 监听端口
bind_port = 7000
# 映射 http 端扣
vhost_http_port = 80
# 特权 token
privilege_token = 111111
# 后台管理 端口、用户名、密码
dashboard_port = 7500
dashboard_user = raspberry
dashboard_pwd = pi

注：建议使用最新版本，0.24.1 出现 https 配置问题，更新后解决

确认服务启动正常：./frps -c ./frps.ini
设置开机自启：nohup ./frps -c ./frps.ini &

树莓派

下载安装

mkdir frp_service
cd frp_service/
wget https://github.com/fatedier/frp/releases/download/v0.24.1/frp_0.24.1_linux_arm.tar.gz
tar -xzvf frp_0.24.1_linux_arm.tar.gz
cd frp_0.24.1_linux_arm/
rm -f frps frps.ini
vim frpc.ini

frpc.ini

#基础配置
[common]
server_addr = 111.111.111.111
server_port = 7000
privilege_token = 111111

#tcp配置
[ssh]
type = tcp
local_ip = 192.168.1.13
local_port = 22
remote_port = 8888

#web配置
[web]
type = http
local_port = 80
custom_domains = kisia.cn

确认服务启动正常：sudo ./frpc -c frpc.ini
设置自启动：nohup ./frpc -c ./frpc.ini &

也可以使用 docker 的方式，注意版本号与服务端一致

docker run -d \
  --name frpc \
  --restart always \
  -v /disk/app/frpc/frpc.ini:/etc/frp/frpc.ini \
  snowdreamtech/frpc:0.24.1

https

如果需要开启 https，建议映射到 server 端后，在 server 端通过 caddy 开启。

42tr · 博客

从零开始开发 ESP32

起点：硬件与开发环境

先让屏幕亮起来

切换到树莓派开发：Linux 主机编译并写入 ESP32

从图片演示到独立联网

把网络读取做成可以测试的模块

触摸交互

语音唤醒

最新 PCB 载板

之前的 Codex 工作轨迹

碰到的问题

下一步工作

麒麟 4.0.2 上的 Electron 适配：从运行库到现代 CSS 降级

架构：前端无需改动

排障过程：四层问题逐层剥开

1. 加载期符号不兼容

2. 运行期启动即段错误

3. Chromium 108 无法解析现代 CSS

4. 白屏并不等于加载失败

交付内容

后续维护要点

麒麟 Kylin 4.0.2 + 4.11 内核 Docker 安装

1. 下载并解压静态二进制包

2. 配置 daemon.json

3. 编写 systemd 服务

4. 启动并验证

5. 安装 Docker Compose 插件

常见问题

用 OpenDataLoader PDF 搭一个兼容 MinerU 的解析服务

一条请求是怎样完成的

兼容层主要适配了什么

页码规则

坐标系统

内容列表

本地启动

用 Docker 部署

后端选择与兼容边界

轻量级日志监控平台搭建

环境部署

使用

配置 Connections

测试

配置 Dashboard

Rust LanceDB 内存不足问题

猜测一：RAM 不足

猜测二：Docker 容器限制

猜测三：虚拟内存不足

猜测四：mmap（实际问题）

克鲁斯卡尔（Kruskal）算法

并查集

PageIndex架构分析

一、文档解析流程（Document Parsing）

1 文档加载

2 文档结构解析

3 LLM 推理生成初始目录

4 构建文档树（Document Tree）

5 文档 Chunk 切分

6 Embedding 向量化

7 构建索引

二、搜索流程（Query Pipeline）

1 Query 解析

2 向量搜索

3 结构补全

4 上下文重排序

5 构造 LLM Prompt

6 LLM 生成答案

三、核心算法

1. 文档树生成算法

1 结构元素检测

2 层级推断

3 树结构构建

搜索时的结构扩展策略

LLM 生成目录为什么不会超上下文

rust内存分析

环境准备

代码

使用

算力

估算方式

`cargo.toml`

`main.rs`

部署 `OnlyOffice`

部署 `NextCloud`