比较提交

..
12 次代码提交
共修改 34 个文件,包含 1160 行新增和 69 行删除

没有与搜索条件相匹配的文件

+44 -35
查看文件
@@ -1,46 +1,55 @@
# 交接:飞牛 APFS 只读访问
# 交接:大鱼硬盘拷贝
更新时间:2026-11-11(Asia/Shanghai)。
更新时间:2026-11-12,Asia/Shanghai。
## 当前目标
## 当前目标与进展
基础 APFS 只读挂载已验证。下一步用普通测试文件验证素材读取及导入,再确定应用封装方案。
- 11 月 12 日“大于 50GB”导入已完成:同一 Tech 4TB APFS 盘共 11 个符合门槛的顶层目录;之前 2 个比赛目录结构/大小复核一致后复用;新增 9 个目录、781417428219 字节,任务 `20261112-000934-7eab85`。50GB 按 50,000,000,000 字节,子目录结构保留。
- 其中 8 个文件原名为 272–576 字节,超过 NAS 的 255 字节限制,初始 rsync 返回 23。按用户明确选择,仅缩短这 8 个目标文件名,保留扩展名,以原相对路径哈希防冲突;8134306 字节已逐文件 SHA-256 读回核验。其余 401182 个普通文件由 rsync 传输校验,457268 个可表示的目录/文件/链接条目结构/大小/链接核对无差异,不宣称对全部 781GB 额外逐字节读回。
- 原名对照表位于目标根目录 `文件名对照-20261112-000934-7eab85.csv` 和同名 JSON,归属 UID 1000;完整文件名、清单及素材只在 NAS,不上传 Git。原始 macOS 属性额外保存在 `.dayu-diskcopy-metadata-20261112-000934-7eab85`,453582 条、约 91.5 MB,保留。
- 正式任务历史已记录人工短名恢复过程,显示“已完成”及 8 个文件更名提示;原始失败日志保留。目标已 syncfs、源分区写计数不变、挂载已释放、块设备原 RO=0 已恢复。见 `verification/2026-11-12-large-copy.json`。
## 已确认
- 用户指定的“火影秋决”和“LCQ荒野乱斗”已完成 NAS 本机复制及核验,目标 `/vol5/1000/剪辑盘备份`,没有向 APFS 源分区写入。
- 原生飞牛应用已实现 APFS / NTFS 识别、只读访问、目录勾选、目标目录/新建目录、后台复制、进度和校验、失败/中断任务重试。0.1.4 已正式安装运行,实机界面复制/续传/校验通过,Release 已发布并完成草稿及正式附件的浏览器全量下载校验。
- 用户已要求停止逐条播报拷贝速度;仅告知完成或异常。
- 用户已明确同意飞牛针对本应用的第三方免责提示并授权继续更新;同一提示无需重复询问,不适用于其他软件或不同条款。
- SSH 已登录 `192.168.31.21:22`,管理员提权已验证;网页管理端口为 5668。
- NAS:Intel i5-12400T / x86_64;Debian 12;内核 `6.18.18.c1107-trim`。
- 有 `/dev/fuse`、FUSE 3.14、Docker;未检测到 apfs-fuse 或本机编译器。
- 测试卡为约 29.7 GiB USB SD 卡;APFS 分区当前为 `/dev/sde2`,分区 GUID 类型 `7c3457ef-0000-11aa-aa11-00306543ecac`,4096 字节块大小,NXSB 标识正确。
- APFS PARTUUID:`5b255495-2ba8-4e49-8774-227d8dd8878f`。每次操作仍需核实其设备身份、USB 传输及挂载状态,不能盲用 sde2。
- 读卡器以 USB 5000M 连接。飞牛图形界面显示“未知文件系统”;独立 FUSE 挂载已成功,但尚未集成系统界面。
- 本轮 SSH 曾返回 `Exceeded MaxStartups`,等待后恢复。未修改 SSH 服务。
## 工程与正式位置
## 工程与恢复
- 本机:`/Users/mac/Documents/dayu-git/repositories/fnos-apfs`;私有远程 `https://dayu.media/git/dayu/fnos-apfs.git`,分支 main,仓库 ID 61。
- 固定 appname `dayu-diskcopy`,显示名“大鱼硬盘拷贝”;唯一安装入口 `/var/apps/dayu-diskcopy`,实际 target 在 `/vol3/@appcenter/dayu-diskcopy`,不是两份安装。
- 访问:飞牛桌面图标,或 `https://192.168.31.21:5668/app/dayu-diskcopy`。仅管理员,经飞牛官方网关登录态,不增加 TCP 端口。
- NAS:fnOS 1.2.0701 / Debian 12 / x86_64 / i5-12400T;Python 3、FUSE、rsync、ntfs-3g 为已有运行组件。
- Web 服务实际为专用用户 UID 985;受限设备服务为 root。网关与设备两个 Unix Socket 都为 0660。源设备仅枚举 USB APFS/NTFS,路径/链接越界拒绝。
- 核心代码 `application/`;FPK 定义 `packaging/fpk/`;构建入口 `scripts/build-fpk.py`。完整上游源码与 LZFSE 已含在 vendor 和 FPK;许可证及版本见 `UPSTREAM.json`。
- 本机:`/Users/mac/Documents/dayu-git/repositories/fnos-apfs`。
- 私有远程:`https://dayu.media/git/dayu/fnos-apfs.git`,分支 main;首个基线 `08e7da7f237c1a21aedad17b7a259726b8182060` 已推送并回读核验。
- `vendor/apfs-fuse` 保存完整源码快照,含 LZFSE 子模块内容;固定版本见 `UPSTREAM.json`。apfs-fuse `66b86bd525e8cb90f9012543be89b1f092b75cf3`,LZFSE `e634ca58b4821d9f3d560cdc6df5dec02ffc93fd`。
- `packaging/Dockerfile` 在固定 Debian 12 基础镜像中编译 Release;`scripts/build-driver.sh` 导出驱动;`scripts/validate-card.py` 按 PARTUUID + USB 序列号核对设备,临时设置内核只读,测试后卸载并恢复原标志。
- 验证程序检查挂载只读、样本复制 SHA-256、APFS 分区写计数和首 MiB 内容;这不是对整盘所有文件或全部 APFS 特性的兼容性保证。
- 首次代码检查点已从远程独立克隆核验,LZFSE 源码完整。实际验证代码为 `d24400b492a90275d8432e63db78c61ff0ddfa09`;本阶段恢复标签为 `poc-apfs-readonly-20261111`,详见 [RECOVERY.md](RECOVERY.md)。
- NAS 验证工程路径为 `/var/tmp/dayu-apfs-validation`,驱动只放在该目录 `build/bin`,未安装至系统路径。保留该目录和专用构建镜像供后续开发。
- 首次构建因 Debian 官方源下载缓慢主动取消,改用容器内中科大镜像后 Release 构建成功,仍保留 Debian 原有签名校验;NAS 宿主机软件源未修改。
## 当前验证
## 验证结果与边界
- 九项权限、网关校验、路径边界、文件系统识别和准备中任务可见性测试通过。Python/生命周期脚本语法及官方 fnpack 格式检查通过。
- 0.1.3 已实机从界面新建目标目录、选 APFS 目录并复制成功;预置 100000 字节不完整文件,rsync 实际复用 99400 字节,完整结果 SHA-256 一致。已存在且 mtime 不同的文件也正确保留并通过内容校验。见 `verification/2026-11-11-app-ui.json`。
- 0.1.4 已核对正式安装的全部应用载荷 SHA-256,实际复制与选择框状态正确;准备中任务可见性、有活动任务时禁止卸载的边界测试通过。见 `verification/2026-11-11-final-install.json`。
- NTFS:独立 64 MiB 镜像只读挂载,1 MiB 文件复制 SHA-256 一致;没有实体 NTFS USB 盘验证。见 `verification/2026-11-11-ntfs-image.json`。
- APFS SD 基础验证见 `verification/2026-11-11-apfs-sd.json`。首版不承诺加密卷或全部 APFS 特性兼容。
- 原始 macOS 扩展属性作为私有存档保存在拷贝目标,不盲目应用机器相关安全属性。真实文件名清单、数据、私有日志和凭据绝不上传 Git。
- Python/Bash 语法检查通过;实际不匹配 USB 身份测试被拒绝。
- NAS 本机 Release 构建成功,运行库均可解析;源码的上游编译警告保留,未修改上游实现。
- APFS 分区内核只读标志设为 1 后,以 `ro,nodev,nosuid,noexec` 挂载成功。
- 读取并复制三个 64 KiB 系统隐藏文件,合计 196608 字节,目标 SHA-256 与读取流一致。
- APFS 分区写入计数测试前后均为 0,首 MiB 哈希不变;测试后已卸载、删除样本副本、恢复原内核只读标志。
- 未找到 512 MiB 以内的普通文件可作样本;尚未验证普通素材导入、独立 macOS 参考哈希、大文件速度、加密及其他 APFS 特性。64 KiB 隐藏文件的速度没有代表性,不据此承诺提速。
- 脱敏证据见 [verification/2026-11-11-apfs-sd.json](verification/2026-11-11-apfs-sd.json),编译依赖见同目录清单。证据不包含源文件内容、文件名或凭据。
- 不使用当前聊天原工作目录“大鱼调色”,不修改 NAS 网站生产源。
- 凭据在用户指定的本机安全位置,不进入工程。
## 已完成的比赛目录备份
## 待完成
- 新增 501332211263 字节;复制用时 2197.872 秒;已有 64 个文件完整校验无差异,目录核对无差异,目标已 syncfs,源写计数为零,源已卸载并恢复原只读标志。见 `verification/2026-11-11-competition-copy.json`。
- 复制时源盘 Tech / DD56419883A4F,APFS PARTUUID `d6bd791c-7bee-486b-8fef-6cf584381a55`;不能将设备名 sdg2 当永久身份。
- 真实任务记录已校验后迁移至 `/var/apps/dayu-diskcopy/var/jobs/imported-20261111-223613`,应用重启后可正常显示。原型目录 `/var/tmp/dayu-apfs-validation` 已清理。
- 目标隐藏目录 `.dayu-apfs-metadata-20261111-223613` 为对应元数据存档,约 1.7 MB,7374 条记录;保留,不清理。
1. 等待用户确认普通测试文件情况;建议 100–500 MB 视频,若可提供 macOS 的 SHA-256 则做独立比对。拔卡前从飞牛系统推出整张卡。
2. 继续使用 PARTUUID 和 USB 身份核对,不假设重新插入后仍为 sde2;重新格式化后 PARTUUID 也会变化。
3. 应用界面、FPK、自动识别、系统文件管理集成及真实 SSD 性能尚未实现,本阶段不是正式应用交付。
## 安装与后续
- 当前设备 CLI install-fpk 对已有应用只提示 installed,不能宣称升级。更新要走网页应用中心“手动安装”,先点“从电脑上传”,再选择 FPK;窗口加载是异步的。
- 原生网关改写 upstream Host,不能直接严格比较 Origin/Host;现用私有页面随机校验值、跨站请求限制和管理员 Header。匿名、非管理员和缺少校验值的写请求都被拒绝。
- 本轮界面测试目录与三条测试任务已清理,真实比赛目录、元数据存档和任务记录保留。NAS 原型驱动、测试镜像、上传暂存与专用构建镜像标签已清理;Docker 共享缓存不作全局清理。本机已删除可重建 build 暂存与原型私有测试输出,保留唯一当前发行 FPK。
- 桌面打开反馈已复查:单击/双击桌面图标及应用中心“打开”正常,用户确认现在可打开;服务正常、网关 HTTP 200、两盘/真实任务可见,无需改代码。见 verification/2026-11-12-launch.json。实体 NTFS USB 盘尚未测试。
## 正式发行与恢复
- 代码标签 `v0.1.4` → `72d678fa03dc730e44d4e53988ea86a88aec6a0f`;标签不移动。后续 main 提交仅补齐验证与交付记录。
- [Release](https://dayu.media/git/dayu/fnos-apfs/releases/tag/v0.1.4),ID 432;附件 ID 71,`dayu-diskcopy-0.1.4-x86.fpk`,564939 字节。
- SHA-256:`cc761c2c62510674bbed60133ec042732dd84477806f0f6550cc97bf50205307`。当前可供分享的本机发行包在 `/Users/mac/Downloads/dayu-diskcopy-0.1.4-x86.fpk`;项目 dist 已无 FPK。已重新核对该包 564939 字节及同一 SHA-256,未另建副本。
- 私有下载需要大鱼站正常网页登录;API 令牌访问网页下载 URL 返回 404。已使用原有 Edge 登录态分别完整下载草稿与正式附件、核对字节数与 SHA-256,再回读 API 版本/附件及远程标签。见 `verification/release-0.1.4.json`,不能把脚本的网页下载 404 当作附件未上传而重复 POST。
- 已独立从远端克隆标签,使用下载的 Release 恢复驱动并重新构建 FPK,恢复载荷与正式安装逐文件哈希一致,临时 clone 已清理。见 `verification/recovery-0.1.4.json` 和 [RECOVERY.md](RECOVERY.md)。
+29 -23
查看文件
@@ -1,38 +1,44 @@
# 飞牛 APFS 只读访问验证
# 大鱼硬盘拷贝
目标:将 APFS 移动存储直接连接 fnOS,在 NAS 本机读取并导入文件,绕过千兆网络。
飞牛 fnOS 原生桌面应用,在 NAS 本机读取 APFS / NTFS 外接硬盘并复制目录,不经过电脑或 SMB 中转。
当前阶段为只读驱动兼容性验证,尚未制作飞牛应用安装包,也未集成系统“外接存储”界面。
## 使用
2026-11-11 实机结果:APFS SD 卡只读挂载成功,三个系统隐藏文件复制校验通过,APFS 分区写计数为零。普通素材导入与大文件速度待测试;详见交接及 `verification/`。
支持已测试的 fnOS 1.2.0701 x86_64。手动安装 FPK 后,在飞牛桌面打开“大鱼硬盘拷贝”,或访问 `/app/dayu-diskcopy`。使用管理员登录态,不增加独立网络端口。
## 安全边界
1. 选择外接硬盘,勾选同一层级中的源目录。
2. 选择自己的 NAS 存储空间和目标目录,可新建文件夹。
3. 开始拷贝,在任务中查看进度和校验结果。关闭窗口不会终止任务。
- 只对核实身份的 USB APFS 测试分区执行只读访问;不格式化、不修复、不写源盘。
- 不安装内核模块,不改飞牛存储服务、启动配置、系统软件包或现有 Docker 服务。
- 编译与测试使用独立目录及容器;不使用 NAS 网站生产目录。
- 账号密码只从用户指定的本机文件读取到内存,不进入源码、参数或记录。
- 默认不启用 apfs-fuse 的 lax 模式,不记录加密调试数据。
源盘不格式化、不修复;新挂载的卷使用只读挂载。已被飞牛挂载的 NTFS 优先复用,应用只读取文件,不修改系统挂载方式。已存在的文件先保留并校验,不同版本不自动覆盖。失败或中断的应用任务可重试,已完成文件会复用,部分文件可继续传输。
## 工程入口
普通文件保留名称、时间和链接;APFS 原始扩展属性另外保存到目标中的隐藏存档,不盲目应用机器相关安全属性。存档可能含私人元数据,不上传源码仓库。首版不承诺所有 APFS 特性或加密卷兼容,不改写剪辑工程内部引用。
- [HANDOFF.md](HANDOFF.md):当前状态与下一步。
- 驱动来源:[sgan81/apfs-fuse](https://github.com/sgan81/apfs-fuse),只读 FUSE 实现;固定源码版本及许可证见下文。
APFS 可接受的部分中文长文件名会超过 NAS 文件系统单个名称 255 字节的上限。0.1.4 遇到这类文件会明确报告任务失败,不会自动改名;需选择归档或缩短目标名并保留对照表后恢复。11 月 12 日实盘导入中发现 8 个此类文件,已按用户选择人工缩短、保存对照表并逐个 SHA-256 核验。该人工恢复流程不等于当前安装包已具备自动处理功能。
## 构建与验证
## 验证
完整驱动快照及 LZFSE 源码位于 `vendor/`,版本见 `UPSTREAM.json`,许可证保留在各自目录内;不需要从上游重新下载源码。
- APFS:真实 4 TB USB 盘两目录本机复制,新增约 501 GB,既有 64 个文件校验一致,源分区写计数为零;见 `verification/2026-11-11-competition-copy.json`。
- APFS 大目录:新增 9 个目录约 781GB 已备份,8 个超长文件名人工恢复并保留对照表,详见 `verification/2026-11-12-large-copy.json`。
- NTFS:只读镜像挂载和复制 SHA-256 比对通过,尚无实体 NTFS USB 盘验证;见 `verification/2026-11-11-ntfs-image.json`。
- 网关身份、页面私有校验、跨站请求、路径/链接边界及文件系统识别测试见 `tests/`。
- 最终实机交付状态以 [HANDOFF.md](HANDOFF.md) 为准。
在 x86_64 Linux + Docker 中,于工程根执行 `bash scripts/build-driver.sh`。仅容器内安装编译依赖;输出 `build/bin/apfs-fuse`、`apfsutil` 及依赖版本清单。NAS 本机需有 libfuse3、libstdc++、zlib、libbz2 的运行库。
## 开发与构建
验证入口为 `scripts/validate-card.py --partuuid <APFS分区PARTUUID> --serial <USB设备序列号> --workdir <工程根目录>`,需管理员运行。它会暂时挂载、读取最多三个 512 MiB 以内样本、将副本写入工程测试目录并比对 SHA-256,然后删除副本及卸载。不会尝试写 APFS 源盘。结果保存在工作目录 `result.json`。
- `application/`:界面、降权 Web 服务、受限设备服务、生命周期控制。
- `packaging/fpk/`:固定 appname `dayu-diskcopy` 的安装定义。
- `scripts/copy-directories.py`:后台复制、内容核验与挂载回收。
- `scripts/save-xattrs.py`:私有扩展属性存档。
- `vendor/apfs-fuse/`:包含 LZFSE 的完整源码快照及许可证,版本见 `UPSTREAM.json`,FPK 内也附对应源码。
SD 卡只适合验证基本功能,不能代表外置 SSD 的吞吐;隐藏索引文件的读取也不能当作素材导入测试。
Linux + Docker 中执行 `bash scripts/build-driver.sh` 构建 Release 驱动。验证后将两个可执行文件放入 `build/linux-bin/`。打包脚本核对本轮已验证驱动的固定 SHA-256;工具链变化后的二进制需重新验证,不能盲目绕过检查。
## 恢复
```sh
PYTHONDONTWRITEBYTECODE=1 python3 -m unittest discover -s tests -v
python3 scripts/build-fpk.py /path/to/official/fnpack
```
目标远程:`https://dayu.media/git/dayu/fnos-apfs.git`,分支 `main`。
使用官方 fnpack 1.2.3,产物位于 `dist/`,不保存为 Git 对象或 LFS。更新通过网页应用中心“手动安装”;当前设备的 CLI install-fpk 对已安装应用只提示 installed,不能据此宣称更新成功。
克隆后查看交接及固定驱动版本。凭据、磁盘数据、编译输出和容器镜像不纳入 Git;本机账号需独立配置。
完整恢复入口见 [RECOVERY.md](RECOVERY.md)。
恢复入口见 [RECOVERY.md](RECOVERY.md),最新状态见交接。凭据、真实文件名清单、源文件内容和私有日志不进入 Git。
+32 -11
查看文件
@@ -1,20 +1,41 @@
# 恢复与继续验证
# 恢复:大鱼硬盘拷贝 0.1.4
- 私有远程:`https://dayu.media/git/dayu/fnos-apfs.git`。
- 分支:`main`;本轮阶段标签:`poc-apfs-readonly-20261111`。
- 已实机验证的代码提交:`d24400b492a90275d8432e63db78c61ff0ddfa09`;阶段标签还包含最终验证证据与交接。
- 完整驱动源码和 LZFSE 依赖均为普通 Git 文件,已保存至 `vendor/`;没有 LFS 对象、Git 子模块或未上传的必要源码。
- 先登录大鱼站并按现有指南配置 Git 凭据,再克隆项目。凭据和源盘数据不随 Git 保存。
## 优先恢复正式安装包
私有 [Release v0.1.4](https://dayu.media/git/dayu/fnos-apfs/releases/tag/v0.1.4),附件 ID 71:`dayu-diskcopy-0.1.4-x86.fpk`,564939 字节。
SHA-256:`cc761c2c62510674bbed60133ec042732dd84477806f0f6550cc97bf50205307`。
使用自己的大鱼站正常网页登录下载。当前 API 令牌请求私有网页下载返回 404,正常已登录 Edge 下载已实测成功;不要为下载修改仓库可见性或扩大令牌权限。安装到已测试的 fnOS 1.2.0701 x86_64,在网页应用中心使用“手动安装”。唯一 appname 为 `dayu-diskcopy`,不要同时安装改名副本。
## 恢复源码
远程:`https://dayu.media/git/dayu/fnos-apfs.git`,分支 main;正式代码标签 `v0.1.4` 对应完整提交 `72d678fa03dc730e44d4e53988ea86a88aec6a0f`。最终交付与发布后的验证记录在 main,标签保持当时实际构建源码,不移动。
```sh
git clone https://dayu.media/git/dayu/fnos-apfs.git
cd fnos-apfs
git switch --detach poc-apfs-readonly-20261111
git rev-parse HEAD
git switch --detach v0.1.4
```
在 x86_64 Linux + Docker 中执行 `bash scripts/build-driver.sh`;固定 Debian 12 基础镜像及上游源码版本见 Dockerfile / UPSTREAM.json。APT 依赖版本清单保留在 `verification/`;仓库未封存全部 Debian 软件包,未来源版本变化可能改变二进制哈希。若基础镜像或镜像站不可用,需要恢复对应基础镜像或选用保持 Debian 签名校验的源,不能直接称二进制逐字节可复现。
完整 APFS 驱动与 LZFSE 源码都在 vendor,为普通 Git 文件,无 LFS 对象或 Git 子模块。固定版本、许可证和容器构建入口见 `UPSTREAM.json`、`packaging/Dockerfile`、`scripts/build-driver.sh`。
NAS 本机运行依赖:libfuse3、libstdc++、zlib、libbz2,以及 `/dev/fuse`。验证命令见 README;先核对真实 USB 设备、APFS 分区及 PARTUUID,不能复制旧的 `/dev/sde2` 作为永久设备路径。
构建 FPK 需要官方 fnpack 1.2.3,以及已验证的两个 Linux 驱动置于 `build/linux-bin/`。可从已校验 Release 的外层 gzip/tar 中读取 `app.tgz`,再只提取 `bin/apfs-fuse`、`bin/apfsutil` 到受控目录。不要对未校验的未知归档盲目 extractall。
`verification/2026-11-11-apfs-sd.json` 记录测试范围、二进制哈希及源盘只读证据。当前仅证明基础挂载及隐藏系统文件读取;普通用户文件与吞吐尚待测试。NAS 上的 `/var/tmp/dayu-apfs-validation` 是可重建验证目录,不是正式安装或网站生产源。没有发布 FPK 或正式发行安装包。
驱动 SHA-256:
- apfs-fuse:`89a7083c42fb498b021d9f7fabbc5b754eaae503649500e4926965fdcfbcb11e`
- apfsutil:`692bbd961678c5db1a48e00cb2bc96c50e82dd77e39d87cfe11087608b4658ae`
执行 `python3 scripts/build-fpk.py /path/to/official/fnpack`。本轮已从远端独立克隆代码、从真实下载附件恢复驱动并重新打包,恢复的应用载荷与正式安装一致。归档时间戳及 Git 文本换行规范化可能改变整体 FPK 哈希,不声称未来编译容器或完整归档可逐字节复现;新包必须重新安装验证,不沿用旧包的验收值。
若重编驱动,需重新验证;Debian APT 精确依赖清单在 verification/build-packages-2026-11-11.txt,仓库未封存全部系统软件包,不盲目更新构建脚本的固定二进制哈希检查。
## NAS 数据与任务
- 唯一安装入口 `/var/apps/dayu-diskcopy`;实际载荷位于 `/vol3/@appcenter/dayu-diskcopy`,配置、数据由飞牛各自的 etc/var 路径管理。
- 真实媒体位于用户选择的 NAS 目标目录,不在应用安装目录内;卸载应用不应删除这些外部备份。
- 本轮真实任务在 `var/jobs/imported-20261111-223613`;对应两目录在 `/vol5/1000/剪辑盘备份`。隐藏元数据存档与媒体一起保留,不上传 Git。
- 11 月 12 日额外导入任务 `var/jobs/20261112-000934-7eab85` 已完成。8 个目标文件名按用户选择缩短,目标根目录的同名 CSV/JSON 对照表必须和媒体一起保留;恢复到 Mac 时可按表改回原名。对应 `.dayu-diskcopy-metadata-20261112-000934-7eab85` 保存原名下的扩展属性。0.1.4 安装包没有自动短名功能,不能直接重试来解决同一长度限制。
- 正在执行任务时不要卸载。窗口关闭或 Web 服务重启不会主动终止后台复制;断电后确认原盘身份并使用重试功能。不要把 sdg2 当永久磁盘身份。
- 凭据、真实素材和私有清单不随源码仓库保存。Git/Release 保存范围及服务端备份限制沿用用户的全局规则,不承诺 NAS 与本机同时损坏仍可恢复媒体。
+332
查看文件
@@ -0,0 +1,332 @@
"""Privileged local-only disk operations; no TCP listener and no shell execution."""
import fcntl
import grp
import json
import os
from pathlib import Path
import pwd
import re
import signal
import socket
import socketserver
import stat
import struct
import subprocess
import time
import uuid
ROOT = Path(__file__).resolve().parent
VAR = Path(os.environ['TRIM_PKGVAR'])
APP_UID = int(os.environ['TRIM_UID'])
APP_GID = int(os.environ['TRIM_GID'])
LEGACY = Path('/var/tmp/dayu-apfs-validation')
TERMINAL = {'complete', 'failed', 'needs_attention', 'cleanup_failed', 'cancelled'}
HISTORY = {}
def command(args, timeout=30):
result = subprocess.run(args, capture_output=True, text=True, timeout=timeout, env={**os.environ, 'LC_ALL': 'C'})
if result.returncode:
raise ValueError((result.stderr or result.stdout).strip()[-600:] or '操作失败')
return result.stdout.strip()
def beneath(path, root, must_exist=True):
path = Path(path).resolve(strict=must_exist)
root = Path(root).resolve(strict=True)
if not path.is_relative_to(root):
raise ValueError('所选路径超出可访问目录')
return path
def atomic(path, data):
temporary = path.with_suffix('.tmp')
temporary.write_text(json.dumps(data, ensure_ascii=False, indent=2))
temporary.replace(path)
def disks():
tree = json.loads(command(['lsblk', '-J', '-b', '-o',
'NAME,PATH,TYPE,SIZE,FSTYPE,UUID,PARTUUID,TRAN,MODEL,SERIAL,MOUNTPOINTS']))
result = []
for disk in tree['blockdevices']:
if disk.get('tran') != 'usb' or not disk.get('size'):
continue
for part in [disk, *disk.get('children', [])]:
filesystem = (part.get('fstype') or '').lower()
if filesystem not in ('apfs', 'ntfs', 'ntfs3'):
continue
identity = part.get('partuuid') or part.get('uuid')
if not identity or not disk.get('serial'):
continue
result.append({'id': identity, 'partuuid': part.get('partuuid'),
'uuid': part.get('uuid'), 'device': part['path'], 'filesystem': filesystem,
'serial': disk['serial'], 'model': (disk.get('model') or 'USB 硬盘').strip(),
'size': part['size'], 'mountpoints': [x for x in part.get('mountpoints', []) if x]})
return result
def mounts():
path = VAR / 'mounts.json'
return json.loads(path.read_text()) if path.exists() else {}
def jobs(uid=None):
result = []
for parent, legacy in ((VAR / 'jobs', False), (LEGACY / 'jobs', True)):
if not parent.exists():
continue
for folder in sorted(parent.iterdir(), reverse=True):
try:
config = json.loads((folder / 'config.json').read_text())
state = json.loads((folder / 'status.json').read_text())
owner = config.get('uid', 1000)
if uid is not None and uid != owner:
continue
log_path = folder / 'copy.log'
data = log_path.read_bytes()[-16000:].decode(errors='replace') if log_path.exists() else ''
progress = list(re.finditer(r'([\d,]+)\s+(\d+)%\s+([\d.]+)([kMGT]?)B/s\s+', data))
copied = int(progress[-1][1].replace(',', '')) if progress else 0
phase = state['phase']
paused = (folder / 'paused').exists()
if paused:
phase = 'paused'
alive = Path('/proc/' + str(state.get('pid', -1))).exists()
if not alive and phase not in TERMINAL and time.time() - state.get('started', 0) > 10:
phase = 'interrupted'
if phase == 'complete' and 'source_write_counters_after' not in state:
phase = 'finalizing'
speed = 0
if phase == 'copying':
now = time.time()
samples = HISTORY.setdefault(str(folder), [])
samples.append((now, copied))
samples[:] = [sample for sample in samples if sample[0] >= now - 90]
elapsed = now - samples[0][0]
speed = (copied - samples[0][1]) / elapsed if elapsed >= 15 else copied / max(1, now - state.get('copy_started', now))
total = config.get('planned_copy_bytes', 0)
if phase == 'complete':
copied = total
result.append({'id': ('legacy:' if legacy else '') + folder.name,
'directories': config['directories'], 'destination': config['destination'],
'phase': phase, 'bytes': copied, 'total': total, 'speed': speed,
'eta': max(0, total - copied) / speed if speed else None,
'started': state.get('started'), 'finished': state.get('finished'),
'error': state.get('error') or state.get('reason') or state.get('cleanup_error'),
'device_id': config.get('partuuid') or config.get('fs_uuid'),
'legacy': legacy, 'uid': owner, '_folder': str(folder), '_config': config,
'source_writes_unchanged': state.get('source_writes_unchanged')})
except (OSError, ValueError, KeyError):
continue
return sorted(result, key=lambda item: item.get('started') or 0, reverse=True)
def active():
return [job for job in jobs() if job['phase'] not in TERMINAL and job['phase'] != 'interrupted']
def mount_disk(identity):
choices = [item for item in disks() if item['id'] == identity]
if len(choices) != 1:
raise ValueError('硬盘已移除或身份发生变化,请刷新')
disk = choices[0]
# Adopt the current authorized copy without remounting or moving its data.
for job in active():
config = job['_config']
if job['device_id'] == identity and os.path.ismount(config['mount']):
return {**disk, 'mount': config['mount'], 'base': str(Path(config['mount']) / config['source_root']),
'managed': False, 'busy': True}
known = mounts()
if identity in known and os.path.ismount(known[identity]['mount']):
return {**disk, **known[identity]}
if disk['filesystem'].startswith('ntfs') and disk['mountpoints']:
mount = Path(disk['mountpoints'][0])
return {**disk, 'mount': str(mount), 'base': str(mount), 'managed': False, 'busy': False}
if disk['mountpoints']:
raise ValueError('该硬盘已被其他程序挂载,请先停止使用')
device = Path(disk['device'])
target = VAR / 'mounts' / re.sub(r'[^a-zA-Z0-9_-]', '_', identity)
target.mkdir(parents=True, exist_ok=True)
if any(target.iterdir()):
raise ValueError('挂载目录不为空,已停止以保护数据')
original = command(['blockdev', '--getro', str(device)])
command(['blockdev', '--setro', str(device)])
try:
if disk['filesystem'] == 'apfs':
command([str(ROOT / 'bin/apfs-fuse'), '-o', 'ro,nodev,nosuid,noexec', str(device), str(target)])
else:
command(['ntfs-3g', '-o', 'ro,nodev,nosuid,noexec', str(device), str(target)])
if not os.path.ismount(target):
raise ValueError('无法只读挂载;加密卷或此文件系统特性可能暂不支持')
except BaseException:
if os.path.ismount(target):
command(['umount', str(target)])
if original == '0':
command(['blockdev', '--setrw', str(device)])
raise
base = target / 'root' if (target / 'root').is_dir() and (target / 'private-dir').is_dir() else target
known[identity] = {'mount': str(target), 'base': str(base), 'managed': True,
'device': str(device), 'original_ro': original, 'serial': disk['serial']}
atomic(VAR / 'mounts.json', known)
return {**disk, **known[identity]}
def destination_roots(uid):
return [path for path in Path('/').glob('vol[0-9]*')
if (path / str(uid)).is_dir() and os.path.ismount(path)]
def target_path(path, uid, must_exist=True):
resolved = Path(path).resolve(strict=must_exist)
if not any(resolved.is_relative_to(root / str(uid)) for root in destination_roots(uid)):
raise ValueError('请选择当前用户存储空间中的目标目录')
return resolved
def listing(root, relative=''):
root = root.resolve(strict=True)
path = beneath(root / relative, root)
entries = []
for entry in path.iterdir():
if entry.name.startswith('.') or entry.is_symlink() or not entry.is_dir():
continue
entries.append({'name': entry.name, 'path': str(entry.relative_to(root))})
return {'path': '' if path == root else str(path.relative_to(root)), 'entries': sorted(entries, key=lambda item: item['name'].casefold())}
def dispatch(request):
uid = int(request['uid'])
if uid < 1000:
raise ValueError('请使用飞牛管理员账号')
action = request['action']
args = request.get('args', {})
if action == 'status':
return {'disks': disks(), 'jobs': [{k: v for k, v in job.items() if not k.startswith('_')}
for job in jobs(uid)], 'version': os.environ.get('TRIM_APPVER', '0.1.0')}
if action == 'source':
disk = mount_disk(args['device'])
return {**listing(Path(disk['base']), args.get('path', '')), 'device': disk['id']}
if action == 'destinations':
if not args.get('path'):
return {'path': '', 'entries': [{'name': root.name + ' · 我的文件', 'path': str(root / str(uid))}
for root in destination_roots(uid)]}
path = target_path(args['path'], uid)
return {'path': str(path), 'entries': [{'name': item.name, 'path': str(item)}
for item in sorted(path.iterdir()) if item.is_dir() and not item.is_symlink() and not item.name.startswith('.')]}
if action == 'mkdir':
parent = target_path(args['path'], uid)
name = args['name'].strip()
if not name or name in ('.', '..') or '/' in name or '\0' in name or name.startswith('.'):
raise ValueError('文件夹名称无效')
new = parent / name
new.mkdir()
os.chown(new, uid, pwd.getpwuid(uid).pw_gid)
return {'path': str(new)}
if action == 'start':
if active():
raise ValueError('已有拷贝任务运行中,请等待完成')
disk = mount_disk(args['device'])
base = Path(disk['base'])
paths = args.get('paths', [])
if not paths or len(paths) > 100:
raise ValueError('请选择 1–100 个目录')
folders = [beneath(base / name, base) for name in paths]
if any(not folder.is_dir() or folder == base for folder in folders):
raise ValueError('请选择硬盘中的具体目录')
if len({folder.name for folder in folders}) != len(folders):
raise ValueError('所选目录存在同名项,请分开拷贝')
parents = {folder.parent for folder in folders}
if len(parents) != 1:
raise ValueError('请选择同一层级下的目录')
destination = target_path(args['destination'], uid)
command(['runuser', '-u', pwd.getpwuid(uid).pw_name, '--', 'test', '-w', str(destination)])
preview = command(['rsync', '-rltHn', '--ignore-existing', '--stats', '--protect-args',
*map(str, folders), str(destination) + '/'], timeout=120)
match = re.search(r'Total transferred file size: ([\d,]+)', preview)
if not match:
raise ValueError('无法计算拷贝大小,请稍后重试')
total = int(match[1].replace(',', ''))
available = os.statvfs(destination)
if total + 1024**3 > available.f_bavail * available.f_frsize:
raise ValueError('目标空间不足')
job = VAR / 'jobs' / (time.strftime('%Y%m%d-%H%M%S') + '-' + uuid.uuid4().hex[:6])
job.mkdir(parents=True)
config = {'mount': disk['mount'], 'source_root': str(next(iter(parents)).relative_to(disk['mount'])),
'destination': str(destination), 'partuuid': disk.get('partuuid'), 'fs_uuid': disk.get('uuid'),
'device_path': disk['device'], 'serial': disk['serial'], 'uid': uid, 'gid': pwd.getpwuid(uid).pw_gid,
'directories': [folder.name for folder in folders], 'planned_copy_bytes': total,
'original_ro': disk.get('original_ro', '0'), 'managed_mount': disk['managed'],
'filesystem': disk['filesystem'], 'selection_paths': paths}
atomic(job / 'config.json', config)
atomic(job / 'status.json', {'phase': 'preflight', 'started': time.time()})
with (job / 'worker.log').open('ab') as log:
subprocess.Popen(['/usr/bin/python3', str(ROOT / 'copy_worker.py'), str(job / 'config.json')],
stdin=subprocess.DEVNULL, stdout=log, stderr=subprocess.STDOUT, start_new_session=True)
return {'job': job.name}
if action == 'resume':
selected = next((item for item in jobs(uid) if item['id'] == args['job']), None)
if not selected or selected['legacy'] or selected['phase'] not in ('failed', 'interrupted'):
raise ValueError('此任务当前不能重试')
config = selected['_config']
return dispatch({'uid': uid, 'action': 'start', 'args': {
'device': selected['device_id'], 'paths': config['selection_paths'], 'destination': config['destination']}})
if action == 'eject':
if any(job['device_id'] == args['device'] for job in active()):
raise ValueError('硬盘仍有拷贝任务,完成后才能释放')
known = mounts()
item = known.get(args['device'])
if not item or not item['managed']:
raise ValueError('此盘由飞牛系统挂载,请在系统“外接存储”中推出')
if os.path.ismount(item['mount']):
command(['umount', item['mount']])
if item['original_ro'] == '0':
command(['blockdev', '--setrw', item['device']])
del known[args['device']]
atomic(VAR / 'mounts.json', known)
return {'released': True}
raise ValueError('未知操作')
class Handler(socketserver.StreamRequestHandler):
def handle(self):
try:
_, uid, _ = struct.unpack('3i', self.request.getsockopt(socket.SOL_SOCKET, socket.SO_PEERCRED, 12))
if uid not in (0, APP_UID):
raise ValueError('拒绝未授权本机客户端')
raw = self.rfile.readline(262145)
if len(raw) > 262144:
raise ValueError('请求过大')
request = json.loads(raw)
result = {'ok': True, 'data': dispatch(request)}
except Exception as error:
result = {'ok': False, 'error': str(error)}
self.wfile.write((json.dumps(result, ensure_ascii=False) + '\n').encode())
if __name__ == '__main__':
VAR.mkdir(exist_ok=True)
path = VAR / 'broker.sock'
path.unlink(missing_ok=True)
server = socketserver.UnixStreamServer(str(path), Handler)
os.chown(path, 0, APP_GID)
path.chmod(0o660)
signal.signal(signal.SIGTERM, lambda *_: (_ for _ in ()).throw(KeyboardInterrupt()))
try:
server.serve_forever()
except KeyboardInterrupt:
pass
finally:
server.server_close()
path.unlink(missing_ok=True)
in_use = {job['device_id'] for job in active()}
for identity, item in mounts().items():
if identity in in_use or not item.get('managed'):
continue
try:
if os.path.ismount(item['mount']):
command(['umount', item['mount']])
properties = command(['udevadm', 'info', '-q', 'property', '-n', item['device']])
if ('ID_SERIAL_SHORT=' + item['serial']) in properties.splitlines() and item['original_ro'] == '0':
command(['blockdev', '--setrw', item['device']])
except Exception:
pass
+92
查看文件
@@ -0,0 +1,92 @@
"""Unprivileged HTTP UI, reachable only through the authenticated fnOS gateway."""
import http.server
import grp
import hmac
import secrets
import json
import os
from pathlib import Path
import socket
import socketserver
import urllib.parse
ROOT = Path(__file__).resolve().parent
PREFIX = '/app/dayu-diskcopy'
VAR = Path(os.environ['TRIM_PKGVAR'])
CSRF_TOKEN = secrets.token_urlsafe(32)
class Handler(http.server.BaseHTTPRequestHandler):
def log_message(self, *args):
pass
def reply(self, status, data, mime='application/json; charset=utf-8'):
payload = data if isinstance(data, bytes) else json.dumps(data, ensure_ascii=False).encode()
self.send_response(status)
self.send_header('Content-Type', mime)
self.send_header('Content-Length', str(len(payload)))
self.send_header('Cache-Control', 'no-store')
self.send_header('X-Content-Type-Options', 'nosniff')
self.end_headers()
self.wfile.write(payload)
def handle_request(self, post=False):
try:
uid = self.headers.get('X-Trim-Userid', '')
if self.headers.get('X-Trim-Isadmin', '').lower() != 'true' or not uid.isdigit() or int(uid) < 1000:
return self.reply(403, {'error': '请从飞牛桌面使用管理员账号打开此应用'})
path = urllib.parse.urlsplit(self.path).path
if path in (PREFIX, PREFIX + '/') and not post:
page = (ROOT / 'index.html').read_bytes().replace(b'__DAYU_CSRF__', CSRF_TOKEN.encode())
return self.reply(200, page, 'text/html; charset=utf-8')
if not path.startswith(PREFIX + '/api/'):
return self.reply(404, {'error': '页面不存在'})
action = path.removeprefix(PREFIX + '/api/')
writes = {'start', 'mkdir', 'eject', 'resume'}
if post != (action in writes):
return self.reply(405, {'error': '请求方法无效'})
if post:
if self.headers.get('X-Dayu-Request') != '1':
return self.reply(403, {'error': '无效请求来源'})
# fnOS rewrites upstream Host; validate the private page nonce instead.
if not hmac.compare_digest(self.headers.get('X-Dayu-Token', ''), CSRF_TOKEN):
return self.reply(403, {'error': '页面验证已失效,请刷新应用后重试'})
if self.headers.get('Sec-Fetch-Site', '') not in ('', 'none', 'same-origin'):
return self.reply(403, {'error': '请求来源不匹配'})
length = int(self.headers.get('Content-Length', '0'))
if not 0 <= length <= 262144:
return self.reply(413, {'error': '请求过大'})
args = json.loads(self.rfile.read(length) or '{}')
else:
args = {key: value[0] for key, value in urllib.parse.parse_qs(urllib.parse.urlsplit(self.path).query).items()}
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as client:
client.settimeout(180)
client.connect(str(VAR / 'broker.sock'))
client.sendall((json.dumps({'uid': int(uid), 'action': action, 'args': args}) + '\n').encode())
with client.makefile('rb') as response:
data = json.loads(response.readline(4 * 1024 * 1024))
self.reply(200 if data['ok'] else 400, data.get('data') if data['ok'] else {'error': data['error']})
except Exception:
self.reply(500, {'error': '服务暂时不可用,请稍后刷新或在应用中心重启应用'})
def do_GET(self):
self.handle_request()
def do_POST(self):
self.handle_request(True)
class Server(socketserver.ThreadingMixIn, socketserver.UnixStreamServer):
daemon_threads = True
if __name__ == '__main__':
path = ROOT / 'app.sock'
path.unlink(missing_ok=True)
server = Server(str(path), Handler)
os.chown(path, int(os.environ['TRIM_UID']), grp.getgrnam('Administrators').gr_gid)
path.chmod(0o660)
os.setgroups([])
os.setgid(int(os.environ['TRIM_GID']))
os.setuid(int(os.environ['TRIM_UID']))
server.serve_forever()
+33
查看文件
@@ -0,0 +1,33 @@
<!doctype html>
<html lang="zh-CN">
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>大鱼硬盘拷贝</title>
<style>
:root{font:14px -apple-system,BlinkMacSystemFont,"PingFang SC",sans-serif;color:#172c39;background:#f2f5f6;--accent:#167666;--line:#e0e7e8}*{box-sizing:border-box}body{margin:0}button,select,input{font:inherit}button{cursor:pointer;border:1px solid var(--line);border-radius:9px;padding:9px 15px;background:white;color:inherit}button:hover{background:#edf5f2;border-color:#bad4ce}button:disabled{opacity:.45;cursor:default}button.primary{background:var(--accent);color:white;border-color:var(--accent);font-weight:600}button:focus-visible,input:focus-visible,select:focus-visible{outline:3px solid #4eaea1;outline-offset:2px}header{padding:29px 34px 22px;display:flex;align-items:center;gap:14px}header svg{width:44px;height:44px;flex:none}h1{font-size:22px;margin:0 0 5px;letter-spacing:.5px}header p{margin:0;color:#6c7d85;font-size:13px}.badge{margin-left:auto;font-size:12px;padding:7px 11px;border-radius:20px;background:#e3efeb;color:var(--accent);white-space:nowrap}main{max-width:1180px;margin:auto;padding:0 30px 35px}.steps{display:flex;gap:20px;margin-bottom:18px;color:#7b8a91;font-size:12px}.steps span{display:flex;align-items:center;gap:7px}.steps b{display:inline-grid;place-items:center;width:21px;height:21px;border:1px solid #c8d5d6;border-radius:50%;font-weight:500}.steps span:first-child{color:var(--accent)}.columns{display:grid;grid-template-columns:1fr 1fr;gap:18px}.card{background:#fff;border:1px solid var(--line);border-radius:14px;overflow:hidden}.cardhead{padding:20px 21px 15px;border-bottom:1px solid #edf0f1}.cardhead h2{font-size:15px;margin:0 0 6px}.muted{color:#7c8b92;font-size:12px}.cardbody{padding:16px 20px}.disk{display:flex;gap:10px;align-items:center;padding:12px;border:1px solid var(--line);border-radius:10px;margin-bottom:14px}.disk select{width:100%;border:0;background:transparent;color:#213e4b;padding:4px 0;outline:none}.disk .fs{font-size:11px;background:#edf4f2;color:var(--accent);padding:5px 7px;border-radius:5px;min-width:43px;text-align:center}.tools{display:flex;align-items:center;gap:7px;margin-bottom:10px}.tools button{font-size:12px;padding:6px 10px}.path{font-size:12px;color:#6a8088;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;flex:1;direction:rtl;text-align:left}.folders{height:280px;overflow:auto;border:1px solid #e9eeee;border-radius:9px}.row{display:flex;align-items:center;gap:8px;padding:10px 12px;border-bottom:1px solid #f0f3f3;min-height:43px}.row:last-child{border:0}.row:hover{background:#f5f9f8}.row input{accent-color:var(--accent);width:16px;height:16px}.foldericon{width:20px;color:#9cbaaf;flex:none}.row button{border:0;padding:0;background:none;text-align:left;flex:1;overflow-wrap:anywhere;line-height:1.5}.row .arrow{color:#9cabb0}.empty{padding:45px 16px;text-align:center;color:#8a999e;font-size:13px;line-height:1.8}.destination{padding:12px;margin-top:12px;background:#f3f7f6;border-radius:8px;font-size:12px;line-height:1.7;overflow-wrap:anywhere}.actions{display:flex;align-items:center;gap:12px;padding:18px 0 22px}.actions .note{font-size:12px;color:#7c8d93;flex:1}.actions button.primary{padding:11px 24px}.tasks h2{font-size:15px;margin:0}.taskhead{padding:18px 21px;display:flex;justify-content:space-between;align-items:center}.task{padding:0 21px 20px}.task+.task{border-top:1px solid var(--line);padding-top:18px}.tasktitle{display:flex;align-items:center;gap:10px;justify-content:space-between;margin-bottom:8px;font-weight:600}.state{font-size:12px;font-weight:400;color:var(--accent);white-space:nowrap}.track{height:7px;border-radius:6px;background:#eef2f2;margin:13px 0 10px;overflow:hidden}.bar{height:100%;border-radius:6px;background:#258c77;transition:width .5s}.metrics{display:flex;gap:22px;font-size:12px;color:#657f89}.taskpath{font-size:12px;color:#94a1a5;overflow-wrap:anywhere;margin-top:10px}.err{background:#fff0eb;color:#a74c30;padding:12px 15px;border-radius:9px;line-height:1.6;margin-bottom:15px;display:none}footer{color:#89999f;font-size:12px;padding-top:18px;display:flex;justify-content:space-between;gap:10px}dialog{border:0;border-radius:14px;padding:25px;box-shadow:0 20px 70px #172c3930;max-width:460px;width:90%}dialog::backdrop{background:#172c3950}dialog input{width:100%;padding:12px;border:1px solid var(--line);border-radius:8px;margin:8px 0 20px}.dialogbuttons{display:flex;justify-content:flex-end;gap:10px}@media(max-width:720px){header{padding:20px}main{padding:0 16px 25px}.columns{grid-template-columns:1fr}.badge{display:none}.folders{height:200px}.steps{gap:10px;font-size:11px}.actions{flex-wrap:wrap}.actions .note{flex-basis:100%}.metrics{gap:12px;flex-wrap:wrap}footer{display:block;line-height:1.8}}
</style>
<header><svg viewBox="0 0 48 48" aria-hidden="true"><rect width="48" height="48" rx="13" fill="#167666"/><rect x="10" y="11" width="28" height="25" rx="5" fill="none" stroke="white" stroke-width="2"/><path d="M10 27h28M16 31h2" stroke="white" stroke-width="2"/><path d="m21 18 4 4 7-7" fill="none" stroke="#9ee5c7" stroke-width="2.5"/></svg><div><h1>大鱼硬盘拷贝</h1><p>外接硬盘直连导入,拷贝在 NAS 本机完成</p></div><span class="badge">APFS · NTFS · 只读访问源盘</span></header>
<main><div class="steps"><span><b>1</b>选择源目录</span><span><b>2</b>选择存储位置</span><span><b>3</b>后台拷贝与校验</span></div><div id="error" class="err" role="alert"></div>
<div class="columns"><section class="card"><div class="cardhead"><h2>从外接硬盘拷贝</h2><div class="muted">勾选同一层级中要拷贝的目录</div></div><div class="cardbody"><div class="disk"><span id="fs" class="fs">USB</span><select id="disk" aria-label="选择外接硬盘"></select><button id="refresh" title="刷新硬盘">刷新</button></div><div class="tools"><button id="sourceUp">上一级</button><span id="sourcePath" class="path">/</span><button id="release">释放挂载</button></div><div id="sources" class="folders"><div class="empty">请选择 APFS 或 NTFS 硬盘</div></div></div></section>
<section class="card"><div class="cardhead"><h2>拷贝到 NAS</h2><div class="muted">选择你的存储空间和目标目录</div></div><div class="cardbody"><div class="disk"><span class="fs">NAS</span><div style="flex:1">我的存储空间<div class="muted" style="margin-top:4px">文件直接写入此处</div></div><button id="newFolder">新建文件夹</button></div><div class="tools"><button id="destUp">上一级</button><span id="destPath" class="path">存储空间</span></div><div id="destinations" class="folders"></div><div class="destination">当前目标:<span id="chosenDest">请选择一个目录</span></div></div></section></div>
<div class="actions"><span id="selection" class="note">尚未选择源目录。同名文件会先保留,并在复制后校验。</span><button id="start" class="primary" disabled>开始拷贝</button></div>
<section class="card tasks"><div class="taskhead"><h2>拷贝任务</h2><span class="muted">关闭窗口后仍继续运行</span></div><div id="tasks"><div class="empty">暂无拷贝任务</div></div></section>
<footer><span>不格式化、不修复源盘;保留目录、文件名和链接。</span><span id="version">大鱼硬盘拷贝</span></footer></main>
<dialog id="newDialog"><h3>新建目标文件夹</h3><form method="dialog" id="newForm"><input id="folderName" placeholder="文件夹名称" aria-label="新文件夹名称" required><div class="dialogbuttons"><button value="cancel" formnovalidate>取消</button><button class="primary" value="create">创建</button></div></form></dialog>
<script>
const API='/app/dayu-diskcopy/api/',$=id=>document.getElementById(id);
let device='',sourcePath='',destPath='',selected=new Set(),lastDisks='',busy=false,loading=false;
const states={preflight:'准备中',copying:'正在拷贝',verifying_existing:'校验已有文件',verifying_tree:'核对目录',saving_metadata:'保存扩展属性',finalizing:'正在完成',complete:'已完成',failed:'拷贝失败',needs_attention:'发现不同版本,请保留核对',cleanup_failed:'需要检查挂载状态',interrupted:'任务已中断'};
function bytes(n){if(!n)return'0 B';const u=['B','KB','MB','GB','TB'],i=Math.min(4,Math.floor(Math.log(n)/Math.log(1000)));return(n/1000**i).toFixed(i>1?1:0)+' '+u[i]}
function duration(s){if(s==null)return'估算中';if(s<60)return'不足 1 分钟';if(s<3600)return Math.ceil(s/60)+' 分钟';return Math.floor(s/3600)+' 小时 '+Math.ceil(s%3600/60)+' 分钟'}
function error(message){$('error').textContent=message||'';$('error').style.display=message?'block':'none'}
async function api(action,args={},post=false){const url=API+action+(post?'':'?'+new URLSearchParams(args));const r=await fetch(url,{method:post?'POST':'GET',headers:post?{'Content-Type':'application/json','X-Dayu-Request':'1','X-Dayu-Token':'__DAYU_CSRF__'}:{},body:post?JSON.stringify(args):undefined});const d=await r.json();if(!r.ok)throw Error(d.error||'操作失败');return d}
function button(name,fn){const b=document.createElement('button');b.textContent=name;b.onclick=fn;return b}
function folderRows(container,entries,source){container.replaceChildren();if(!entries.length){const e=document.createElement('div');e.className='empty';e.textContent=source?'当前目录下没有可选择的文件夹':'当前目录下没有子文件夹,可以直接选作目标';container.append(e);return}for(const entry of entries){const row=document.createElement('div');row.className='row';if(source){const check=document.createElement('input');check.type='checkbox';check.setAttribute('aria-label','选择 '+entry.name);check.checked=selected.has(entry.path);check.onchange=()=>{check.checked?selected.add(entry.path):selected.delete(entry.path);updateSelection()};row.append(check)}const icon=document.createElement('span');icon.className='foldericon';icon.textContent='▰';row.append(icon,button(entry.name,()=>source?browseSource(entry.path):browseDest(entry.path)));const arrow=document.createElement('span');arrow.className='arrow';arrow.textContent='›';row.append(arrow);container.append(row)}}
function updateSelection(){$('selection').textContent=selected.size?'已选 '+selected.size+' 个目录。同名文件会先保留,并在复制后校验。':'尚未选择源目录。同名文件会先保留,并在复制后校验。';$('start').disabled=!selected.size||!destPath||busy||loading}
async function browseSource(path=''){if(!device)return;try{loading=true;updateSelection();const d=await api('source',{device,path});sourcePath=d.path;selected.clear();$('sourcePath').textContent='/'+sourcePath;$('sourceUp').disabled=!sourcePath;folderRows($('sources'),d.entries,true);error()}catch(e){error(e.message)}finally{loading=false;updateSelection()}}
async function browseDest(path=''){try{const d=await api('destinations',{path});destPath=d.path;$('destPath').textContent=destPath||'存储空间';$('chosenDest').textContent=destPath||'请选择一个目录';folderRows($('destinations'),d.entries,false);updateSelection();error()}catch(e){error(e.message)}}
function renderJobs(jobs){busy=jobs.some(j=>!['complete','failed','needs_attention','cleanup_failed','interrupted','cancelled'].includes(j.phase));$('tasks').replaceChildren();if(!jobs.length){const e=document.createElement('div');e.className='empty';e.textContent='暂无拷贝任务';$('tasks').append(e)}for(const job of jobs.slice(0,10)){const box=document.createElement('div');box.className='task';const title=document.createElement('div');title.className='tasktitle';const name=document.createElement('span');name.textContent=job.directories.join('、');const state=document.createElement('span');state.className='state';state.textContent=states[job.phase]||job.phase;title.append(name,state);const track=document.createElement('div');track.className='track';const bar=document.createElement('div');bar.className='bar';bar.style.width=(job.phase==='complete'?100:Math.min(100,job.total?job.bytes/job.total*100:0))+'%';track.append(bar);const metrics=document.createElement('div');metrics.className='metrics';for(const value of [bytes(job.bytes)+' / '+bytes(job.total),job.phase==='copying'?bytes(job.speed)+'/s':'',job.phase==='copying'?'预计剩余 '+duration(job.eta):job.phase==='complete'?'文件与目录核验通过':'']){if(value){const e=document.createElement('span');e.textContent=value;metrics.append(e)}}const path=document.createElement('div');path.className='taskpath';path.textContent=job.destination;box.append(title,track,metrics,path);if(job.error){const e=document.createElement('div');e.className='taskpath';e.style.color='#a74c30';e.textContent=job.error;box.append(e)}if(!job.legacy&&['failed','interrupted'].includes(job.phase))box.append(button('继续此任务',async()=>{try{await api('resume',{job:job.id},true);await refresh()}catch(e){error(e.message)}}));$('tasks').append(box)}updateSelection()}
async function refresh(){try{const d=await api('status');$('version').textContent='大鱼硬盘拷贝 '+d.version;const signature=JSON.stringify(d.disks.map(x=>[x.id,x.filesystem]));if(signature!==lastDisks){lastDisks=signature;$('disk').replaceChildren();for(const disk of d.disks){const option=document.createElement('option');option.value=disk.id;option.textContent=disk.model+' · '+bytes(disk.size)+' · '+disk.filesystem.toUpperCase();$('disk').append(option)}if(!d.disks.length){const o=document.createElement('option');o.textContent='未发现 APFS 或 NTFS 外接硬盘';$('disk').append(o);device=''}else if(!d.disks.some(x=>x.id===device)){device=d.disks[0].id;$('disk').value=device;await browseSource()}$('fs').textContent=(d.disks.find(x=>x.id===device)?.filesystem||'USB').toUpperCase()}renderJobs(d.jobs)}catch(e){error(e.message)}}
$('disk').onchange=()=>{device=$('disk').value;$('fs').textContent=$('disk').selectedOptions[0]?.textContent.split(' · ').at(-1)||'USB';browseSource()};$('refresh').onclick=refresh;$('sourceUp').onclick=()=>browseSource(sourcePath.split('/').slice(0,-1).join('/'));$('destUp').onclick=()=>{const up=destPath.split('/').slice(0,-1).join('/');browseDest(/^\/vol\d+\/\d+/.test(up)?up:'')};$('start').onclick=async()=>{try{loading=true;updateSelection();await api('start',{device,paths:[...selected],destination:destPath},true);selected.clear();for(const c of document.querySelectorAll('#sources input'))c.checked=false;error();await refresh()}catch(e){error(e.message)}finally{loading=false;updateSelection()}};$('release').onclick=async()=>{try{await api('eject',{device},true);error('已释放应用挂载;拔盘前仍请在飞牛系统中推出整块硬盘');await refresh()}catch(e){error(e.message)}};$('newFolder').onclick=()=>{if(!destPath)return error('请先选择一个存储空间或目录');$('folderName').value='';$('newDialog').showModal()};$('newForm').onsubmit=async e=>{if(e.submitter?.value!=='create')return;e.preventDefault();try{const d=await api('mkdir',{path:destPath,name:$('folderName').value},true);$('newDialog').close();await browseDest(d.path)}catch(err){error(err.message)}};
browseDest();refresh();setInterval(refresh,2500);
</script></html>
+58
查看文件
@@ -0,0 +1,58 @@
"""fnOS lifecycle controller. Stops only the two service processes, not copy jobs."""
import json
import os
from pathlib import Path
import signal
import subprocess
import sys
import time
ROOT = Path(__file__).resolve().parent
VAR = Path(os.environ['TRIM_PKGVAR'])
STATE = VAR / 'services.json'
def alive(pid, script):
try:
return str(ROOT / script).encode() in (Path('/proc') / str(pid) / 'cmdline').read_bytes()
except OSError:
return False
def main():
action = sys.argv[1]
VAR.mkdir(parents=True, exist_ok=True)
os.chown(VAR, 0, int(os.environ['TRIM_GID']))
VAR.chmod(0o750)
records = json.loads(STATE.read_text()) if STATE.exists() else {}
if action == 'status':
raise SystemExit(0 if all(alive(records.get(name, -1), name) for name in ('broker.py', 'front.py')) else 3)
if action == 'stop':
for script, pid in records.items():
if alive(pid, script):
os.kill(pid, signal.SIGTERM)
for _ in range(30):
if not any(alive(pid, script) for script, pid in records.items()):
break
time.sleep(.1)
STATE.unlink(missing_ok=True)
return
if action != 'start':
raise SystemExit(1)
for script in ('broker.py', 'front.py'):
if alive(records.get(script, -1), script):
continue
with (VAR / 'service.log').open('ab') as log:
process = subprocess.Popen(['/usr/bin/python3', str(ROOT / script)],
stdin=subprocess.DEVNULL, stdout=log, stderr=subprocess.STDOUT, start_new_session=True)
records[script] = process.pid
STATE.write_text(json.dumps(records))
for _ in range(50):
if (ROOT / 'app.sock').exists() and (VAR / 'broker.sock').exists():
return
time.sleep(.1)
raise SystemExit('服务启动失败,请查看应用日志')
if __name__ == '__main__':
main()
+1
查看文件
@@ -0,0 +1 @@
{".url":{"dayu-diskcopy.main":{"title":"大鱼硬盘拷贝","icon":"images/icon_{0}.png","type":"iframe","protocol":"","gatewayPrefix":"/app/dayu-diskcopy","gatewaySocket":"app.sock","url":"/app/dayu-diskcopy","allUsers":false,"control":{"accessPerm":"readonly"}}}}
+3
查看文件
@@ -0,0 +1,3 @@
#!/bin/bash
set -euo pipefail
exit 0
+3
查看文件
@@ -0,0 +1,3 @@
#!/bin/bash
set -euo pipefail
exit 0
+3
查看文件
@@ -0,0 +1,3 @@
#!/bin/bash
set -euo pipefail
exit 0
+9
查看文件
@@ -0,0 +1,9 @@
#!/bin/bash
set -euo pipefail
for program in python3 rsync ntfs-3g; do
if ! command -v "$program" >/dev/null; then
printf '系统缺少运行组件:%s\n' "$program" > "$TRIM_TEMP_LOGFILE"
exit 1
fi
done
exit 0
+3
查看文件
@@ -0,0 +1,3 @@
#!/bin/bash
set -euo pipefail
exec /usr/bin/python3 "$TRIM_APPDEST/service.py" "$1"
+3
查看文件
@@ -0,0 +1,3 @@
#!/bin/bash
set -euo pipefail
exit 0
+10
查看文件
@@ -0,0 +1,10 @@
#!/bin/bash
set -euo pipefail
if test -f "$TRIM_APPDEST/service.py"; then
if ! /usr/bin/python3 -c 'import sys; sys.path.insert(0, sys.argv[1]); import broker; sys.exit(1 if broker.active() else 0)' "$TRIM_APPDEST"; then
printf '仍有拷贝任务正在运行,请等待完成后再卸载。\n' > "$TRIM_TEMP_LOGFILE"
exit 1
fi
/usr/bin/python3 "$TRIM_APPDEST/service.py" stop
fi
exit 0
+3
查看文件
@@ -0,0 +1,3 @@
#!/bin/bash
set -euo pipefail
exit 0
+3
查看文件
@@ -0,0 +1,3 @@
#!/bin/bash
set -euo pipefail
exit 0
+1
查看文件
@@ -0,0 +1 @@
{"defaults":{"run-as":"root"},"username":"dayu_diskcopy","groupname":"dayu_diskcopy"}
+1
查看文件
@@ -0,0 +1 @@
{}
+16
查看文件
@@ -0,0 +1,16 @@
appname=dayu-diskcopy
version=0.1.4
display_name=大鱼硬盘拷贝
desc=直接读取 APFS、NTFS 外接硬盘,在飞牛 NAS 本机后台拷贝目录、查看进度和校验结果。
source=thirdparty
platform=x86
maintainer=大鱼
maintainer_url=https://dayu.media
distributor=大鱼
os_min_version=1.2.0701
desktop_uidir=ui
desktop_applaunchname=dayu-diskcopy.main
ctl_stop=true
checkport=false
disable_authorization_path=false
changelog=首版:APFS 与 NTFS 只读访问、目录选择、后台复制、进度与校验。
+18
查看文件
@@ -0,0 +1,18 @@
大鱼硬盘拷贝 0.1.4,飞牛 fnOS x86 原生应用。支持 APFS / NTFS 外接硬盘识别、目录选择、NAS 本机后台复制、进度与校验、部分文件续传和失败重试。
- 已在 fnOS 1.2.0701 安装验证;使用飞牛管理员登录态,Web 进程降权运行,不开放新的 TCP 服务端口。
- 新挂载的源盘只读访问;系统已挂载的 NTFS 优先复用。保留既有文件,不自动覆盖不同版本。APFS 扩展属性另存为私有元数据存档。
- APFS:真实 USB 盘约 501 GB 新增复制、64 个旧文件校验、目录比对、界面实际复制与续传均通过;源分区写计数为零。
- NTFS:只读镜像挂载与复制 SHA-256 核对通过;尚未进行实体 NTFS USB 盘测试。首版不承诺加密 APFS 或所有 APFS 新特性兼容。
- 九项身份、路径、跨站请求与任务状态边界测试通过。
安装:在飞牛网页应用中心选择“手动安装”,先点击“从电脑上传”,再选择 FPK。安装更新后打开桌面“大鱼硬盘拷贝”。第三方应用免责提示由用户确认;本次用户已明确同意相同条款。
唯一安装入口:/var/apps/dayu-diskcopy(实际 target 位于存储空间 3)。包由官方 fnpack 1.2.3 生成,通过格式、安装更新与运行校验;未上架飞牛官方商店。
实际编译源码:72d678fa03dc730e44d4e53988ea86a88aec6a0f
安装包:dayu-diskcopy-0.1.4-x86.fpk
字节数:564939
SHA-256:cc761c2c62510674bbed60133ec042732dd84477806f0f6550cc97bf50205307
完整源码、上游许可证与对应 APFS/LZFSE 源码随仓库及 FPK 保存;不含用户媒体、账号凭据或私有任务清单。最终验证和恢复记录保存在 main 分支 verification/ 与 HANDOFF.md。
+80
查看文件
@@ -0,0 +1,80 @@
#!/usr/bin/env python3
"""Build a self-contained native fnOS FPK with the validated Linux driver."""
from pathlib import Path
import hashlib
import json
import os
import shutil
import struct
import subprocess
import sys
import zlib
ROOT = Path(__file__).resolve().parent.parent
stage = ROOT / 'build/fpk'
if stage.exists():
shutil.rmtree(stage)
shutil.copytree(ROOT / 'packaging/fpk', stage)
(stage / 'wizard').mkdir(exist_ok=True)
(stage / 'wizard/.gitkeep').touch()
app = stage / 'app'
for path in (ROOT / 'application').iterdir():
if path.is_file():
shutil.copy2(path, app / path.name)
shutil.copy2(ROOT / 'scripts/copy-directories.py', app / 'copy_worker.py')
shutil.copy2(ROOT / 'scripts/save-xattrs.py', app / 'save_xattrs.py')
(app / 'bin').mkdir()
for name, expected in [('apfs-fuse','89a7083c42fb498b021d9f7fabbc5b754eaae503649500e4926965fdcfbcb11e'),
('apfsutil','692bbd961678c5db1a48e00cb2bc96c50e82dd77e39d87cfe11087608b4658ae')]:
binary = ROOT / 'build/linux-bin' / name
if hashlib.sha256(binary.read_bytes()).hexdigest() != expected:
raise SystemExit('Driver hash mismatch: ' + name)
shutil.copy2(binary, app / 'bin' / name)
(app / 'bin' / name).chmod(0o755)
shutil.copytree(ROOT / 'vendor/apfs-fuse', app / 'source/apfs-fuse')
shutil.copy2(ROOT / 'UPSTREAM.json', app / 'source/UPSTREAM.json')
shutil.copy2(ROOT / 'packaging/Dockerfile', app / 'source/Dockerfile')
for path in (stage / 'cmd').iterdir():
path.chmod(0o755)
def icon(size):
def chunk(kind, payload):
return struct.pack('>I', len(payload)) + kind + payload + struct.pack('>I', zlib.crc32(kind + payload) & 0xffffffff)
rows = []
for y in range(size):
row = bytearray()
for x in range(size):
px, py = x * 256 / size, y * 256 / size
radius = 50
dx, dy = max(abs(px - 128) - 78, 0), max(abs(py - 128) - 78, 0)
inside = dx * dx + dy * dy <= radius * radius
color = (22, 118, 102, 255) if inside else (0, 0, 0, 0)
if 53 <= px <= 203 and 62 <= py <= 192 and (px < 63 or px > 193 or py < 72 or py > 182 or 144 < py < 153):
color = (255, 255, 255, 255)
if 78 <= px <= 90 and 164 <= py <= 172:
color = (255, 255, 255, 255)
if 100 <= px <= 126 and abs(py - (px - 3)) < 5 or 122 <= px <= 165 and abs(py - (249 - px)) < 5:
color = (158, 229, 199, 255)
row.extend(color)
rows.append(b'\0' + row)
return b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', size, size, 8, 6, 0, 0, 0)) + chunk(b'IDAT', zlib.compress(b''.join(rows))) + chunk(b'IEND', b'')
images = app / 'ui/images'
images.mkdir(exist_ok=True)
for size in (64, 256):
payload = icon(size)
(images / ('icon_' + str(size) + '.png')).write_bytes(payload)
(stage / ('ICON.PNG' if size == 64 else 'ICON_256.PNG')).write_bytes(payload)
subprocess.run([sys.argv[1], 'build', '--directory', str(stage)], cwd=stage, check=True)
output = ROOT / 'dist'
output.mkdir(exist_ok=True)
packages = list(stage.glob('*.fpk'))
if len(packages) != 1:
raise SystemExit('Expected one FPK package')
version = next(line.split('=',1)[1].strip() for line in (stage / 'manifest').read_text().splitlines() if line.startswith('version='))
destination = output / ('dayu-diskcopy-' + version + '-x86.fpk')
shutil.copy2(packages[0], destination)
print(destination)
print('sha256:', hashlib.sha256(destination.read_bytes()).hexdigest())
+131
查看文件
@@ -0,0 +1,131 @@
#!/usr/bin/env python3
"""NAS-local copy job with read-only source, resumable rsync and status records.
Config and file-name manifests stay on the NAS; never commit user data to Git.
Existing files are retained during copying and checksum-checked afterwards.
"""
import fcntl
import json
import os
from pathlib import Path
import stat
import subprocess
import sys
import time
import traceback
def main():
config_path = Path(sys.argv[1]).resolve(strict=True)
job = config_path.parent
config = json.loads(config_path.read_text())
mount = Path(config['mount'])
source = mount / config['source_root']
destination = Path(config['destination']).resolve(strict=True)
device = Path(config['device_path']).resolve(strict=True) if config.get('device_path') else (Path('/dev/disk/by-partuuid') / config['partuuid']).resolve(strict=True)
managed = config.get('managed_mount', True)
os.environ['LC_ALL'] = 'C'
lock = (job.parent.parent / 'transfer.lock').open('a')
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
state = {'pid': os.getpid(), 'started': time.time(), 'phase': 'preflight',
'planned_copy_bytes': config['planned_copy_bytes'], 'directories': config['directories']}
def save(phase, **extra):
state.update(phase=phase, updated=time.time(), **extra)
temporary = job / 'status.tmp'
temporary.write_text(json.dumps(state, ensure_ascii=False, indent=2) + '\n')
temporary.replace(job / 'status.json')
def run_to_log(args, log_name):
with (job / log_name).open('wb') as log:
return subprocess.run(args, stdout=log, stderr=subprocess.STDOUT).returncode
save('preflight')
try:
properties = dict(line.split('=', 1) for line in subprocess.check_output(
['udevadm', 'info', '-q', 'property', '-n', str(device)], text=True).splitlines() if '=' in line)
if properties.get('ID_SERIAL_SHORT') != config['serial'] or properties.get('ID_BUS') != 'usb':
raise RuntimeError('USB device identity changed.')
if not os.path.ismount(mount):
raise RuntimeError('Source is not mounted.')
mounted = json.loads(subprocess.check_output(
['findmnt', '-J', '-M', str(mount), '-o', 'SOURCE,OPTIONS'], text=True))['filesystems'][0]
if Path(mounted['source']).resolve() != device or (managed and 'ro' not in mounted['options'].split(',')):
raise RuntimeError('Unexpected source mount or source is not read-only.')
if managed and subprocess.check_output(['blockdev', '--getro', str(device)], text=True).strip() != '1':
raise RuntimeError('Block device is not read-only.')
writes_before = (Path('/sys/class/block') / device.name / 'stat').read_text().split()[4:8:2]
state['source_write_counters_before'] = writes_before
available = os.statvfs(destination)
if available.f_bavail * available.f_frsize < config['planned_copy_bytes'] + 1024**3:
raise RuntimeError('Insufficient destination free space.')
existing = []
for name in config['directories']:
folder = source / name
if folder.is_symlink() or not folder.is_dir():
raise RuntimeError('Expected source directory missing or linked.')
for base, dirs, files in os.walk(folder, followlinks=False, onerror=lambda e: (_ for _ in ()).throw(e)):
for filename in files:
entry = Path(base) / filename
relative = entry.relative_to(source)
target = destination / relative
if os.path.lexists(target):
existing.append(os.fsencode(relative))
(job / 'existing-files.list').write_bytes(b'\0'.join(existing) + (b'\0' if existing else b''))
save('copying', existing_files_to_verify=len(existing), copy_started=time.time())
source_args = [str(source / name) for name in config['directories']]
command = ['rsync', '-rltH', '--chown=' + str(config.get('uid', 1000)) + ':' + str(config.get('gid', 1001)), '--ignore-existing', '--partial', '--no-whole-file',
'--partial-dir=.dayu-apfs-partial', '--info=progress2,stats2', '--outbuf=L',
'--stats', '--no-inc-recursive', '--protect-args', *source_args, str(destination) + '/']
result = run_to_log(command, 'copy.log')
if result:
raise RuntimeError('rsync copy exited with status ' + str(result))
save('verifying_existing', copy_finished=time.time())
if existing:
result = run_to_log(['rsync', '-rcnli', '--from0',
'--files-from=' + str(job / 'existing-files.list'),
'--out-format=%i %n%L', '--protect-args',
str(source) + '/', str(destination) + '/'], 'existing-check.log')
if result:
raise RuntimeError('Existing-file checksum check failed: ' + str(result))
changes = (job / 'existing-check.log').read_text().strip()
if changes:
save('needs_attention', reason='Existing destination files differ; retained unchanged.',
mismatch_log=str(job / 'existing-check.log'))
return
save('verifying_tree')
# Existing files keep their original metadata. Their contents were fully
# checksum-checked above, so a different mtime alone is not a copy failure.
result = run_to_log(['rsync', '-rlHni', '--size-only', '--out-format=%i %n%L', '--protect-args',
*source_args, str(destination) + '/'], 'tree-check.log')
if result or (job / 'tree-check.log').read_text().strip():
raise RuntimeError('Final directory comparison found differences; see tree-check.log.')
subprocess.run(['sync', '-f', str(destination)], check=True)
metadata_helper = Path(__file__).with_name('save_xattrs.py')
if config.get('filesystem') == 'apfs' and metadata_helper.exists():
save('saving_metadata')
metadata_target = destination / ('.dayu-diskcopy-metadata-' + job.name)
result = run_to_log(['/usr/bin/python3', str(metadata_helper), str(config_path), str(metadata_target)], 'metadata-summary.json')
if result:
raise RuntimeError('File copy passed but extended attribute archive failed.')
save('complete', finished=time.time(), existing_files_checksum_match=True,
new_files_verified_by_rsync_transfer_checksums=True)
except BaseException as error:
save('failed', error=str(error), finished=time.time())
traceback.print_exc()
finally:
try:
if managed and os.path.ismount(mount):
subprocess.run(['umount', str(mount)], check=True, timeout=60)
if managed and config['original_ro'] == '0':
subprocess.run(['blockdev', '--setrw', str(device)], check=True)
writes_after = (Path('/sys/class/block') / device.name / 'stat').read_text().split()[4:8:2]
save(state['phase'], unmounted=managed and not os.path.ismount(mount), source_write_counters_after=writes_after,
source_writes_unchanged=writes_after == state.get('source_write_counters_before'))
except BaseException as error:
save('cleanup_failed', prior_phase=state['phase'], cleanup_error=str(error))
fcntl.flock(lock, fcntl.LOCK_UN)
if __name__ == '__main__':
main()
+57
查看文件
@@ -0,0 +1,57 @@
#!/usr/bin/env python3
"""Archive macOS extended attributes beside a NAS backup, without applying them.
Attribute values may contain private user information. Output stays on the NAS.
"""
import base64
import collections
import json
import os
from pathlib import Path
import sys
def main():
config = json.loads(Path(sys.argv[1]).read_text())
uid, gid = config.get('uid', 1000), config.get('gid', 1001)
source = Path(config['mount']) / config['source_root']
destination = Path(sys.argv[2])
destination.mkdir(mode=0o700)
os.chown(destination, uid, gid)
count = collections.Counter()
entries = 0
output = destination / 'extended-attributes.jsonl'
fd = os.open(output, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
with os.fdopen(fd, 'w') as stream:
for name in config['directories']:
folder = source / name
paths = [folder]
for base, dirs, files in os.walk(folder, followlinks=False,
onerror=lambda e: (_ for _ in ()).throw(e)):
paths.extend(Path(base) / item for item in dirs + files)
for path in paths:
attributes = {}
for key in os.listxattr(path, follow_symlinks=False):
value = os.getxattr(path, key, follow_symlinks=False)
attributes[key] = base64.b64encode(value).decode('ascii')
count[key] += 1
if attributes:
stream.write(json.dumps({'path': str(path.relative_to(source)),
'attributes_base64': attributes}, ensure_ascii=False) + '\n')
entries += 1
stream.flush()
os.fsync(stream.fileno())
os.chown(output, uid, gid)
summary = {'entries': entries, 'attribute_names': dict(count), 'bytes': output.stat().st_size,
'resource_fork_attributes': count['com.apple.ResourceFork']}
(destination / 'README.txt').write_text(
'这是 APFS 源目录的 macOS 扩展属性原始存档,不包含普通文件的数据内容。\n'
'extended-attributes.jsonl 每行记录相对路径与 Base64 编码的原始属性。\n'
'包含用户标签、Finder 信息和机器相关安全元数据,请随剪辑备份私下保管,不上传源码仓库。\n'
'普通文件已由 rsync 复制;还原至 Mac 时应按需使用这些属性,不要盲目重放机器相关属性。\n')
os.chown(destination / 'README.txt', uid, gid)
print(json.dumps(summary, ensure_ascii=False))
if __name__ == '__main__':
main()
+22
查看文件
@@ -0,0 +1,22 @@
{
"date": "2026-11-11",
"tested_app_version": "0.1.3",
"native_gateway_admin_login": true,
"ui_create_destination_folder": true,
"ui_start_copy": true,
"file_bytes": 404309,
"partial_basis_matched_bytes": 99400,
"file_sha256_matches_reference": true,
"existing_file_different_mtime_preserved_and_checksum_passed": true,
"all_jobs_complete": true,
"all_jobs_source_writes_unchanged": true,
"all_jobs_unmounted": true,
"version": "0.1.4",
"all_three_test_jobs_complete": true,
"existing_mtime_preserved": true,
"real_copy_history_migrated": true,
"test_copies_and_test_jobs_cleaned": true,
"final_tested_app_version": "0.1.4",
"final_ui_copy_and_checksum_passed": true,
"final_checkbox_state_correct": true
}
@@ -0,0 +1,26 @@
{
"date": "2026-11-11",
"directories": [
"火影秋决",
"LCQ荒野乱斗"
],
"destination": "/vol5/1000/剪辑盘备份",
"status": "complete",
"logical_source_file_bytes": 548102817612,
"newly_copied_bytes": 501332211263,
"copy_seconds": 2197.872,
"average_copy_MB_per_second": 228.099,
"existing_files_checksum_verified": 64,
"existing_checksum_differences": 0,
"directory_differences": 0,
"new_files_verified_by_rsync_stream_checksums": true,
"independent_full_new_file_readback_performed": false,
"source_writes_unchanged": true,
"source_unmounted": true,
"original_readonly_flag_restored": true,
"destination_syncfs_passed": true,
"destination_user_access_checked": true,
"metadata_archive_entries": 7374,
"metadata_archive_bytes": 1690603,
"source_worker_commit": "604fce4fecc5d4a8ea5f830d653ced830bcc37d7"
}
@@ -0,0 +1,20 @@
{
"installed_version": "0.1.4",
"unique_entry": "/var/apps/dayu-diskcopy",
"prototype_directory_removed": true,
"no_legacy_mounts": true,
"test_directories_removed": true,
"payload": {
"broker.py": "37b88e7b3b1c7a70ddea618a5dad8a7d8153c008bf20ee12f7cab339dc6be2f7",
"front.py": "748fc8789e09d15cbc839f08778a5cf96d162b0fba66d9d052b6fd34d46aac9b",
"service.py": "eb393823c5f6b7da8ef04acf81c61146cab202d0cb74200fc7c6166480af6e8d",
"index.html": "96f7f5df4b720508244b4ac215e3ae6ae48001e1554218b30b4c3d4c1a7af081",
"copy_worker.py": "50fb5fdb188ae58a66f7b8e4a3a236c0d49849cd7ce8feb553a60632d8adba6c",
"save_xattrs.py": "ee5df34e92b7c89ae1029da0e23314b576dfdf6dc5581089d2e049bd86071b8f",
"bin/apfs-fuse": "89a7083c42fb498b021d9f7fabbc5b754eaae503649500e4926965fdcfbcb11e",
"bin/apfsutil": "692bbd961678c5db1a48e00cb2bc96c50e82dd77e39d87cfe11087608b4658ae"
},
"installed_payload_matches_source_and_validated_drivers": true,
"source_code_commit": "72d678fa03dc730e44d4e53988ea86a88aec6a0f",
"fpk_sha256": "cc761c2c62510674bbed60133ec042732dd84477806f0f6550cc97bf50205307"
}
+7
查看文件
@@ -0,0 +1,7 @@
{
"ntfs_image_readonly_mount": true,
"copied_bytes": 1048576,
"source_and_copy_sha256_match": true,
"sha256": "fbbab289f7f94b25736c58be46a994c441fd02552cc6022352e3d86d2fab7c83",
"hardware_ntfs_usb_tested": false
}
+16
查看文件
@@ -0,0 +1,16 @@
{
"app_status": "running",
"source_partition_ro_flags": {
"5b255495-2ba8-4e49-8774-227d8dd8878f": "0",
"d6bd791c-7bee-486b-8fef-6cf584381a55": "0"
},
"process_uids": {
"broker.py": 0,
"front.py": 985
},
"socket_modes": {
"gateway": "0o660",
"broker": "0o660"
},
"completed_history_persisted": true
}
+45
查看文件
@@ -0,0 +1,45 @@
{
"status": "complete",
"job": "20261112-000934-7eab85",
"threshold_bytes": 50000000000,
"scope": "visible top-level directories including descendants",
"source_identity": "d6bd791c-7bee-486b-8fef-6cf584381a55",
"qualifying_directories": 11,
"previously_complete_and_tree_rechecked": 2,
"new_directories": 9,
"planned_copy_bytes": 781417428219,
"existing_destination_files_to_verify": 0,
"destination": "/vol5/1000/剪辑盘备份",
"native_app_task_visible": true,
"private_inventory_on_nas_only": true,
"source_mounted_readonly": true,
"periodic_speed_reports_disabled_per_user": true,
"rsync_exit": 23,
"regular_files_transferred_before_recovery": 401182,
"bytes_transferred_before_recovery": 781409293913,
"reported_untransferred_files": 8,
"reported_untransferred_bytes": 8134306,
"source_writes_unchanged": true,
"initial_worker_source_unmounted": true,
"copied_bytes": 781417428219,
"regular_files": 401190,
"symbolic_links": 2585,
"portable_files_transferred_by_rsync": 401182,
"portable_bytes_transferred_by_rsync": 781409293913,
"nonportable_files_recovered": 8,
"recovered_bytes": 8134306,
"recovery_method": "user_selected_destination_name_shortening_with_csv_json_mapping",
"all_recovered_file_sha256_readback_matches": true,
"portable_entries_size_and_links_checked": 457268,
"portable_differences": 0,
"app_history_complete_with_rename_notice": true,
"source_unmounted": true,
"source_block_ro_restored": 0,
"extended_attributes_archive_entries": 453582,
"extended_attributes_archive_bytes": 91456093,
"resource_fork_attributes_archived": 309,
"destination_sync_passed": true,
"user_access_verified": true,
"whole_backup_extra_full_sha256_readback_claimed": false,
"automatic_portability_handling_in_fpk": false
}
+15
查看文件
@@ -0,0 +1,15 @@
{
"date": "2026-11-12",
"app_version": "0.1.4",
"service_status": "running",
"gateway_upstream_http": 200,
"desktop_click_opens_iframe": true,
"desktop_double_click_opens_iframe": true,
"appcenter_open_activates_iframe": true,
"frame_ready_state": "complete",
"usb_apfs_disks_visible": 2,
"completed_job_visible": true,
"javascript_errors": [],
"user_confirmed_now_opens": true,
"code_change_required": false
}
+11
查看文件
@@ -0,0 +1,11 @@
{
"remote_clone_verified": true,
"tag": "v0.1.4",
"commit": "72d678fa03dc730e44d4e53988ea86a88aec6a0f",
"tracked_files": 139,
"validated_drivers_recovered_from_fully_downloaded_release": true,
"source_rebuild_fpk_passed": true,
"recovered_application_payload_matches_final_install": true,
"temporary_restore_clone_removed": true,
"bit_identical_archive_reproduction_not_claimed": true
}
+23
查看文件
@@ -0,0 +1,23 @@
{
"passResult": true,
"repository": "dayu/fnos-apfs",
"repositoryID": 61,
"private": true,
"tag": "v0.1.4",
"releaseCommit": "72d678fa03dc730e44d4e53988ea86a88aec6a0f",
"releaseID": 432,
"releaseURL": "https://dayu.media/git/dayu/fnos-apfs/releases/tag/v0.1.4",
"assetID": 71,
"assetName": "dayu-diskcopy-0.1.4-x86.fpk",
"downloadURL": "https://dayu.media/git/dayu/fnos-apfs/releases/download/v0.1.4/dayu-diskcopy-0.1.4-x86.fpk",
"bytes": 564939,
"sha256": "cc761c2c62510674bbed60133ec042732dd84477806f0f6550cc97bf50205307",
"draft_full_browser_download_verified": true,
"published_full_browser_download_verified": true,
"published_downloaded_file": "/Volumes/备份/dayu-diskcopy-0.1.4-x86 (1).fpk",
"credentialSource": "macOS Keychain: dayu-git-api",
"verification": "Existing authenticated Microsoft Edge browser session: complete draft and published downloads; exact byte count and SHA-256; API release/asset read-back and remote tag verified.",
"private_download_requires_web_login": true,
"api_token_web_download_status": 404,
"temporary_browser_download_copies_removed_after_verification": true
}
@@ -0,0 +1,10 @@
{
"asset_id": 71,
"release_id": 432,
"url": "https://dayu.media/git/dayu/fnos-apfs/releases/download/v0.1.4/dayu-diskcopy-0.1.4-x86.fpk",
"download_method": "Existing authenticated Microsoft Edge browser session; download item visibly completed.",
"downloaded_file": "/Volumes/备份/dayu-diskcopy-0.1.4-x86.fpk",
"bytes": 564939,
"sha256": "cc761c2c62510674bbed60133ec042732dd84477806f0f6550cc97bf50205307",
"full_download_verified_before_publication": true
}