pcb项目接口

This commit is contained in:
lxp
2026-11-04 17:35:31 +08:00
parent a64c878ff1
commit ed7920c9f6
25 changed files with 1651 additions and 6 deletions
+8
View File
@@ -30,6 +30,10 @@ URDF_MAX_TOTAL_BYTES=209715200
URDF_MAX_FILES=500
# 管理端四类项目资源直传签名有效期;不设置应用层文件大小、数量及总量配额。
PROJECT_RESOURCE_SIGNATURE_VALIDITY=1h
# PCB 工程 ZIP 直传独立开关,共用上述 OSS 连接及环境根目录。
PCB_OSS_ENABLED=false
PCB_MAX_FILE_BYTES=268435456
PCB_UPLOAD_VALIDITY=15m
# AI 默认关闭;启用后密钥仅在后端使用。两个环境均支持这些变量。
AI_ENABLED=false
ARK_API_KEY=''
@@ -88,6 +92,10 @@ RATE_FORK_PER_MINUTE=10
RATE_FILE_WRITE_PER_MINUTE=10
RATE_COVER_SIGN_PER_MINUTE=30
RATE_URDF_SIGN_PER_MINUTE=20
RATE_PCB_CREATE_PER_MINUTE=5
RATE_PCB_SIGN_PER_MINUTE=20
RATE_PCB_SAVE_PER_MINUTE=30
RATE_PCB_READ_PER_MINUTE=60
RATE_COMMENT_PER_MINUTE=10
RATE_LIKE_PER_MINUTE=60
+3 -1
View File
@@ -103,7 +103,9 @@ SPRING_PROFILES_ACTIVE=prod java -Djava.awt.headless=true -jar vibemake-api/targ
mvn clean verify
```
普通测试固定使用 test 配置,覆盖连接为临时 H2 MySQL 模式及模拟 Gitea/AI/OSS,验证登录、权限、提交冲突、发布快照、Fork、评论、点赞、URDF 直传核验和独立复制,以及 AI 筛选、引用校验、创建、Fork 与候选选择、SSE、限流、超时和取消,不访问真实数据库、仓库、对象存储或模型。未加载外部服务凭据时,执行 `AI_ENABLED=false VIBEMAKE_AI_ENABLED=false OSS_ENABLED=false mvn verify`;其中 `VIBEMAKE_AI_ENABLED` 用于覆盖管理端当前固定开启的 AI 配置,AI 流程测试自行启用模拟模型。完整安装验证可执行 `AI_ENABLED=false VIBEMAKE_AI_ENABLED=false OSS_ENABLED=false mvn clean install`。
普通测试固定使用 test 配置,覆盖连接为临时 H2 MySQL 模式及模拟 Gitea/AI/OSS,验证登录、权限、提交冲突、发布快照、Fork、评论、点赞、URDF 直传核验和独立复制,以及 AI 筛选、引用校验、创建、Fork 与候选选择、SSE、限流、超时和取消,不访问真实数据库、仓库、对象存储或模型。未加载外部服务凭据时,执行 `GIT_ENABLED=false AI_ENABLED=false VIBEMAKE_AI_ENABLED=false OSS_ENABLED=false mvn verify`;其中 `GIT_ENABLED` 关闭需要独立凭据的 Git 网关,`VIBEMAKE_AI_ENABLED` 用于覆盖管理端当前固定开启的 AI 配置,对应流程测试自行启用模拟服务。完整安装验证可执行 `GIT_ENABLED=false AI_ENABLED=false VIBEMAKE_AI_ENABLED=false OSS_ENABLED=false mvn clean install`。
PCB 个人工作空间提供 `/api/pcb/workspace/projects` 八个接口,支持独立列表、完整工程 ZIP 直传保存、幂等确认与版本冲突保护。上线前手工执行 [PCB 建表 SQL](docs/pcb-database.md),配置共用 OSS 后设置 `PCB_OSS_ENABLED=true`;默认关闭,ZIP 默认上限 256 MiB、上传有效期 15 分钟。前端对接与部署见 [PCB 工作空间文档](docs/frontend-pcb-workspace.md)。普通测试覆盖 PCB 与 CAD 保存链路,不访问真实 OSS。
真实 Gitea 联调:
+128
View File
@@ -0,0 +1,128 @@
# PCB 个人工作空间前端对接
PCB 工作空间使用独立的 `/api/pcb/workspace/projects`,与 CAD 共用 `/api/auth/login`、`/api/auth/logout` 和 `/api/users/me`,使用同一个 `Authorization: Bearer <平台 token>`。个人空间提供独立 PCB 分类;列表只包含本人未删除的 PCB 项目,不创建 Git 仓库、不自动发布社区。本文约定后端接口,PCB 编辑器及宿主网页需另行接入。
每次手动保存上传一个完整工程 ZIP。数据库保存项目元数据、当前文件引用和上传回执,原理图、PCB、工程配置与工程内私有依赖由前端打包和还原。后端不解压 ZIP、不解析 KiCad 文件,也不验证 ZIP 内容是否可编辑;文件名和大小校验不能代替前端格式验证。
文件读取沿用 CAD 的普通 OSS/CDN 地址规则:平台接口按用户隔离,文件直链权限由现有 Bucket/CDN 决定。公开配置下,拿到链接即可下载。逻辑删除不会撤销已有文件链接。
## 接口与数据
下表前缀为 `/api/pcb/workspace/projects`。全部需要登录,成功 HTTP 200,响应为 `{code,message,data,requestId}`,响应包含 `Cache-Control: no-store`。分页、上海业务时间和跨域约定沿用 [Vibemake 接入约定](vibemake-api.md#接入约定)。业务编码是不透明字符串,客户端不使用数据库 ID。
| 方法 | 相对路径 | 请求 | 成功 data |
| --- | --- | --- | --- |
| GET | 空 | `page=1&size=20&keyword=名称` | `{items,page,size,total}` |
| POST | 空 | `{name,description?,coverUrl?}` | 项目 |
| GET | `/{pcbProjectCode}` | 无 | 项目 |
| PATCH | `/{pcbProjectCode}` | `{name?,description?,coverUrl?}` | 项目 |
| DELETE | `/{pcbProjectCode}` | 无 | null |
| POST | `/{pcbProjectCode}/uploads/signature` | `{fileName,sizeBytes,expectedVersion}` | 上传签名 |
| PUT | `/{pcbProjectCode}/document` | `{uploadCode}` | 保存回执 |
| GET | `/{pcbProjectCode}/document` | 无 | ZIP 文件读取信息 |
名称去除首尾空白后须为 1~100 字符,描述最多 2000 字符,新建默认空字符串。封面为完整 HTTPS 地址,最多 2048 字符,新建省略、null 或空白表示无封面。PATCH 省略或 null 表示保留;描述或封面传 `""` 可清空,至少提供一个非 null 字段。
同名项目允许存在。列表按最近更新时间倒序,同一时间按内部主键倒序稳定分页,主键不对外返回;名称支持包含搜索,关键词最多 100 字符。`page` 为 1~100000,`size` 为 1~100,默认 20。
```ts
interface PcbProject {
pcbProjectCode: string;
name: string;
description: string;
coverUrl: string | null;
hasDocument: boolean;
version: number;
fileName: string;
sizeBytes: number;
savedAt: string | null;
createdAt: string;
updatedAt: string;
}
interface PcbUploadSignature {
uploadCode: string;
uploadUrl: string;
formFields: Record<string, string>;
expiresAt: string;
}
interface PcbSaveResult {
pcbProjectCode: string;
version: number;
savedAt: string;
}
interface PcbDocument {
downloadUrl: string;
expiresAt: null;
version: number;
fileName: string;
sizeBytes: number;
}
```
空项目 `hasDocument=false、version=0、fileName=""、sizeBytes=0、savedAt=null`。名称、描述和封面修改只更新元数据,不改变文件版本或 savedAt。
## 工程 ZIP、保存和重新打开
ZIP 应保留工程原有目录和文件名,包含 `.kicad_pro`、`.kicad_sch`、`.kicad_pcb` 及工程实际使用的私有符号库、封装库、库表、3D 模型、图像等项目文件。文件按原始字节保存,二进制文件不能先解码为文本。全局标准库仍由编辑器提供;工程外的本机绝对路径依赖需由前端迁入工程并处理引用,后端不会自动收集。
PCB 前端现有“归档项目”按扩展名白名单过滤,不能直接作为完整云端保存范围。前端需先刷新所有编辑器的最新序列化结果、等待本地写入完成,再读取完整工程快照打包;不上传浏览器缓存、`.git`、工具目录和本地历史记录。解压时由前端校验路径及资源限额,完整导入成功后再切换当前工程。
1. 首次保存先创建项目,保留返回的 `pcbProjectCode` 和 `version=0`,后续上传失败复用该项目。
2. 从完整工程快照生成 ZIP。文件名为不含路径和控制字符的 `.zip` 名称,最多 255 字符,扩展名不区分大小写;文件非空,默认最大 268435456 字节(256 MiB)。
3. 申请签名,提交 ZIP 实际字节数及编辑基础版本。`sizeBytes` 和 `expectedVersion` 必须是 JSON 整数,不接受字符串、小数、负数或 null,sizeBytes 必须大于零。
4. 将所有 `formFields` 原样加入 FormData,最后追加 ZIP 文件,POST 到 `uploadUrl`。ZIP Blob MIME 使用 `application/zip`,不手写 multipart Content-Type,不携带平台 Authorization。OSS 成功为 HTTP 200,无需解析 JSON。
5. 上传后提交原 `uploadCode` 确认。只有成功回执才能显示云端已保存;同一项目串行保存,打包或上传期间的新修改继续标记为未保存。
6. 打开先读详情;空项目进入新工程,否则获取 `document`,fetch `downloadUrl` 得到 ZIP 并交给编辑器导入。**编辑基础版本使用 document.version**,不能混用此前详情的版本。
本期为手动云端保存,宿主保存按钮和 Ctrl+S 应接入上述链路。本地自动保存继续作为浏览器内恢复能力,不能显示为云端已保存。iframe 集成由宿主网页和编辑器完成;使用 postMessage 时校验精确 origin 与 source,平台 Token 不放 URL,直传和 OSS 文件读取不携带平台 Token。
签名及未确认批次默认 15 分钟后过期。业务时间采用上海时间、无时区后缀,前端解析时补 `+08:00`。下载地址为普通 OSS/CDN 地址,expiresAt 固定为 null,不需要下载签名续期。
相同 uploadCode 重复确认返回首次成功的 version 和 savedAt,不重复增加版本;即使已有更新版本,也不会重新绑定旧 ZIP。回执版本可能小于当前版本,需要时重新读项目。确认超时应保留原批次并重试确认;OSS 上传结果不明确时也先尝试确认,缺文件再处理上传,不盲目覆盖或重复创建项目。
两个标签页基于同一版本保存,仅一个成功,另一个收到 `PCB_VERSION_CONFLICT`。保留本地修改,提供重新打开最新工程、下载本地 ZIP 或另存项目入口,不能自动替换版本号后覆盖。401 时保留本地工程,重新登录后核对账号与归属;离开、切换工程、退出登录前处理未保存修改。
## 封面与错误处理
封面复用 `POST /api/uploads/project-covers/signature`,请求 `{contentType,fileSize}`,支持 JPG、PNG、WebP,最大 5 MiB。取得签名后直传图片,将完整 `coverUrl` 提交至 PCB 创建或 PATCH 接口;无需先创建 Git 项目。封面上传使用已有 `OSS_ENABLED` 开关,PCB 文件开关不代替它。
平台封面落库为 `/project-covers/...` 等环境相对路径,接口返回完整 URL;外部 HTTPS 图片沿用已有规则。工程保存保留封面,更新封面不改变工程版本;替换或清空封面、删除项目均保留原 OSS 对象。
| HTTP / code | 处理 |
| --- | --- |
| 400 `BAD_REQUEST` / `PCB_INVALID_FILE` | 检查元数据、ZIP 文件名及整数参数 |
| 401 `UNAUTHORIZED` | 保留工程,恢复登录后核对账号 |
| 404 `NOT_FOUND` | 项目或批次不存在、非本人或已删除,停止保存 |
| 404 `PCB_DOCUMENT_NOT_FOUND` | 空项目尚无云端 ZIP |
| 409 `PCB_VERSION_CONFLICT` | 保留本地修改,处理并发冲突 |
| 409 `PCB_FILE_MISSING` | 尚无上传对象,检查上传结果再重试确认 |
| 409 `PCB_FILE_SIZE_MISMATCH` | 当前文件不变,重新申请并上传正确文件 |
| 409 `PCB_UPLOAD_EXPIRED` | 重新申请批次 |
| 413 `PCB_FILE_TOO_LARGE` / `REQUEST_TOO_LARGE` | 文件或 JSON 请求超限 |
| 429 `RATE_LIMITED` | 按 Retry-After 等待后重试 |
| 502 `PCB_OSS_ERROR` | 保留工程及批次,稍后重试 |
| 503 `PCB_STORAGE_UNAVAILABLE` / `PCB_STORAGE_UNSAFE` | 存储未开启或连接不完整 |
| 503 `PCB_CODE_BUSY` / `REDIS_UNAVAILABLE` | 暂时无法处理,保留输入后重试 |
## 部署与联调
先手工执行 [PCB 建表 SQL](pcb-database.md),再部署后端,配置当前环境 `pcb-projects/*` 的 RAM 权限及 OSS/CDN CORS,最后开启 PCB 存储。应用不自动创建或修改业务表,回滚时保留两张表和已有 OSS 对象。
| 配置项 | 默认值 / 要求 |
| --- | --- |
| `PCB_OSS_ENABLED` | false,配置完成后显式开启 |
| `PCB_MAX_FILE_BYTES` | 268435456;允许 1 字节至 5 GiB,需兼容编辑器读取限额 |
| `PCB_UPLOAD_VALIDITY` | 15m,允许 1 秒至 7 天 |
| `RATE_PCB_CREATE_PER_MINUTE` / `RATE_PCB_SIGN_PER_MINUTE` | 每用户 5 / 20 |
| `RATE_PCB_SAVE_PER_MINUTE` / `RATE_PCB_READ_PER_MINUTE` | 每用户 30 / 60,含确认及读取重试 |
| `OSS_REGION、OSS_ENDPOINT、OSS_BUCKET、OSS_ACCESS_KEY_ID、OSS_ACCESS_KEY_SECRET` | 共用现有 OSS 连接,前端不持有 RAM 密钥 |
| `OSS_PUBLIC_BASE_URL` | 共用普通 OSS/CDN 基础地址;为空时使用 Bucket 域名 |
| `vibemake.oss.root-directory` | test 为 vibemake_dev,prod 为 vibemake |
PCB 开关独立于 CAD 和公共资源开关;`OSS_ENABLED=false` 时,只要共用连接完整,PCB 仍可开启。适配器仅本地签名、HEAD 核验大小及生成普通地址,不读取或修改 Bucket ACL、对象 ACL、版本控制或公开策略,不单独设置 private ACL。
数据库仅存 `/pcb-projects/{pcbProjectCode}/{uploadCode}/project.zip`,真实 OSS key 为环境根目录加此路径。前端原样使用 formFields.key,不自行拼接环境前缀。格式见 [OSS 引用规范](oss-storage-paths.md)。
RAM 授权覆盖当前环境 `pcb-projects/*` 的 `oss:PutObject` 与 `oss:GetObject`,用于直传和 HEAD;读取权限按已有普通地址方式配置。CORS 允许实际宿主或编辑器来源的 POST、GET 和 Content-Type,需要时暴露 Content-Length、Content-Disposition。平台 API 使用既有来源白名单。
联调验证创建工程、上传、确认、刷新列表、下载 ZIP、重新打开并继续编辑,以及账号隔离和双标签版本冲突。后端自动化使用模拟 OSS,真实 OSS/CDN 与编辑器联调在部署环境完成。首期不提供历史恢复、对象清理或自动云端保存。
+4 -1
View File
@@ -5,7 +5,8 @@
| 位置 | 数据库存储示例 | 实际 OSS key 示例 |
| --- | --- | --- |
| CAD 当前设计及上传批次 | `/cad-projects/{项目编码}/{批次编码}/design.sc` | `vibemake_dev/cad-projects/{项目编码}/{批次编码}/design.sc` |
| 平台托管封面(含 CAD 的 cover_url) | `/project-covers/{用户编码}/{日期}/{文件名}` | `vibemake_dev/project-covers/{用户编码}/{日期}/{文件名}` |
| PCB 当前工程及上传批次 | `/pcb-projects/{项目编码}/{批次编码}/project.zip` | `vibemake_dev/pcb-projects/{项目编码}/{批次编码}/project.zip` |
| 平台托管封面(含 CAD、PCB 的 cover_url) | `/project-covers/{用户编码}/{日期}/{文件名}` | `vibemake_dev/project-covers/{用户编码}/{日期}/{文件名}` |
| URDF 主文件及目录 | `/urdf/{项目编码}/{批次编码}/...` | `vibemake_dev/urdf/{项目编码}/{批次编码}/...` |
| STEP、GLB、零件、拼装步骤、行走资源 | `/project-resources/{项目编码}/{类型}/{批次编码}/...` | `vibemake_dev/project-resources/{项目编码}/{类型}/{批次编码}/...` |
@@ -15,6 +16,8 @@
## 现有数据手工转换 SQL
PCB 两张新表直接采用环境相对路径,建表见 [PCB 工作空间 SQL](pcb-database.md),无需执行下列 CAD 与社区资源的历史转换。
无需修改字段结构。先升级所有在线写入进程与导入工具,再暂停资源写入并备份业务库。在对应环境的业务数据库连接中执行;test 使用 `vibemake_dev`,prod 将 `@oss_root` 改为 `vibemake`。不会移动、复制或删除 OSS 对象,也不修改项目版本、保存时间、上传回执和业务更新时间。
仅当字段精确以当前环境和对应资源目录开头时转换,使用二进制前缀比较避免大小写或下划线通配符误匹配,不使用全局 REPLACE。已经是相对路径的记录、空值和其他环境路径不变;本转换可重复执行。
+50
View File
@@ -0,0 +1,50 @@
# PCB 工作空间建表 SQL
在启用 PCB 接口前,由运维在现有 `vibemake` 数据库手工执行以下 SQL(MySQL 8.0.13+)。应用不自动建表,不修改现有项目表。所有业务时间按上海时间写入。
`id` 和归属外键仅供服务内部使用,对外使用 `pcb_project_code` 和 `upload_code`。两张表与 Git 项目无关联。上线顺序:执行 SQL → 部署后端 → 验证共用 OSS 配置及文件读取 → 开放前端入口。回滚代码时保留两张表和 OSS 对象。
```sql
CREATE TABLE pcb_project (
id BIGINT NOT NULL AUTO_INCREMENT COMMENT '内部主键,不对外返回',
pcb_project_code VARCHAR(32) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT 'PCB项目唯一业务编码',
owner_user_id BIGINT NOT NULL COMMENT '所属用户内部主键,关联sys_user.id',
name VARCHAR(100) NOT NULL COMMENT 'PCB项目名称',
description VARCHAR(2000) NOT NULL DEFAULT '' COMMENT 'PCB项目描述',
cover_url VARCHAR(2048) NULL COMMENT 'PCB项目封面,平台OSS资源存无环境前缀的相对路径',
document_object_key VARCHAR(512) CHARACTER SET ascii COLLATE ascii_bin NOT NULL DEFAULT '' COMMENT '当前工程ZIP文件环境相对路径,以斜杠开头,不含域名和环境根目录',
file_name VARCHAR(255) NOT NULL DEFAULT '' COMMENT '当前工程ZIP文件名称',
size_bytes BIGINT NOT NULL DEFAULT 0 COMMENT '当前工程ZIP文件大小,单位字节',
version BIGINT NOT NULL DEFAULT 0 COMMENT '当前保存版本,空项目为0,每次成功保存递增',
saved_at DATETIME(3) NULL COMMENT '最近成功保存工程ZIP文件的上海时间',
deleted TINYINT NOT NULL DEFAULT 0 COMMENT '逻辑删除标记,0未删除,1已删除',
created_at DATETIME(3) NOT NULL COMMENT '项目创建上海时间',
updated_at DATETIME(3) NOT NULL COMMENT '项目信息最近更新上海时间',
PRIMARY KEY (id),
UNIQUE KEY uk_pcb_project_code (pcb_project_code),
KEY idx_pcb_project_owner_list (owner_user_id, deleted, updated_at, id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='PCB个人工作空间项目';
CREATE TABLE pcb_project_upload (
id BIGINT NOT NULL AUTO_INCREMENT COMMENT '内部主键,不对外返回',
upload_code VARCHAR(32) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT '上传批次唯一业务编码',
pcb_project_id BIGINT NOT NULL COMMENT '所属PCB项目内部主键,关联pcb_project.id',
expected_version BIGINT NOT NULL COMMENT '签发上传时的项目基础版本,用于并发保存校验',
object_key VARCHAR(512) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT '本批次工程ZIP文件环境相对路径,以斜杠开头,不含域名和环境根目录',
file_name VARCHAR(255) NOT NULL COMMENT '本批次工程ZIP文件名称',
size_bytes BIGINT NOT NULL COMMENT '本批次声明的文件大小,单位字节',
expires_at DATETIME(3) NOT NULL COMMENT '未确认批次的截止上海时间,与上传签名一致',
saved_version BIGINT NULL COMMENT '确认成功的版本号,空值表示尚未确认',
saved_at DATETIME(3) NULL COMMENT '首次确认成功上海时间,重复确认返回原值',
created_at DATETIME(3) NOT NULL COMMENT '批次创建上海时间',
updated_at DATETIME(3) NOT NULL COMMENT '批次最近更新上海时间',
PRIMARY KEY (id),
UNIQUE KEY uk_pcb_upload_code (upload_code),
KEY idx_pcb_upload_project (pcb_project_id, created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='PCB工程ZIP文件上传与保存确认批次';
```
保存事务锁定当前用户的未删除项目和对应批次,按 `expected_version` 条件更新当前对象键和版本,同时写入批次回执。失败整体回滚。重放已确认批次只返回首次确认的版本和时间,不重新绑定旧对象;项目删除后仍拒绝重放。首期不清理上传批次或旧 OSS 对象,不提供历史恢复接口。
`document_object_key` 和 `object_key` 均保存 `/pcb-projects/{项目编码}/{批次编码}/project.zip`,不保存 `vibemake_dev/` 或 `vibemake/`。真实上传和读取在运行时补当前环境根目录。PCB 新建表直接采用该格式,无需执行 CAD 的历史路径转换 SQL。
+2
View File
@@ -10,6 +10,8 @@ ZIP、TAR.GZ 下载和 HTTPS Git 本地开发的独立前端交付文档见 [仓
CAD 个人工作空间使用独立的 `/api/cad/workspace/projects`,共用登录,但不创建 Git 仓库、不混入现有项目列表。接口、保存续编流程和共用 OSS 配置见 [CAD 工作空间前端对接](frontend-cad-workspace.md),上线前执行 [CAD 建表 SQL](cad-database.md)。
PCB 个人工作空间使用独立的 `/api/pcb/workspace/projects`,共用登录,通过完整工程 ZIP 直传 OSS 保存与续编,个人空间按独立 PCB 分类查询。接口、版本冲突、重试和部署配置见 [PCB 工作空间前端对接](frontend-pcb-workspace.md),上线前手工执行 [PCB 建表 SQL](pcb-database.md)。
CAD 网页 AI Agent 使用 `/api/cad/ai/capabilities` 和 `/api/cad/ai/chat`,支持流式回复及浏览器执行的 CAD 工具调用,复用豆包连接配置。功能默认关闭,聊天不落库;完整协议及 SolidCraft 网页适配要求见 [CAD AI Agent 前端对接](frontend-cad-ai-agent.md)。
## 阅读导航
@@ -0,0 +1,78 @@
package com.linkerbot.vibemake.api.controller;
import com.linkerbot.vibemake.bean.PcbContracts.*;
import com.linkerbot.vibemake.common.ApiResponse;
import com.linkerbot.vibemake.common.PageResponse;
import com.linkerbot.vibemake.security.CurrentUser;
import com.linkerbot.vibemake.service.pcb.PcbProjectService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.*;
import jakarta.servlet.http.HttpServletResponse;
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/pcb/workspace/projects")
@Tag(name = "PCB 个人工作空间")
public class PcbWorkspaceController {
private final PcbProjectService projects;
@ModelAttribute
public void noStore(HttpServletResponse response) {
response.setHeader(HttpHeaders.CACHE_CONTROL, "no-store");
}
@GetMapping
@Operation(summary = "我的 PCB 项目分页列表")
public ApiResponse<PageResponse<PcbProjectView>> list(
@RequestParam(defaultValue = "1") long page, @RequestParam(defaultValue = "20") long size,
@RequestParam(required = false) String keyword) {
return ApiResponse.success(projects.list(CurrentUser.required(), keyword, page, size));
}
@PostMapping
@Operation(summary = "创建空 PCB 项目")
public ApiResponse<PcbProjectView> create(@Valid @RequestBody PcbCreateProjectInput input) {
return ApiResponse.success(projects.create(CurrentUser.required(), input));
}
@GetMapping("/{pcbProjectCode}")
@Operation(summary = "我的 PCB 项目详情")
public ApiResponse<PcbProjectView> detail(@PathVariable String pcbProjectCode) {
return ApiResponse.success(projects.detail(CurrentUser.required(), pcbProjectCode));
}
@PatchMapping("/{pcbProjectCode}")
@Operation(summary = "修改 PCB 项目名称、描述和封面")
public ApiResponse<PcbProjectView> update(@PathVariable String pcbProjectCode, @Valid @RequestBody PcbUpdateProjectInput input) {
return ApiResponse.success(projects.update(CurrentUser.required(), pcbProjectCode, input));
}
@DeleteMapping("/{pcbProjectCode}")
@Operation(summary = "逻辑删除 PCB 项目")
public ApiResponse<Void> delete(@PathVariable String pcbProjectCode) {
projects.delete(CurrentUser.required(), pcbProjectCode);
return ApiResponse.success(null);
}
@PostMapping("/{pcbProjectCode}/uploads/signature")
@Operation(summary = "申请 PCB 工程 ZIP 文件 OSS 直传签名")
public ApiResponse<PcbUploadSignature> sign(@PathVariable String pcbProjectCode, @Valid @RequestBody PcbUploadInput input) {
return ApiResponse.success(projects.sign(CurrentUser.required(), pcbProjectCode, input));
}
@PutMapping("/{pcbProjectCode}/document")
@Operation(summary = "确认文件上传并保存 PCB 最新工程")
public ApiResponse<PcbSaveResult> confirm(@PathVariable String pcbProjectCode, @Valid @RequestBody PcbConfirmInput input) {
return ApiResponse.success(projects.confirm(CurrentUser.required(), pcbProjectCode, input.uploadCode()));
}
@GetMapping("/{pcbProjectCode}/document")
@Operation(summary = "获取 PCB 当前工程 ZIP 的 OSS/CDN 文件地址")
public ApiResponse<PcbDocumentView> document(@PathVariable String pcbProjectCode) {
return ApiResponse.success(projects.document(CurrentUser.required(), pcbProjectCode));
}
}
@@ -64,6 +64,10 @@ vibemake:
cad-sign: ${RATE_CAD_SIGN_PER_MINUTE:20}
cad-save: ${RATE_CAD_SAVE_PER_MINUTE:30}
cad-read: ${RATE_CAD_READ_PER_MINUTE:60}
pcb-create: ${RATE_PCB_CREATE_PER_MINUTE:5}
pcb-sign: ${RATE_PCB_SIGN_PER_MINUTE:20}
pcb-save: ${RATE_PCB_SAVE_PER_MINUTE:30}
pcb-read: ${RATE_PCB_READ_PER_MINUTE:60}
comment: ${RATE_COMMENT_PER_MINUTE:10}
like: ${RATE_LIKE_PER_MINUTE:60}
readme-images:
@@ -97,6 +101,11 @@ vibemake:
upload-validity: ${CAD_UPLOAD_VALIDITY:15m}
oss:
enabled: ${CAD_OSS_ENABLED:true}
pcb:
max-file-bytes: ${PCB_MAX_FILE_BYTES:268435456}
upload-validity: ${PCB_UPLOAD_VALIDITY:15m}
oss:
enabled: ${PCB_OSS_ENABLED:false}
ai:
enabled: ${AI_ENABLED:true}
api-key: ${ARK_API_KEY:}
@@ -0,0 +1,628 @@
package com.linkerbot.vibemake.api;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.linkerbot.vibemake.bean.PcbContracts.PcbSaveResult;
import com.linkerbot.vibemake.bean.entity.User;
import com.linkerbot.vibemake.common.BusinessException;
import com.linkerbot.vibemake.security.TokenService;
import com.linkerbot.vibemake.service.UserService;
import com.linkerbot.vibemake.service.pcb.PcbObjectStore;
import com.linkerbot.vibemake.service.pcb.PcbProjectService;
import com.linkerbot.vibemake.service.config.PcbProperties;
import com.linkerbot.vibemake.service.config.LimitProperties;
import com.linkerbot.vibemake.service.config.OssProperties;
import com.linkerbot.vibemake.service.oss.OssPostSigner;
import com.linkerbot.vibemake.service.oss.OssResourcePaths;
import com.linkerbot.vibemake.service.support.ProjectSupport;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.*;
import org.springframework.boot.test.context.*;
import org.springframework.context.annotation.*;
import org.springframework.http.MediaType;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.web.servlet.*;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
@SpringBootTest(properties = {
"spring.datasource.url=jdbc:h2:mem:pcb;MODE=MySQL;DB_CLOSE_DELAY=-1;LOCK_TIMEOUT=10000",
"spring.datasource.username=sa", "spring.datasource.password=",
"spring.datasource.driver-class-name=org.h2.Driver",
"vibemake.repository-write.worker-enabled=false", "vibemake.oss.enabled=false",
"vibemake.pcb.oss.enabled=true", "vibemake.oss.bucket=shared-oss-tests",
"vibemake.oss.access-key-id=TestPcbKey", "vibemake.oss.access-key-secret=test-secret",
"vibemake.oss.public-base-url=https://pcb-cdn.example.com/resources",
"vibemake.ai.enabled=false", "vibemake.git.enabled=false", "vibemake.limits.enabled=false",
"logging.level.org.springframework=WARN"
})
@ActiveProfiles("test")
@AutoConfigureMockMvc(print = MockMvcPrint.NONE)
@Import(PcbWorkspaceTest.Config.class)
class PcbWorkspaceTest {
private static final String BASE = "/api/pcb/workspace/projects";
@TestConfiguration
static class Config {
@Bean @Primary
FakePcbStore fakePcb(PcbProperties properties, OssProperties oss, ObjectMapper json) {
return new FakePcbStore(properties, oss, json);
}
}
static class FakePcbStore implements PcbObjectStore {
final Map<String, byte[]> objects = new ConcurrentHashMap<>();
final PcbProperties properties;
final OssProperties oss;
final OssPostSigner signer;
boolean unavailable;
Runnable afterSign;
Runnable afterSize;
CyclicBarrier sizeBarrier;
FakePcbStore(PcbProperties properties, OssProperties oss, ObjectMapper json) {
this.properties = properties;
this.oss = oss;
this.signer = new OssPostSigner(oss, json);
}
private void available() {
if (!properties.getOss().isEnabled()) throw new BusinessException(503, "PCB_STORAGE_UNAVAILABLE", "关闭");
}
@Override
public SignedUpload signUpload(String key, String name, long size, Duration validity) {
available();
OssPostSigner.SignedPost post = signer.signObject(key, "application/zip", size, validity, null);
if (afterSign != null) {
Runnable action = afterSign;
afterSign = null;
action.run();
}
return new SignedUpload(oss.uploadUrl(), post.formFields(), post.expiresAt());
}
@Override
public long size(String key) {
available();
if (unavailable) throw new BusinessException(502, "PCB_OSS_ERROR", "不可用");
byte[] bytes = objects.get(key);
if (bytes == null) throw new BusinessException(409, "PCB_FILE_MISSING", "缺文件");
if (sizeBarrier != null) {
try {
sizeBarrier.await(5, TimeUnit.SECONDS);
} catch (Exception error) {
throw new IllegalStateException(error);
}
}
if (afterSize != null) {
Runnable action = afterSize;
afterSize = null;
action.run();
}
return bytes.length;
}
@Override
public String documentUrl(String key) {
available();
return new OssResourcePaths(oss).publicUrl(key);
}
}
@Autowired MockMvc mvc;
@Autowired ObjectMapper json;
@Autowired JdbcTemplate jdbc;
@Autowired UserService users;
@Autowired TokenService tokens;
@Autowired PcbProperties properties;
@Autowired LimitProperties limitProperties;
@Autowired OssProperties oss;
@Autowired PcbProjectService service;
@Autowired FakePcbStore store;
private String token;
private long userId;
@BeforeEach
void reset() throws Exception {
SchemaSupport.reset(jdbc);
properties.getOss().setEnabled(true);
properties.setMaxFileBytes(268435456);
properties.setUploadValidity(Duration.ofMinutes(15));
store.objects.clear();
store.unavailable = false;
store.afterSign = null;
store.afterSize = null;
store.sizeBarrier = null;
User user = users.login("pcb-owner@example.invalid");
userId = user.getId();
token = tokens.issue(user.getId(), user.getSessionVersion());
}
private MockHttpServletRequestBuilder auth(MockHttpServletRequestBuilder request) {
return request.header("Authorization", "Bearer " + token);
}
private JsonNode perform(MockHttpServletRequestBuilder request, int status) throws Exception {
MvcResult result = mvc.perform(request).andExpect(status().is(status)).andReturn();
return json.readTree(result.getResponse().getContentAsString());
}
private MockHttpServletRequestBuilder body(MockHttpServletRequestBuilder request, Object body) throws Exception {
return request.contentType(MediaType.APPLICATION_JSON).content(json.writeValueAsBytes(body));
}
private String create(String name) throws Exception {
JsonNode project = perform(body(auth(post(BASE)), Map.of("name", name)), 200).path("data");
assertThat(project.has("id")).isFalse();
assertThat(project.has("ownerUserId")).isFalse();
assertThat(project.path("hasDocument").asBoolean()).isFalse();
assertThat(project.path("version").asLong()).isZero();
assertThat(project.path("pcbProjectCode").asText()).matches("[0-9a-z]{12}");
return project.path("pcbProjectCode").asText();
}
private JsonNode sign(String code, long version, long size) throws Exception {
return perform(body(auth(post(BASE + "/" + code + "/uploads/signature")),
Map.of("fileName", "控制板.zip", "sizeBytes", size, "expectedVersion", version)), 200).path("data");
}
private JsonNode upload(String code, long version, byte[] bytes) throws Exception {
JsonNode signature = sign(code, version, bytes.length);
store.objects.put(signature.path("formFields").path("key").asText(), bytes.clone());
return signature;
}
private JsonNode confirm(String code, JsonNode signature, int status) throws Exception {
return perform(body(auth(put(BASE + "/" + code + "/document")),
Map.of("uploadCode", signature.path("uploadCode").asText())), status);
}
@Test
void sharedLoginSeparateWorkspaceAndZipReferencesRoundTrip() throws Exception {
perform(auth(get("/api/users/me")), 200);
String code = create(" PCB 控制板 ");
assertThat(perform(auth(get(BASE)), 200).path("data").path("total").asInt()).isEqualTo(1);
assertThat(perform(auth(get("/api/workspace/projects")), 200).path("data").path("total").asInt()).isZero();
assertThat(perform(auth(get("/api/cad/workspace/projects")), 200).path("data").path("total").asInt()).isZero();
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM project", Long.class)).isZero();
assertThat(perform(auth(get(BASE + "/" + code + "/document")), 404).path("code").asText()).isEqualTo("PCB_DOCUMENT_NOT_FOUND");
Map<String, byte[]> files = new HashMap<>(Map.of(
"控制板/控制板.kicad_pro", "{}".getBytes(StandardCharsets.UTF_8),
"控制板/控制板.kicad_sch", "(kicad_sch)".getBytes(StandardCharsets.UTF_8),
"控制板/控制板.kicad_pcb", "(kicad_pcb)".getBytes(StandardCharsets.UTF_8),
"控制板/私有.pretty/接口.kicad_mod", "(footprint)".getBytes(StandardCharsets.UTF_8),
"控制板/models/model.step", new byte[] {0, 1, 2, -1}));
byte[] firstBytes = zip(files);
JsonNode first = upload(code, 0, firstBytes);
assertThat(first.path("uploadUrl").asText()).isEqualTo(oss.uploadUrl());
assertThat(first.path("formFields").path("key").asText())
.startsWith(oss.getRootDirectory() + "/pcb-projects/" + code + "/");
assertThat(first.path("formFields").path("x-oss-credential").asText())
.startsWith(oss.getAccessKeyId() + "/");
assertThat(first.path("formFields").has("x-oss-object-acl")).isFalse();
assertThat(first.path("formFields").path("content-type").asText()).isEqualTo("application/zip");
assertThat(confirm(code, first, 200).path("data").path("version").asLong()).isEqualTo(1);
JsonNode opened = perform(auth(get(BASE + "/" + code + "/document")), 200).path("data");
assertThat(opened.path("version").asLong()).isEqualTo(1);
assertThat(opened.path("downloadUrl").asText())
.isEqualTo(oss.publicBaseUrl() + "/" + first.path("formFields").path("key").asText());
assertThat(opened.has("expiresAt")).isTrue();
assertThat(opened.path("expiresAt").isNull()).isTrue();
assertThat(store.objects.get(first.path("formFields").path("key").asText())).isEqualTo(firstBytes);
files.put("控制板/控制板.kicad_pcb", "(kicad_pcb (net 1 GND))".getBytes(StandardCharsets.UTF_8));
byte[] secondBytes = zip(files);
JsonNode second = upload(code, opened.path("version").asLong(), secondBytes);
JsonNode saved = confirm(code, second, 200).path("data");
assertThat(saved.path("version").asLong()).isEqualTo(2);
JsonNode detail = perform(auth(get(BASE + "/" + code)), 200).path("data");
assertThat(detail.path("hasDocument").asBoolean()).isTrue();
assertThat(detail.path("fileName").asText()).isEqualTo("控制板.zip");
assertThat(detail.path("sizeBytes").asLong()).isEqualTo(secondBytes.length);
assertThat(detail.path("savedAt").asText()).doesNotEndWith("Z");
assertThat(detail.has("documentObjectKey")).isFalse();
assertThat(jdbc.queryForObject("SELECT document_object_key FROM pcb_project WHERE pcb_project_code=?",
String.class, code)).isEqualTo("/pcb-projects/" + code + "/" + second.path("uploadCode").asText() + "/project.zip");
assertThat(jdbc.queryForObject("SELECT object_key FROM pcb_project_upload WHERE upload_code=?", String.class,
second.path("uploadCode").asText())).isEqualTo("/pcb-projects/" + code + "/" + second.path("uploadCode").asText() + "/project.zip");
perform(body(auth(patch(BASE + "/" + code)), Map.of("name", "重命名", "description", "电机控制板")), 200);
assertThat(perform(auth(get(BASE + "?keyword=重命")), 200).path("data").path("total").asInt()).isEqualTo(1);
assertThat(perform(auth(get(BASE + "/" + code)), 200).path("data").path("version").asLong()).isEqualTo(2);
assertThat(store.objects).hasSize(2);
JsonNode current = perform(auth(get(BASE + "/" + code + "/document")), 200).path("data");
assertThat(current.path("version").asLong()).isEqualTo(2);
assertThat(current.path("downloadUrl").asText())
.isEqualTo(oss.publicBaseUrl() + "/" + second.path("formFields").path("key").asText());
}
private byte[] zip(Map<String, byte[]> files) throws Exception {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
try (ZipOutputStream zip = new ZipOutputStream(bytes, StandardCharsets.UTF_8)) {
for (Map.Entry<String, byte[]> file : files.entrySet()) {
zip.putNextEntry(new ZipEntry(file.getKey()));
zip.write(file.getValue());
zip.closeEntry();
}
}
return bytes.toByteArray();
}
@Test
void pcbCoverRoundTripsThroughCreationListingUpdateClearAndDocumentSave() throws Exception {
String path = "/project-covers/" + "a".repeat(12) + "/20261104/" + "b".repeat(32) + ".png";
String url = oss.publicBaseUrl() + "/" + oss.getRootDirectory() + path;
JsonNode created = perform(body(auth(post(BASE)), Map.of("name", "带封面的 PCB", "description", "参数化设计", "coverUrl", url)), 200).path("data");
String code = created.path("pcbProjectCode").asText();
assertThat(created.path("coverUrl").asText()).isEqualTo(url);
assertThat(created.path("version").asLong()).isZero();
assertThat(jdbc.queryForObject("SELECT cover_url FROM pcb_project WHERE pcb_project_code=?", String.class, code)).isEqualTo(path);
assertThat(perform(auth(get(BASE)), 200).path("data").path("items").get(0).path("coverUrl").asText()).isEqualTo(url);
assertThat(perform(auth(get(BASE + "/" + code)), 200).path("data").path("coverUrl").asText()).isEqualTo(url);
JsonNode receipt = confirm(code, upload(code, 0, new byte[] {80, 75, 3, 4}), 200).path("data");
String nextPath = path.replace(".png", ".webp");
String nextUrl = oss.publicBaseUrl() + "/" + oss.getRootDirectory() + nextPath;
JsonNode changed = perform(body(auth(patch(BASE + "/" + code)), Map.of("coverUrl", nextUrl)), 200).path("data");
assertThat(changed.path("coverUrl").asText()).isEqualTo(nextUrl);
assertThat(changed.path("name").asText()).isEqualTo("带封面的 PCB");
assertThat(changed.path("description").asText()).isEqualTo("参数化设计");
assertThat(changed.path("version").asLong()).isEqualTo(1);
assertThat(changed.path("savedAt")).isEqualTo(receipt.path("savedAt"));
assertThat(jdbc.queryForObject("SELECT cover_url FROM pcb_project WHERE pcb_project_code=?", String.class, code)).isEqualTo(nextPath);
JsonNode preserved = perform(body(auth(patch(BASE + "/" + code)),
json.createObjectNode().put("name", "改名").putNull("coverUrl")), 200).path("data");
assertThat(preserved.path("coverUrl").asText()).isEqualTo(nextUrl);
confirm(code, upload(code, 1, new byte[] {80, 75, 3, 4, 5}), 200);
assertThat(perform(auth(get(BASE + "/" + code)), 200).path("data").path("coverUrl").asText()).isEqualTo(nextUrl);
String ownerToken = token;
User other = users.login("pcb-cover-other@example.invalid");
token = tokens.issue(other.getId(), other.getSessionVersion());
perform(body(auth(patch(BASE + "/" + code)), Map.of("coverUrl", "")), 404);
token = ownerToken;
JsonNode cleared = perform(body(auth(patch(BASE + "/" + code)), Map.of("coverUrl", "")), 200).path("data");
assertThat(cleared.path("coverUrl").isNull()).isTrue();
assertThat(cleared.path("version").asLong()).isEqualTo(2);
assertThat(jdbc.queryForObject("SELECT cover_url FROM pcb_project WHERE pcb_project_code=?", String.class, code)).isNull();
}
@Test
void optionalAndExternalCoversFollowExistingCoverRules() throws Exception {
String code = create("无封面");
assertThat(perform(auth(get(BASE + "/" + code)), 200).path("data").path("coverUrl").isNull()).isTrue();
String external = "https://images.example.com/pcb.png";
JsonNode view = perform(body(auth(patch(BASE + "/" + code)), Map.of("coverUrl", external)), 200).path("data");
assertThat(view.path("coverUrl").asText()).isEqualTo(external);
assertThat(jdbc.queryForObject("SELECT cover_url FROM pcb_project WHERE pcb_project_code=?", String.class, code)).isEqualTo(external);
}
@ParameterizedTest
@ValueSource(strings = {"http://images.example.com/pcb.png", "https://user:password@images.example.com/pcb.png",
"/project-covers/user/pcb.png", "data:image/png;base64,abcd"})
void invalidCoverAddressesAreRejectedWithoutChangingProject(String invalid) throws Exception {
String code = create("封面验证");
perform(body(auth(patch(BASE + "/" + code)), Map.of("coverUrl", invalid)), 400);
perform(body(auth(post(BASE)), Map.of("name", "非法封面", "coverUrl", invalid)), 400);
assertThat(jdbc.queryForObject("SELECT cover_url FROM pcb_project WHERE pcb_project_code=?", String.class, code)).isNull();
}
@Test
void confirmedBatchReplayReturnsOriginalReceiptEvenAfterLaterSaveExpiryAndOssFailure() throws Exception {
String code = create("幂等");
JsonNode first = upload(code, 0, new byte[] {1});
JsonNode original = confirm(code, first, 200).path("data");
confirm(code, upload(code, 1, new byte[] {2}), 200);
jdbc.update("UPDATE pcb_project_upload SET expires_at=?", ProjectSupport.now().minusDays(1));
store.unavailable = true;
assertThat(confirm(code, first, 200).path("data")).isEqualTo(original);
assertThat(service.detail(userId, code).version()).isEqualTo(2);
JsonNode document = perform(auth(get(BASE + "/" + code + "/document")), 200).path("data");
assertThat(document.path("version").asLong()).isEqualTo(2);
assertThat(document.path("downloadUrl").asText()).startsWith(oss.publicBaseUrl() + "/");
properties.getOss().setEnabled(false);
assertThat(confirm(code, first, 200).path("data")).isEqualTo(original);
}
@Test
void foreignUsersAndProjectsCannotAccessOrConfirmUploads() throws Exception {
String code = create("私有设计");
JsonNode pending = upload(code, 0, new byte[] {1});
String another = create("另一项目");
confirm(another, pending, 404);
User other = users.login("pcb-other@example.invalid");
token = tokens.issue(other.getId(), other.getSessionVersion());
assertThat(perform(auth(get(BASE)), 200).path("data").path("total").asInt()).isZero();
perform(auth(get(BASE + "/" + code)), 404);
perform(auth(get(BASE + "/" + code + "/document")), 404);
perform(body(auth(patch(BASE + "/" + code)), Map.of("name", "越权")), 404);
perform(auth(delete(BASE + "/" + code)), 404);
perform(body(auth(post(BASE + "/" + code + "/uploads/signature")),
Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 0)), 404);
confirm(code, pending, 404);
}
@Test
void failuresDoNotReplaceSavedDocumentAndUnconfirmedExpiryIsEnforced() throws Exception {
String code = create("失败保护");
confirm(code, upload(code, 0, new byte[] {1}), 200);
JsonNode next = sign(code, 1, 2);
assertThat(confirm(code, next, 409).path("code").asText()).isEqualTo("PCB_FILE_MISSING");
String key = next.path("formFields").path("key").asText();
store.objects.put(key, new byte[] {2});
assertThat(confirm(code, next, 409).path("code").asText()).isEqualTo("PCB_FILE_SIZE_MISMATCH");
store.objects.put(key, new byte[] {2, 3});
store.unavailable = true;
assertThat(confirm(code, next, 502).path("code").asText()).isEqualTo("PCB_OSS_ERROR");
store.unavailable = false;
jdbc.update("UPDATE pcb_project_upload SET expires_at=? WHERE upload_code=?",
ProjectSupport.now().minusSeconds(1), next.path("uploadCode").asText());
assertThat(confirm(code, next, 409).path("code").asText()).isEqualTo("PCB_UPLOAD_EXPIRED");
assertThat(service.detail(userId, code).version()).isEqualTo(1);
assertThat(service.detail(userId, code).sizeBytes()).isEqualTo(1);
}
@Test
void concurrentDifferentBatchesOnlyOneSaveWins() throws Exception {
String code = create("并发");
JsonNode first = upload(code, 0, new byte[] {1});
JsonNode second = upload(code, 0, new byte[] {2});
store.sizeBarrier = new CyclicBarrier(2);
try (ExecutorService executor = Executors.newFixedThreadPool(2)) {
Future<String> one = executor.submit(() -> confirmationOutcome(code, first));
Future<String> two = executor.submit(() -> confirmationOutcome(code, second));
assertThat(List.of(one.get(10, TimeUnit.SECONDS), two.get(10, TimeUnit.SECONDS)))
.containsExactlyInAnyOrder("saved:1", "PCB_VERSION_CONFLICT");
}
assertThat(service.detail(userId, code).version()).isEqualTo(1);
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM pcb_project_upload WHERE saved_version IS NOT NULL", Long.class)).isEqualTo(1);
}
@Test
void concurrentSameBatchOnlyIncrementsOnce() throws Exception {
String code = create("重复并发");
JsonNode batch = upload(code, 0, new byte[] {1});
store.sizeBarrier = new CyclicBarrier(2);
try (ExecutorService executor = Executors.newFixedThreadPool(2)) {
Future<PcbSaveResult> one = executor.submit(() -> service.confirm(userId, code, batch.path("uploadCode").asText()));
Future<PcbSaveResult> two = executor.submit(() -> service.confirm(userId, code, batch.path("uploadCode").asText()));
assertThat(one.get(10, TimeUnit.SECONDS)).isEqualTo(two.get(10, TimeUnit.SECONDS));
}
assertThat(service.detail(userId, code).version()).isEqualTo(1);
}
private String confirmationOutcome(String code, JsonNode batch) {
try {
return "saved:" + service.confirm(userId, code, batch.path("uploadCode").asText()).version();
} catch (BusinessException error) {
return error.code();
}
}
@Test
void failedReceiptWriteRollsBackDocumentAndAllowsRetry() throws Exception {
String code = create("事务回滚");
JsonNode batch = upload(code, 0, new byte[] {1});
jdbc.execute("ALTER TABLE pcb_project_upload ADD CONSTRAINT reject_saved CHECK (saved_version IS NULL)");
assertThatThrownBy(() -> service.confirm(userId, code, batch.path("uploadCode").asText())).isInstanceOf(RuntimeException.class);
assertThat(service.detail(userId, code).version()).isZero();
assertThat(service.detail(userId, code).hasDocument()).isFalse();
jdbc.execute("ALTER TABLE pcb_project_upload DROP CONSTRAINT reject_saved");
assertThat(confirm(code, batch, 200).path("data").path("version").asLong()).isEqualTo(1);
}
@Test
void deletionDuringHeadAndLaterReplayCannotRestoreProject() throws Exception {
String code = create("删除竞争");
JsonNode saved = upload(code, 0, new byte[] {1});
confirm(code, saved, 200);
JsonNode pending = upload(code, 1, new byte[] {2});
store.afterSize = () -> service.delete(userId, code);
confirm(code, pending, 404);
confirm(code, saved, 404);
perform(auth(get(BASE + "/" + code)), 404);
perform(auth(get(BASE + "/" + code + "/document")), 404);
perform(body(auth(post(BASE + "/" + code + "/uploads/signature")),
Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 1)), 404);
assertThat(perform(auth(get(BASE)), 200).path("data").path("total").asInt()).isZero();
assertThat(store.objects).hasSize(2);
}
@Test
void deletionDuringSigningDoesNotCreateOrReturnUploadBatch() throws Exception {
String code = create("签名删除竞争");
store.afterSign = () -> service.delete(userId, code);
perform(body(auth(post(BASE + "/" + code + "/uploads/signature")),
Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 0)), 404);
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM pcb_project_upload", Long.class)).isZero();
}
@Test
void versionChangeDuringSigningDoesNotReturnStaleCredentials() throws Exception {
String code = create("签名版本竞争");
JsonNode first = upload(code, 0, new byte[] {1});
store.afterSign = () -> service.confirm(userId, code, first.path("uploadCode").asText());
assertThat(perform(body(auth(post(BASE + "/" + code + "/uploads/signature")),
Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 0)), 409)
.path("code").asText()).isEqualTo("PCB_VERSION_CONFLICT");
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM pcb_project_upload", Long.class)).isEqualTo(1);
assertThat(service.detail(userId, code).version()).isEqualTo(1);
}
@Test
void expiryDuringHeadStillPreventsDocumentChange() throws Exception {
String code = create("确认过期竞争");
JsonNode batch = upload(code, 0, new byte[] {1});
store.afterSize = () -> jdbc.update("UPDATE pcb_project_upload SET expires_at=? WHERE upload_code=?",
ProjectSupport.now().minusSeconds(1), batch.path("uploadCode").asText());
assertThat(confirm(code, batch, 409).path("code").asText()).isEqualTo("PCB_UPLOAD_EXPIRED");
assertThat(service.detail(userId, code).version()).isZero();
assertThat(jdbc.queryForObject("SELECT saved_version FROM pcb_project_upload WHERE upload_code=?",
Long.class, batch.path("uploadCode").asText())).isNull();
}
@Test
void independentRateLimitsApplyToEachPcbOperationAndUser() throws Exception {
boolean wasEnabled = limitProperties.isEnabled();
Map<String, Integer> original = new HashMap<>(limitProperties.getPerMinute());
try {
limitProperties.setEnabled(true);
for (String group : List.of("pcb-create", "pcb-sign", "pcb-save", "pcb-read"))
limitProperties.getPerMinute().put(group, 1);
String code = create("限流");
assertThat(perform(body(auth(post(BASE)), Map.of("name", "创建超额")), 429)
.path("code").asText()).isEqualTo("RATE_LIMITED");
JsonNode batch = upload(code, 0, new byte[] {1});
mvc.perform(body(auth(post(BASE + "/" + code + "/uploads/signature")),
Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 0)))
.andExpect(status().isTooManyRequests()).andExpect(header().exists("Retry-After"));
confirm(code, batch, 200);
assertThat(confirm(code, batch, 429).path("code").asText()).isEqualTo("RATE_LIMITED");
perform(auth(get(BASE + "/" + code + "/document")), 200);
assertThat(perform(auth(get(BASE + "/" + code + "/document")), 429)
.path("code").asText()).isEqualTo("RATE_LIMITED");
perform(body(auth(post("/api/cad/workspace/projects")), Map.of("name", "CAD 额度独立")), 200);
User other = users.login("pcb-rate-other@example.invalid");
token = tokens.issue(other.getId(), other.getSessionVersion());
String another = create("另一账号额度");
confirm(another, upload(another, 0, new byte[] {2}), 200);
perform(auth(get(BASE + "/" + another + "/document")), 200);
} finally {
limitProperties.setPerMinute(original);
limitProperties.setEnabled(wasEnabled);
}
}
@Test
void duplicateNamesStablePaginationAndDeletedFilteringPreserveMetadata() throws Exception {
String first = create("控制板");
String second = create("控制板");
jdbc.update("UPDATE pcb_project SET updated_at=?", ProjectSupport.now().minusDays(1));
JsonNode page = perform(auth(get(BASE + "?page=1&size=1&keyword=控制")), 200).path("data");
assertThat(page.path("total").asInt()).isEqualTo(2);
assertThat(page.path("items").get(0).path("pcbProjectCode").asText()).isEqualTo(second);
assertThat(perform(auth(get(BASE + "?page=2&size=1&keyword=控制")), 200)
.path("data").path("items").get(0).path("pcbProjectCode").asText()).isEqualTo(first);
perform(body(auth(patch(BASE + "/" + first)), Map.of("description", "待清空")), 200);
JsonNode cleared = perform(body(auth(patch(BASE + "/" + first)), Map.of("description", "")), 200).path("data");
assertThat(cleared.path("description").asText()).isEmpty();
assertThat(cleared.path("savedAt").isNull()).isTrue();
perform(auth(delete(BASE + "/" + second)), 200);
assertThat(perform(auth(get(BASE)), 200).path("data").path("total").asInt()).isEqualTo(1);
}
@Test
void staleVersionCannotObtainNewUploadCredentialsAndLogoutRevokesPcbAccess() throws Exception {
String code = create("登录与版本");
confirm(code, upload(code, 0, new byte[] {1}), 200);
assertThat(perform(body(auth(post(BASE + "/" + code + "/uploads/signature")),
Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 0)), 409)
.path("code").asText()).isEqualTo("PCB_VERSION_CONFLICT");
perform(auth(post("/api/auth/logout")), 200);
perform(auth(get(BASE + "/" + code)), 401);
perform(auth(get("/api/users/me")), 401);
}
@Test
void validatesMetadataLimitsAndStorageDisabledWithoutBlockingProjectDeletion() throws Exception {
perform(body(auth(post(BASE)), Map.of("name", " ")), 400);
String code = create("参数检查");
perform(body(auth(patch(BASE + "/" + code)), Map.of()), 400);
perform(body(auth(patch(BASE + "/" + code)), Map.of("name", " ")), 400);
perform(auth(get(BASE + "?page=0")), 400);
perform(auth(get(BASE + "?size=101")), 400);
perform(auth(get(BASE + "?keyword=" + "a".repeat(101))), 400);
properties.setMaxFileBytes(1);
assertThat(perform(body(auth(post(BASE + "/" + code + "/uploads/signature")),
Map.of("fileName", "test.zip", "sizeBytes", 2, "expectedVersion", 0)), 413).path("code").asText()).isEqualTo("PCB_FILE_TOO_LARGE");
properties.getOss().setEnabled(false);
assertThat(perform(body(auth(post(BASE + "/" + code + "/uploads/signature")),
Map.of("fileName", "test.zip", "sizeBytes", 1, "expectedVersion", 0)), 503).path("code").asText()).isEqualTo("PCB_STORAGE_UNAVAILABLE");
perform(auth(delete(BASE + "/" + code)), 200);
}
@ParameterizedTest
@ValueSource(strings = {"../project.zip", "dir/project.zip", "dir\\project.zip", "test.step", ".zip", "test.zip\n", "test\u0000.zip"})
void rejectsNonZipOrUnsafeFileNames(String fileName) throws Exception {
String code = create("文件名检查");
perform(body(auth(post(BASE + "/" + code + "/uploads/signature")),
Map.of("fileName", fileName, "sizeBytes", 1, "expectedVersion", 0)), 400);
}
@ParameterizedTest
@ValueSource(strings = {"\"1\"", "1.5", "null", "-1", "9223372036854775808"})
void rejectsCoercedOrInvalidNumericInput(String number) throws Exception {
String code = create("数字检查");
for (String input : List.of(
"{\"fileName\":\"test.zip\",\"sizeBytes\":" + number + ",\"expectedVersion\":0}",
"{\"fileName\":\"test.zip\",\"sizeBytes\":1,\"expectedVersion\":" + number + "}")) {
perform(auth(post(BASE + "/" + code + "/uploads/signature")).contentType(MediaType.APPLICATION_JSON).content(input), 400);
}
}
@Test
void acceptsUppercaseZipButRejectsEmptyAndOversizedMetadata() throws Exception {
String code = create("边界检查");
perform(body(auth(post(BASE + "/" + code + "/uploads/signature")),
Map.of("fileName", "工程.ZIP", "sizeBytes", 1, "expectedVersion", 0)), 200);
perform(body(auth(post(BASE + "/" + code + "/uploads/signature")),
Map.of("fileName", "工程.zip", "sizeBytes", 0, "expectedVersion", 0)), 400);
perform(body(auth(post(BASE)), Map.of("name", "a".repeat(101))), 400);
perform(body(auth(patch(BASE + "/" + code)), Map.of("description", "a".repeat(2001))), 400);
perform(body(auth(post(BASE + "/" + code + "/uploads/signature")),
Map.of("fileName", "a".repeat(252) + ".zip", "sizeBytes", 1, "expectedVersion", 0)), 400);
}
@Test
void authenticationCorsNoStoreAndOpenApiExposeAllEightOperations() throws Exception {
mvc.perform(get(BASE)).andExpect(status().isUnauthorized()).andExpect(header().string("Cache-Control", "no-store"));
mvc.perform(auth(get(BASE)).header("Origin", "https://dev-vibemake.robotquan.com"))
.andExpect(status().isOk()).andExpect(header().string("Access-Control-Allow-Origin", "https://dev-vibemake.robotquan.com"))
.andExpect(header().string("Cache-Control", "no-store"));
JsonNode spec = perform(get("/v3/api-docs"), 200);
JsonNode paths = spec.path("paths");
assertThat(paths.path(BASE).has("get")).isTrue();
assertThat(paths.path(BASE).has("post")).isTrue();
assertThat(paths.path(BASE + "/{pcbProjectCode}").has("get")).isTrue();
assertThat(paths.path(BASE + "/{pcbProjectCode}").has("patch")).isTrue();
assertThat(paths.path(BASE + "/{pcbProjectCode}").has("delete")).isTrue();
assertThat(paths.path(BASE + "/{pcbProjectCode}/uploads/signature").has("post")).isTrue();
assertThat(paths.path(BASE + "/{pcbProjectCode}/document").has("get")).isTrue();
assertThat(paths.path(BASE + "/{pcbProjectCode}/document").has("put")).isTrue();
// PCB、CAD 与 Git 项目使用独立 DTO,避免 OpenAPI 模型相互污染。
JsonNode schemas = spec.path("components").path("schemas");
assertThat(schemas.path("PcbProjectView").path("properties").has("pcbProjectCode")).isTrue();
assertThat(schemas.path("PcbProjectView").path("properties").has("coverUrl")).isTrue();
assertThat(schemas.path("PcbCreateProjectInput").path("properties").has("coverUrl")).isTrue();
assertThat(schemas.path("PcbUpdateProjectInput").path("properties").has("coverUrl")).isTrue();
assertThat(schemas.path("PcbProjectView").path("properties").has("projectCode")).isFalse();
assertThat(schemas.path("PcbProjectView").path("properties").has("cadProjectCode")).isFalse();
assertThat(schemas.path("CadProjectView").path("properties").has("cadProjectCode")).isTrue();
for (String name : List.of("PcbProjectView", "PcbUploadSignature", "PcbSaveResult", "PcbDocumentView")) {
assertThat(schemas.path(name).path("properties").has("id")).isFalse();
assertThat(schemas.path(name).path("properties").has("ownerUserId")).isFalse();
assertThat(schemas.path(name).path("properties").has("pcbProjectId")).isFalse();
}
assertThat(schemas.path("ProjectView").path("properties").has("projectCode")).isTrue();
assertThat(schemas.path("ProjectView").path("properties").has("pcbProjectCode")).isFalse();
}
}
@@ -15,7 +15,8 @@ final class SchemaSupport {
Files.readString(path)
+ "\n"
+ Files.readString(path.resolveSibling("admin-database.md"))
+ "\n" + Files.readString(path.resolveSibling("cad-database.md"));
+ "\n" + Files.readString(path.resolveSibling("cad-database.md"))
+ "\n" + Files.readString(path.resolveSibling("pcb-database.md"));
Matcher matcher = Pattern.compile("CREATE TABLE [\\s\\S]*?;").matcher(content);
jdbc.execute("DROP ALL OBJECTS");
int tables = 0;
@@ -33,6 +34,6 @@ final class SchemaSupport {
jdbc.execute(ddl);
tables++;
}
if (tables != 9) throw new IllegalStateException("必须包含九张业务与审计表");
if (tables != 11) throw new IllegalStateException("必须包含十一张业务与审计表");
}
}
@@ -1271,7 +1271,7 @@ class WorkflowTest {
"PROJECT_COMMENT",
"PROJECT_LIKE",
"PROJECT_IMPORT_TASK", "REPOSITORY_WRITE_OPERATION", "PROJECT_GIT_TOKEN",
"CAD_PROJECT", "CAD_PROJECT_UPLOAD");
"CAD_PROJECT", "CAD_PROJECT_UPLOAD", "PCB_PROJECT", "PCB_PROJECT_UPLOAD");
}
@Test
@@ -0,0 +1,59 @@
package com.linkerbot.vibemake.bean;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import jakarta.validation.constraints.*;
import java.io.IOException;
import java.time.LocalDateTime;
import java.util.Map;
public final class PcbContracts {
private PcbContracts() {}
public record PcbCreateProjectInput(
@NotBlank @Size(max = 100) String name,
@Size(max = 2000) String description,
@Size(max = 2048) String coverUrl) {}
public record PcbUpdateProjectInput(
@Size(min = 1, max = 100) String name,
@Size(max = 2000) String description,
@Size(max = 2048) String coverUrl) {}
public record PcbUploadInput(
@NotBlank @Size(max = 255) String fileName,
@NotNull @Positive @JsonDeserialize(using = StrictLongDeserializer.class) Long sizeBytes,
@NotNull @PositiveOrZero @JsonDeserialize(using = StrictLongDeserializer.class) Long expectedVersion) {}
public record PcbConfirmInput(@NotBlank @Size(max = 32) String uploadCode) {}
public record PcbProjectView(
String pcbProjectCode, String name, String description, String coverUrl, boolean hasDocument,
long version, String fileName, long sizeBytes, LocalDateTime savedAt,
LocalDateTime createdAt, LocalDateTime updatedAt) {}
public record PcbUploadSignature(
String uploadCode, String uploadUrl, Map<String, String> formFields,
LocalDateTime expiresAt) {}
public record PcbSaveResult(String pcbProjectCode, long version, LocalDateTime savedAt) {}
/** 普通 OSS/CDN 文件地址不设置业务过期时间,expiresAt 固定为 null,与 CAD 接口约定一致。 */
public record PcbDocumentView(
String downloadUrl, LocalDateTime expiresAt, long version,
String fileName, long sizeBytes) {}
/** 文件大小和版本必须是真正的 JSON 整数,拒绝小数截断及字符串自动转换。 */
public static final class StrictLongDeserializer extends JsonDeserializer<Long> {
@Override
public Long deserialize(JsonParser parser, DeserializationContext context) throws IOException {
if (!parser.hasToken(JsonToken.VALUE_NUMBER_INT)) {
return (Long) context.handleUnexpectedToken(Long.class, parser);
}
return parser.getLongValue();
}
}
}
@@ -0,0 +1,25 @@
package com.linkerbot.vibemake.bean.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@TableName("pcb_project")
public class PcbProject extends BaseEntity {
private String pcbProjectCode;
private Long ownerUserId;
private String name;
private String description;
/** 平台 OSS 封面保存无环境前缀的相对路径,对外返回完整 URL。 */
private String coverUrl;
/** 环境相对路径,以 /pcb-projects/ 开头;访问 OSS 时再补当前环境根目录。 */
private String documentObjectKey;
private String fileName;
private Long sizeBytes;
private Long version;
private LocalDateTime savedAt;
private Boolean deleted;
}
@@ -0,0 +1,22 @@
package com.linkerbot.vibemake.bean.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@TableName("pcb_project_upload")
public class PcbProjectUpload extends BaseEntity {
private String uploadCode;
private Long pcbProjectId;
private Long expectedVersion;
/** 环境相对路径,不保存 Bucket、域名或环境根目录。 */
private String objectKey;
private String fileName;
private Long sizeBytes;
private LocalDateTime expiresAt;
private Long savedVersion;
private LocalDateTime savedAt;
}
@@ -45,6 +45,10 @@ public class LimitProperties {
values.put("cad-sign", 20);
values.put("cad-save", 30);
values.put("cad-read", 60);
values.put("pcb-create", 5);
values.put("pcb-sign", 20);
values.put("pcb-save", 30);
values.put("pcb-read", 60);
values.put("comment", 10);
values.put("like", 60);
return values;
@@ -0,0 +1,41 @@
package com.linkerbot.vibemake.service.config;
import jakarta.validation.Valid;
import jakarta.validation.constraints.*;
import java.time.Duration;
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
@Getter
@Setter
@Validated
@Component
@ConfigurationProperties(prefix = "vibemake.pcb")
public class PcbProperties {
@Valid @NotNull
private OssSettings oss = new OssSettings();
@Positive @Max(5368709120L)
private long maxFileBytes = 256L * 1024 * 1024;
@NotNull
private Duration uploadValidity = Duration.ofMinutes(15);
/** PCB 独立开关,连接参数统一使用 vibemake.oss。 */
@Getter
@Setter
public static class OssSettings {
private boolean enabled;
}
@AssertTrue(message = "PCB 上传签名有效期必须在 1 秒至 7 天之间")
public boolean isValidityValid() {
return valid(uploadValidity);
}
private boolean valid(Duration duration) {
return duration != null && duration.compareTo(Duration.ofSeconds(1)) >= 0
&& duration.compareTo(Duration.ofDays(7)) <= 0;
}
}
@@ -0,0 +1,12 @@
package com.linkerbot.vibemake.service.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.linkerbot.vibemake.bean.entity.PcbProject;
import org.apache.ibatis.annotations.*;
@Mapper
public interface PcbProjectMapper extends BaseMapper<PcbProject> {
@Select("SELECT * FROM pcb_project WHERE pcb_project_code = #{code} "
+ "AND owner_user_id = #{userId} AND deleted = 0 FOR UPDATE")
PcbProject lockOwner(@Param("userId") long userId, @Param("code") String code);
}
@@ -0,0 +1,12 @@
package com.linkerbot.vibemake.service.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.linkerbot.vibemake.bean.entity.PcbProjectUpload;
import org.apache.ibatis.annotations.*;
@Mapper
public interface PcbProjectUploadMapper extends BaseMapper<PcbProjectUpload> {
@Select("SELECT * FROM pcb_project_upload WHERE upload_code = #{code} "
+ "AND pcb_project_id = #{projectId} FOR UPDATE")
PcbProjectUpload lockUpload(@Param("projectId") long projectId, @Param("code") String code);
}
@@ -70,6 +70,7 @@ public class OssResourcePaths {
if (!path.startsWith("/project-covers/") && !path.startsWith("/urdf/")
&& !path.startsWith("/project-resources/")
&& !path.startsWith("/cad-projects/")
&& !path.startsWith("/pcb-projects/")
&& !path.startsWith("/readme-images/")) throw invalidPath();
String relative = path.substring(1);
if (relative.endsWith("/")) relative = relative.substring(0, relative.length() - 1);
@@ -0,0 +1,118 @@
package com.linkerbot.vibemake.service.pcb;
import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.DefaultCredentialProvider;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.model.*;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.linkerbot.vibemake.common.BusinessException;
import com.linkerbot.vibemake.service.config.PcbProperties;
import com.linkerbot.vibemake.service.config.OssProperties;
import com.linkerbot.vibemake.service.oss.OssPostSigner;
import com.linkerbot.vibemake.service.oss.OssResourcePaths;
import jakarta.annotation.PreDestroy;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ContentDisposition;
import org.springframework.stereotype.Component;
@Component
public class AliyunPcbObjectStore implements PcbObjectStore {
private static final Logger log = LoggerFactory.getLogger(AliyunPcbObjectStore.class);
private final PcbProperties properties;
private final OssProperties oss;
private final OssPostSigner signer;
private final OssResourcePaths paths;
private OSS client;
@Autowired
public AliyunPcbObjectStore(PcbProperties properties, OssProperties oss, ObjectMapper json) {
this(properties, oss, json, null);
}
AliyunPcbObjectStore(PcbProperties properties, OssProperties oss, ObjectMapper json, OSS client) {
this.properties = properties;
this.oss = oss;
this.signer = new OssPostSigner(oss, json);
this.paths = new OssResourcePaths(oss);
this.client = client;
}
private void requireConfiguration() {
if (!properties.getOss().isEnabled()) throw new BusinessException(503, "PCB_STORAGE_UNAVAILABLE", "PCB 文件存储暂未开启");
if (!oss.hasValidStorageConfiguration()) {
log.error("PCB OSS 连接配置不完整 bucket={} region={}", oss.getBucket(), oss.getRegion());
throw new BusinessException(503, "PCB_STORAGE_UNSAFE", "PCB 文件存储连接配置异常,请联系管理员");
}
}
private synchronized OSS client() {
requireConfiguration();
if (client == null) {
ClientBuilderConfiguration configuration = new ClientBuilderConfiguration();
configuration.setSignatureVersion(SignVersion.V4);
configuration.setConnectionTimeout(5000);
configuration.setSocketTimeout(30000);
configuration.setMaxErrorRetry(1);
client = OSSClientBuilder.create().endpoint(oss.resolvedEndpoint()).region(oss.getRegion())
.credentialsProvider(new DefaultCredentialProvider(oss.getAccessKeyId(), oss.getAccessKeySecret()))
.clientConfiguration(configuration).build();
}
return client;
}
@Override
public SignedUpload signUpload(String objectKey, String fileName, long sizeBytes, Duration validity) {
// 签名仅做本地计算,不查询 Bucket 配置或对象 ACL。
requireConfiguration();
OssPostSigner.SignedPost post = signer.signObject(objectKey, "application/zip",
sizeBytes, validity, disposition(fileName));
return new SignedUpload(oss.uploadUrl(), post.formFields(), post.expiresAt());
}
@Override
public long size(String objectKey) {
try {
return client().getObjectMetadata(oss.getBucket(), objectKey).getContentLength();
} catch (OSSException error) {
if ("NoSuchKey".equals(error.getErrorCode())) {
log.warn("PCB 上传对象尚不存在 objectKey={} ossRequestId={}", objectKey, error.getRequestId());
throw new BusinessException(409, "PCB_FILE_MISSING", "工程文件尚未上传完成");
}
throw failure("head", objectKey, error);
} catch (ClientException error) {
throw transportFailure("head", objectKey, error);
}
}
@Override
public String documentUrl(String objectKey) {
requireConfiguration();
return paths.publicUrl(objectKey);
}
private String disposition(String fileName) {
return ContentDisposition.attachment().filename(fileName, StandardCharsets.UTF_8).build().toString();
}
private BusinessException failure(String operation, String key, OSSException error) {
log.error("PCB OSS 操作失败 operation={} objectKey={} ossCode={} ossRequestId={}",
operation, key, error.getErrorCode(), error.getRequestId());
return new BusinessException(502, "PCB_OSS_ERROR", "PCB 文件存储访问失败,请稍后重试");
}
private BusinessException transportFailure(String operation, String key, ClientException error) {
// SDK 异常正文可能带签名 URL,仅记录异常类型。
log.error("PCB OSS 网络异常 operation={} objectKey={} errorType={}",
operation, key, error.getClass().getSimpleName());
return new BusinessException(502, "PCB_OSS_ERROR", "PCB 文件存储访问失败,请稍后重试");
}
@PreDestroy
public synchronized void close() {
if (client != null) client.shutdown();
}
}
@@ -0,0 +1,16 @@
package com.linkerbot.vibemake.service.pcb;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.Map;
/** 入参为包含环境根目录的真实 OSS key;数据库引用由业务层通过 OssResourcePaths 转换。权限由 Bucket/CDN 决定。 */
public interface PcbObjectStore {
record SignedUpload(String uploadUrl, Map<String, String> formFields, LocalDateTime expiresAt) {}
SignedUpload signUpload(String objectKey, String fileName, long sizeBytes, Duration validity);
long size(String objectKey);
String documentUrl(String objectKey);
}
@@ -0,0 +1,245 @@
package com.linkerbot.vibemake.service.pcb;
import static com.linkerbot.vibemake.service.support.ProjectSupport.now;
import static com.linkerbot.vibemake.service.support.ProjectSupport.pageCheck;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.linkerbot.vibemake.bean.PcbContracts.*;
import com.linkerbot.vibemake.bean.entity.PcbProject;
import com.linkerbot.vibemake.bean.entity.PcbProjectUpload;
import com.linkerbot.vibemake.common.*;
import com.linkerbot.vibemake.service.config.PcbProperties;
import com.linkerbot.vibemake.service.oss.OssResourcePaths;
import com.linkerbot.vibemake.service.mapper.PcbProjectMapper;
import com.linkerbot.vibemake.service.mapper.PcbProjectUploadMapper;
import com.linkerbot.vibemake.service.state.RateLimits;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.Locale;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;
@Service
@RequiredArgsConstructor
public class PcbProjectService {
private static final Logger log = LoggerFactory.getLogger(PcbProjectService.class);
private final PcbProjectMapper projects;
private final PcbProjectUploadMapper uploads;
private final PcbProperties properties;
private final OssResourcePaths paths;
private final PcbObjectStore storage;
private final TransactionTemplate transactions;
private final RateLimits limits;
public PageResponse<PcbProjectView> list(long userId, String keyword, long page, long size) {
pageCheck(page, size);
if (keyword != null && keyword.length() > 100) throw BusinessException.badRequest("搜索词最多 100 个字符");
String search = keyword == null ? "" : keyword.trim();
Page<PcbProject> result = projects.selectPage(new Page<>(page, size),
new LambdaQueryWrapper<PcbProject>().eq(PcbProject::getOwnerUserId, userId)
.eq(PcbProject::getDeleted, false).like(!search.isEmpty(), PcbProject::getName, search)
.orderByDesc(PcbProject::getUpdatedAt).orderByDesc(PcbProject::getId));
return new PageResponse<>(result.getRecords().stream().map(this::view).toList(), page, size, result.getTotal());
}
public PcbProjectView create(long userId, PcbCreateProjectInput input) {
limits.operation("pcb-create", userId);
PcbProject project = new PcbProject();
project.setOwnerUserId(userId);
project.setName(name(input.name()));
project.setDescription(input.description() == null ? "" : input.description().trim());
project.setCoverUrl(paths.coverStorage(input.coverUrl()));
project.setDocumentObjectKey("");
project.setFileName("");
project.setSizeBytes(0L);
project.setVersion(0L);
project.setDeleted(false);
project.setCreatedAt(now());
project.setUpdatedAt(project.getCreatedAt());
for (int attempt = 0; attempt < 5; attempt++) {
project.setPcbProjectCode(ProjectCodes.next());
try {
projects.insert(project);
log.info("创建 PCB 项目 pcbProjectCode={}", project.getPcbProjectCode());
return view(project);
} catch (DuplicateKeyException error) {
project.setId(null);
}
}
throw new BusinessException(503, "PCB_CODE_BUSY", "项目编码分配繁忙,请稍后重试");
}
public PcbProjectView detail(long userId, String code) {
return view(owner(userId, code));
}
public PcbProjectView update(long userId, String code, PcbUpdateProjectInput input) {
if (input.name() == null && input.description() == null && input.coverUrl() == null)
throw BusinessException.badRequest("请提供名称、描述或封面");
PcbProjectView result = transactions.execute(status -> {
PcbProject project = lockedOwner(userId, code);
if (input.name() != null) project.setName(name(input.name()));
if (input.description() != null) project.setDescription(input.description().trim());
if (input.coverUrl() != null) project.setCoverUrl(paths.coverStorage(input.coverUrl()));
project.setUpdatedAt(now());
projects.update(null, new LambdaUpdateWrapper<PcbProject>().eq(PcbProject::getId, project.getId())
.set(PcbProject::getName, project.getName()).set(PcbProject::getDescription, project.getDescription())
.set(input.coverUrl() != null, PcbProject::getCoverUrl, project.getCoverUrl())
.set(PcbProject::getUpdatedAt, project.getUpdatedAt()));
return view(project);
});
log.info("修改 PCB 项目信息 pcbProjectCode={} coverChanged={}", code, input.coverUrl() != null);
return result;
}
public void delete(long userId, String code) {
transactions.executeWithoutResult(status -> {
PcbProject project = lockedOwner(userId, code);
projects.update(null, new LambdaUpdateWrapper<PcbProject>().eq(PcbProject::getId, project.getId())
.set(PcbProject::getDeleted, true).set(PcbProject::getUpdatedAt, now()));
});
log.info("删除 PCB 项目 pcbProjectCode={}", code);
}
public PcbUploadSignature sign(long userId, String code, PcbUploadInput input) {
PcbProject project = owner(userId, code);
limits.operation("pcb-sign", userId);
checkFile(input);
checkVersion(project, input.expectedVersion());
String uploadCode = Codes.next();
String path = "/pcb-projects/" + code + "/" + uploadCode + "/project.zip";
PcbObjectStore.SignedUpload signature = storage.signUpload(paths.objectKey(path), input.fileName(), input.sizeBytes(), properties.getUploadValidity());
transactions.executeWithoutResult(status -> {
PcbProject current = lockedOwner(userId, code);
checkVersion(current, input.expectedVersion());
PcbProjectUpload upload = new PcbProjectUpload();
upload.setUploadCode(uploadCode);
upload.setPcbProjectId(current.getId());
upload.setExpectedVersion(input.expectedVersion());
upload.setObjectKey(path);
upload.setFileName(input.fileName());
upload.setSizeBytes(input.sizeBytes());
upload.setExpiresAt(signature.expiresAt());
upload.setCreatedAt(now());
upload.setUpdatedAt(upload.getCreatedAt());
uploads.insert(upload);
});
log.info("签发 PCB 上传 pcbProjectCode={} uploadCode={} expectedVersion={} sizeBytes={}",
code, uploadCode, input.expectedVersion(), input.sizeBytes());
return new PcbUploadSignature(uploadCode, signature.uploadUrl(), signature.formFields(), signature.expiresAt());
}
public PcbSaveResult confirm(long userId, String code, String uploadCode) {
PcbProject project = owner(userId, code);
limits.operation("pcb-save", userId);
PcbProjectUpload upload = uploads.selectOne(new LambdaQueryWrapper<PcbProjectUpload>()
.eq(PcbProjectUpload::getPcbProjectId, project.getId()).eq(PcbProjectUpload::getUploadCode, uploadCode));
if (upload == null) throw BusinessException.notFound();
// HEAD 在事务之外执行,远程访问期间不占数据库行锁。已确认批次重试不再依赖 OSS。
if (upload.getSavedVersion() == null) {
checkExpiry(code, upload);
checkVersion(project, upload.getExpectedVersion());
long actualBytes = storage.size(paths.objectKey(upload.getObjectKey()));
if (actualBytes != upload.getSizeBytes()) {
log.warn("PCB 文件大小不符 pcbProjectCode={} uploadCode={} expectedBytes={} actualBytes={}",
code, uploadCode, upload.getSizeBytes(), actualBytes);
throw new BusinessException(409, "PCB_FILE_SIZE_MISMATCH", "工程文件大小不符,请重新上传");
}
}
PcbSaveResult result = transactions.execute(status -> {
PcbProject current = lockedOwner(userId, code);
PcbProjectUpload pending = uploads.lockUpload(current.getId(), uploadCode);
if (pending == null) throw BusinessException.notFound();
if (pending.getSavedVersion() != null) return receipt(code, pending);
checkExpiry(code, pending);
checkVersion(current, pending.getExpectedVersion());
long version = Math.addExact(current.getVersion(), 1L);
// 与 DATETIME(3) 一致,保证首次回执和数据库重放回执完全相同。
LocalDateTime savedAt = now().truncatedTo(ChronoUnit.MILLIS);
String path = paths.storagePath(pending.getObjectKey());
int changed = projects.update(null, new LambdaUpdateWrapper<PcbProject>()
.eq(PcbProject::getId, current.getId()).eq(PcbProject::getDeleted, false)
.eq(PcbProject::getVersion, pending.getExpectedVersion())
.set(PcbProject::getDocumentObjectKey, path)
.set(PcbProject::getFileName, pending.getFileName()).set(PcbProject::getSizeBytes, pending.getSizeBytes())
.set(PcbProject::getVersion, version).set(PcbProject::getSavedAt, savedAt).set(PcbProject::getUpdatedAt, savedAt));
if (changed != 1) throw new BusinessException(409, "PCB_VERSION_CONFLICT", "项目已发生变化,请刷新后重试");
pending.setSavedVersion(version);
pending.setObjectKey(path);
pending.setSavedAt(savedAt);
pending.setUpdatedAt(savedAt);
if (uploads.updateById(pending) != 1) throw new IllegalStateException("PCB 上传批次确认失败");
return receipt(code, pending);
});
log.info("确认 PCB 保存 pcbProjectCode={} uploadCode={} version={}", code, uploadCode, result.version());
return result;
}
public PcbDocumentView document(long userId, String code) {
PcbProject project = owner(userId, code);
limits.operation("pcb-read", userId);
if (project.getVersion() == 0) throw new BusinessException(404, "PCB_DOCUMENT_NOT_FOUND", "项目尚未保存工程文件");
String downloadUrl = storage.documentUrl(paths.objectKey(project.getDocumentObjectKey()));
log.info("读取 PCB 文件地址 pcbProjectCode={} version={}", code, project.getVersion());
return new PcbDocumentView(downloadUrl, null, project.getVersion(), project.getFileName(), project.getSizeBytes());
}
private PcbProject owner(long userId, String code) {
PcbProject project = projects.selectOne(new LambdaQueryWrapper<PcbProject>()
.eq(PcbProject::getPcbProjectCode, code).eq(PcbProject::getOwnerUserId, userId).eq(PcbProject::getDeleted, false));
if (project == null) throw BusinessException.notFound();
return project;
}
private PcbProject lockedOwner(long userId, String code) {
PcbProject project = projects.lockOwner(userId, code);
if (project == null) throw BusinessException.notFound();
return project;
}
private PcbProjectView view(PcbProject project) {
return new PcbProjectView(project.getPcbProjectCode(), project.getName(), project.getDescription(), paths.coverUrl(project.getCoverUrl()), project.getVersion() > 0,
project.getVersion(), project.getFileName(), project.getSizeBytes(), project.getSavedAt(), project.getCreatedAt(), project.getUpdatedAt());
}
private PcbSaveResult receipt(String code, PcbProjectUpload upload) {
return new PcbSaveResult(code, upload.getSavedVersion(), upload.getSavedAt());
}
private String name(String value) {
if (value == null || value.isBlank() || value.trim().length() > 100) throw BusinessException.badRequest("项目名称须为 1 至 100 个字符");
return value.trim();
}
private void checkFile(PcbUploadInput input) {
String name = input.fileName();
if (name == null || name.isBlank() || name.length() > 255 || name.indexOf('/') >= 0
|| name.indexOf('\\') >= 0 || name.chars().anyMatch(Character::isISOControl)
|| !name.toLowerCase(Locale.ROOT).endsWith(".zip") || name.length() <= 4
|| input.sizeBytes() == null || input.sizeBytes() <= 0 || input.expectedVersion() == null || input.expectedVersion() < 0) {
throw new BusinessException(400, "PCB_INVALID_FILE", "请上传名称合法的非空 .zip 工程文件");
}
if (input.sizeBytes() > properties.getMaxFileBytes()) throw new BusinessException(413, "PCB_FILE_TOO_LARGE", "工程文件超过大小限制");
}
private void checkVersion(PcbProject project, long expectedVersion) {
if (project.getVersion() != expectedVersion) {
log.warn("PCB 保存版本冲突 pcbProjectCode={} expectedVersion={} currentVersion={}", project.getPcbProjectCode(), expectedVersion, project.getVersion());
throw new BusinessException(409, "PCB_VERSION_CONFLICT", "项目已有更新,请保留本地修改并刷新后处理");
}
}
private void checkExpiry(String code, PcbProjectUpload upload) {
if (!upload.getExpiresAt().isAfter(now())) {
log.warn("PCB 上传批次过期 pcbProjectCode={} uploadCode={} expiresAt={}",
code, upload.getUploadCode(), upload.getExpiresAt());
throw new BusinessException(409, "PCB_UPLOAD_EXPIRED", "上传批次已过期,请重新申请上传");
}
}
}
@@ -62,7 +62,8 @@ public class HttpSafetyFilter extends OncePerRequestFilter {
boolean read = "GET".equals(method) || "HEAD".equals(method);
boolean acquired = false;
try {
if (path.contains("/auth/") || path.endsWith("/signature") || path.startsWith("/api/cad/"))
if (path.contains("/auth/") || path.endsWith("/signature")
|| path.startsWith("/api/cad/") || path.startsWith("/api/pcb/"))
response.setHeader("Cache-Control", "no-store");
String ip = addresses.resolve(request);
if (path.equals("/api/auth/captcha")) limits.request("captcha", ip);
@@ -97,6 +97,20 @@ class OssResourcePathsTest {
assertThatThrownBy(() -> paths.objectKey("/urdf/../other/a.urdf")).isInstanceOf(BusinessException.class);
}
@Test
void pcbArchivesKeepEnvironmentIsolationAndRejectUnsafePaths() {
String path = "/pcb-projects/7m4k9x2p8q6r/" + "a".repeat(32) + "/project.zip";
assertThat(paths.storagePath("vibemake_dev" + path)).isEqualTo(path);
assertThat(paths.objectKey(path)).isEqualTo("vibemake_dev" + path);
assertThat(paths.publicUrl(path)).isEqualTo("https://cdn.example.com/assets/vibemake_dev" + path);
assertThatThrownBy(() -> paths.objectKey("vibemake" + path)).isInstanceOf(BusinessException.class);
assertThatThrownBy(() -> paths.objectKey("/pcb-projects/../other/project.zip")).isInstanceOf(BusinessException.class);
assertThatThrownBy(() -> paths.objectKey("/pcb-projects-evil/code/project.zip")).isInstanceOf(BusinessException.class);
oss.setRootDirectory("vibemake");
assertThat(paths.objectKey(path)).isEqualTo("vibemake" + path);
assertThatThrownBy(() -> paths.objectKey("vibemake_dev" + path)).isInstanceOf(BusinessException.class);
}
@Test
void normalizesEveryProjectBindingBeforeFullSaveWithoutChangingObjectLocations() {
Project project = new Project();
@@ -0,0 +1,166 @@
package com.linkerbot.vibemake.service.pcb;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import com.aliyun.oss.*;
import com.aliyun.oss.model.*;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.linkerbot.vibemake.common.BusinessException;
import com.linkerbot.vibemake.service.config.PcbProperties;
import com.linkerbot.vibemake.service.config.OssProperties;
import com.linkerbot.vibemake.service.support.ProjectSupport;
import jakarta.validation.Validation;
import jakarta.validation.ValidatorFactory;
import java.time.Duration;
import java.util.Base64;
import org.junit.jupiter.api.*;
class AliyunPcbObjectStoreTest {
private final ObjectMapper json = new ObjectMapper();
private final PcbProperties properties = new PcbProperties();
private final OssProperties oss = new OssProperties();
private final OSS sdk = mock(OSS.class);
private AliyunPcbObjectStore storage;
@BeforeEach
void setup() {
properties.getOss().setEnabled(true);
oss.setEnabled(false);
oss.setRegion("cn-beijing");
oss.setBucket("pcb-private-test");
oss.setAccessKeyId("TestKey");
oss.setAccessKeySecret("test-secret");
oss.setRootDirectory("vibemake_dev");
storage = new AliyunPcbObjectStore(properties, oss, json, sdk);
}
@Test
void uploadUsesExistingOssPolicyWithoutOverridingObjectAcl() throws Exception {
PcbObjectStore.SignedUpload result = storage.signUpload("vibemake_dev/pcb-projects/code/batch/project.zip",
"控制板.zip", 1234, Duration.ofMinutes(15));
assertThat(result.uploadUrl()).isEqualTo("https://pcb-private-test.oss-cn-beijing.aliyuncs.com");
assertThat(result.formFields()).containsEntry("x-oss-forbid-overwrite", "true")
.containsEntry("x-oss-content-type", "application/zip")
.containsEntry("content-type", "application/zip")
.doesNotContainKey("x-oss-object-acl");
JsonNode policy = json.readTree(Base64.getDecoder().decode(result.formFields().get("policy")));
assertThat(policy.path("conditions").toString()).contains(
"[\"eq\",\"$x-oss-forbid-overwrite\",\"true\"]",
"[\"content-length-range\",1234,1234]",
"[\"eq\",\"$content-type\",\"application/zip\"]",
"[\"eq\",\"$x-oss-content-type\",\"application/zip\"]",
"[\"eq\",\"$key\",\"vibemake_dev/pcb-projects/code/batch/project.zip\"]",
"[\"eq\",\"$Content-Disposition\"");
assertThat(policy.path("conditions").toString()).doesNotContain("x-oss-object-acl");
assertThat(result.expiresAt()).isBetween(ProjectSupport.now().plusMinutes(14), ProjectSupport.now().plusMinutes(16));
verifyNoInteractions(sdk);
}
@Test
void documentUsesConfiguredPublicCdnAndEnvironmentRootWithoutSigning() {
oss.setPublicBaseUrl("https://cdn.example.com/resources/");
String key = "vibemake_dev/pcb-projects/code/batch/project.zip";
assertThat(storage.documentUrl(key)).isEqualTo("https://cdn.example.com/resources/" + key);
verifyNoInteractions(sdk);
}
@Test
void documentFallsBackToBucketUrlAndRejectsOtherEnvironmentKeys() {
String key = "vibemake_dev/pcb-projects/code/batch/project.zip";
assertThat(storage.documentUrl(key)).isEqualTo(oss.uploadUrl() + "/" + key);
assertThatThrownBy(() -> storage.documentUrl("vibemake/pcb-projects/code/batch/project.zip"))
.isInstanceOfSatisfying(BusinessException.class, error -> assertThat(error.code()).isEqualTo("RESOURCE_PATH_INVALID"));
verifyNoInteractions(sdk);
}
@Test
void signingAndSavingWorkWithoutBucketOrObjectAclReadPermissions() throws Exception {
OSSException denied = new OSSException("denied", "AccessDenied", "request-test", "host", null, null, null);
when(sdk.getBucketAcl(anyString())).thenThrow(denied);
when(sdk.getBucketPolicyStatus(anyString())).thenThrow(denied);
when(sdk.getBucketVersioning(anyString())).thenThrow(denied);
when(sdk.getObjectAcl(anyString(), anyString())).thenThrow(denied);
ObjectMetadata metadata = new ObjectMetadata();
metadata.setContentLength(1234);
when(sdk.getObjectMetadata("pcb-private-test", "key")).thenReturn(metadata);
assertThat(storage.signUpload("key", "x.zip", 1234, Duration.ofMinutes(15)).uploadUrl()).isEqualTo(oss.uploadUrl());
assertThat(storage.size("key")).isEqualTo(1234);
assertThat(storage.documentUrl("vibemake_dev/pcb-projects/code/batch/project.zip"))
.isEqualTo(oss.publicBaseUrl() + "/vibemake_dev/pcb-projects/code/batch/project.zip");
verify(sdk, never()).getBucketAcl(anyString());
verify(sdk, never()).getBucketPolicyStatus(anyString());
verify(sdk, never()).getBucketVersioning(anyString());
verify(sdk, never()).getObjectAcl(anyString(), anyString());
verify(sdk, never()).setBucketAcl(anyString(), any(CannedAccessControlList.class));
verify(sdk, never()).generatePresignedUrl(any(GeneratePresignedUrlRequest.class));
}
@Test
void pcbSwitchDisablesOperationsEvenWithValidSharedSettings() {
properties.getOss().setEnabled(false);
assertThatThrownBy(() -> storage.documentUrl("vibemake_dev/pcb-projects/code/batch/project.zip"))
.isInstanceOfSatisfying(BusinessException.class, error -> assertThat(error.code()).isEqualTo("PCB_STORAGE_UNAVAILABLE"));
verifyNoInteractions(sdk);
}
@Test
void rejectsIncompleteSharedCredentialsEvenWhenPublicUploadsDisabled() {
oss.setAccessKeySecret("");
assertUnsafe(() -> storage.signUpload("key", "x.zip", 1, Duration.ofMinutes(15)));
verifyNoInteractions(sdk);
}
@Test
void missingObjectAndTransportErrorsHaveStableCodes() {
OSSException missing = new OSSException("not found", "NoSuchKey", "request-test", "host", null, null, null);
when(sdk.getObjectMetadata("pcb-private-test", "key")).thenThrow(missing);
assertThatThrownBy(() -> storage.size("key")).isInstanceOfSatisfying(BusinessException.class,
error -> assertThat(error.code()).isEqualTo("PCB_FILE_MISSING"));
doThrow(new ClientException("network")).when(sdk).getObjectMetadata("pcb-private-test", "key");
assertThatThrownBy(() -> storage.size("key")).isInstanceOfSatisfying(BusinessException.class,
error -> assertThat(error.code()).isEqualTo("PCB_OSS_ERROR"));
doThrow(new OSSException("denied")).when(sdk).getObjectMetadata("pcb-private-test", "key");
assertThatThrownBy(() -> storage.size("key"))
.isInstanceOfSatisfying(BusinessException.class, error -> assertThat(error.status()).isEqualTo(502));
}
@Test
void pcbStorageDefaultsToDisabledAndHasBoundedUploadSettings() {
PcbProperties defaults = new PcbProperties();
assertThat(defaults.getOss().isEnabled()).isFalse();
assertThat(defaults.getMaxFileBytes()).isEqualTo(256L * 1024 * 1024);
assertThat(defaults.getUploadValidity()).isEqualTo(Duration.ofMinutes(15));
}
@Test
void validatesSharedCredentialsSizeAndSignatureValidity() {
try (ValidatorFactory factory = Validation.buildDefaultValidatorFactory()) {
assertThat(factory.getValidator().validate(properties)).isEmpty();
assertThat(oss.hasValidStorageConfiguration()).isTrue();
oss.setAccessKeySecret("");
assertThat(oss.hasValidStorageConfiguration()).isFalse();
properties.setUploadValidity(Duration.ZERO);
assertThat(factory.getValidator().validate(properties)).isNotEmpty();
properties.setUploadValidity(null);
assertThat(factory.getValidator().validate(properties)).isNotEmpty();
properties.setUploadValidity(Duration.ofMillis(999));
assertThat(factory.getValidator().validate(properties)).isNotEmpty();
properties.setUploadValidity(Duration.ofMinutes(15));
properties.setUploadValidity(Duration.ofDays(8));
assertThat(factory.getValidator().validate(properties)).isNotEmpty();
properties.setUploadValidity(Duration.ofMinutes(15));
properties.setMaxFileBytes(5368709121L);
assertThat(factory.getValidator().validate(properties)).isNotEmpty();
properties.setMaxFileBytes(0);
assertThat(factory.getValidator().validate(properties)).isNotEmpty();
}
}
private void assertUnsafe(org.assertj.core.api.ThrowableAssert.ThrowingCallable action) {
assertThatThrownBy(action).isInstanceOfSatisfying(BusinessException.class,
error -> assertThat(error.code()).isEqualTo("PCB_STORAGE_UNSAFE"));
}
}