Compare commits

...

62 Commits

Author SHA1 Message Date
codex-bot 1090591503 docs: annotate Foundry source and deployment lifecycle in Chinese [skip ci] 2026-11-16 17:59:10 +08:00
Zayden-Jung 30829eeb86 Merge pull request 'Add canonical canvas edits, identity migration and idempotent resource/AI operations' (#19) from codex/headless-canvas-v1 into main
Foundry Go checks / check (push) Successful in 3m25s
Deploy Foundry Core / deploy (push) Successful in 3m10s
Reviewed-on: #19
2026-11-11 14:53:33 +00:00
codex-bot 506f778ac3 fix(canvas): retain canonical frame rotation across owner changes
Foundry Go checks / check (push) Successful in 3m26s
Foundry Go checks / check (pull_request) Successful in 3m28s
2026-11-11 18:53:06 +08:00
codex-bot 36d69133b8 ci(canvas): verify owning-canvas dissolution and receipt recovery
Foundry Go checks / check (push) Failing after 3m15s
Foundry Go checks / check (pull_request) Failing after 3m8s
2026-11-11 18:42:55 +08:00
codex-bot 5db2bf3c98 ci(canvas): verify the browser migration delivery revision
Foundry Go checks / check (push) Successful in 3m23s
Foundry Go checks / check (pull_request) Successful in 3m18s
2026-11-11 18:06:55 +08:00
codex-bot 3268c57bc6 ci(canvas): verify durable migration coordination with the actual client
Foundry Go checks / check (push) Successful in 3m27s
Foundry Go checks / check (pull_request) Successful in 3m36s
2026-11-11 17:11:14 +08:00
codex-bot d00388504c test(canvas): cover migration admission guards with valid legacy edges
Foundry Go checks / check (push) Successful in 3m36s
Foundry Go checks / check (pull_request) Successful in 3m25s
2026-11-11 16:35:31 +08:00
codex-bot cc3068ace3 test(canvas): verify canonical concurrency and late migration rollback
Foundry Go checks / check (push) Failing after 2m59s
Foundry Go checks / check (pull_request) Failing after 2m55s
2026-11-11 16:29:37 +08:00
codex-bot 1605b5a9d6 ci(canvas): verify managed result copy with durable source files
Foundry Go checks / check (push) Successful in 3m43s
Foundry Go checks / check (pull_request) Successful in 3m36s
2026-11-11 16:09:57 +08:00
codex-bot ca01ea3ea1 ci(canvas): verify host asset display and original generated bytes
Foundry Go checks / check (push) Failing after 3m18s
Foundry Go checks / check (pull_request) Failing after 3m45s
2026-11-11 16:04:44 +08:00
codex-bot 8395baa24f ci(canvas): verify cancellation cursor drain in real client
Foundry Go checks / check (push) Failing after 3m27s
Foundry Go checks / check (pull_request) Failing after 3m25s
2026-11-11 15:55:58 +08:00
codex-bot daec39ead4 ci(canvas): exercise controlled HTTP run polling
Foundry Go checks / check (push) Failing after 3m8s
Foundry Go checks / check (pull_request) Failing after 3m24s
2026-11-11 15:50:45 +08:00
codex-bot 121ce7496c ci(canvas): verify headless AI v2 negotiation fix
Foundry Go checks / check (push) Failing after 3m25s
Foundry Go checks / check (pull_request) Failing after 3m20s
2026-11-11 15:42:24 +08:00
codex-bot c8f3940d26 ci(canvas): pin AI protocol header trace
Foundry Go checks / check (push) Failing after 3m14s
Foundry Go checks / check (pull_request) Failing after 3m23s
2026-11-11 15:35:05 +08:00
codex-bot da6a5f8207 ci(canvas): expose AI admission recovery diagnostics
Foundry Go checks / check (push) Failing after 3m18s
Foundry Go checks / check (pull_request) Failing after 3m23s
2026-11-11 15:29:02 +08:00
codex-bot 6131fb5d7b Verify runtime AI coordination against real HTTP and database state
Foundry Go checks / check (push) Failing after 3m45s
Foundry Go checks / check (pull_request) Failing after 3m12s
2026-11-11 15:13:14 +08:00
codex-bot 28ca98a506 Verify current headless client through the remote HTTP integration runner
Foundry Go checks / check (push) Successful in 3m22s
Foundry Go checks / check (pull_request) Successful in 3m22s
2026-11-11 14:24:48 +08:00
codex-bot 95812c3a96 Verify asset permission revocation and immutable adoption rejection receipts
Foundry Go checks / check (push) Successful in 5m12s
Foundry Go checks / check (pull_request) Successful in 5m0s
2026-11-09 16:36:19 +08:00
codex-bot efa916060a Preserve private asset metadata headers and verify cross-project adoption
Foundry Go checks / check (push) Successful in 3m48s
Foundry Go checks / check (pull_request) Successful in 3m32s
2026-11-09 16:12:36 +08:00
codex-bot cc2ca05cd4 Pin real asset metadata and original byte verification client
Foundry Go checks / check (push) Failing after 3m28s
Foundry Go checks / check (pull_request) Failing after 2m55s
2026-11-09 15:55:20 +08:00
codex-bot be2014cc31 Avoid ambiguous asset metadata and operation receipt routes
Foundry Go checks / check (push) Failing after 3m7s
Foundry Go checks / check (pull_request) Failing after 3m28s
2026-11-09 15:49:58 +08:00
codex-bot 6b07c19728 Expose permission-checked immutable asset metadata for shared depot adoption
Foundry Go checks / check (push) Failing after 6m24s
Foundry Go checks / check (pull_request) Failing after 4m36s
2026-11-09 15:47:19 +08:00
codex-bot 6a0a2e1912 Pin upload Created-response fault injection coverage
Foundry Go checks / check (push) Successful in 3m7s
Foundry Go checks / check (pull_request) Successful in 2m59s
2026-11-09 14:43:25 +08:00
codex-bot 7d7408a0ec Verify scoped image upload and lost receipt recovery with the live headless client
Foundry Go checks / check (push) Failing after 3m5s
Foundry Go checks / check (pull_request) Failing after 3m1s
2026-11-09 14:37:30 +08:00
codex-bot ee04a6372b Pin live partial-scope import and deep-copy integration coverage
Foundry Go checks / check (push) Successful in 4m19s
Foundry Go checks / check (pull_request) Successful in 3m58s
2026-11-09 14:05:21 +08:00
codex-bot d6e877712a Pin corrected Foundry HTTP consumer transport
Foundry Go checks / check (push) Successful in 10m19s
Foundry Go checks / check (pull_request) Successful in 3m41s
2026-11-09 13:50:50 +08:00
codex-bot 6d1a5b5c83 Run pinned Endoleap headless runtime against real HTTP and PostgreSQL in CI
Foundry Go checks / check (push) Failing after 4m1s
Foundry Go checks / check (pull_request) Failing after 4m15s
2026-11-09 13:45:40 +08:00
codex-bot 9cf6e4cedf Bind all canvas element identities to their snapshot owners
Foundry Go checks / check (push) Successful in 2m53s
Foundry Go checks / check (pull_request) Successful in 2m55s
2026-11-09 04:11:26 +08:00
codex-bot ad6ab30b5f Declare snapshot-bound direct canvas membership counts in model streams
Foundry Go checks / check (push) Successful in 5m54s
Foundry Go checks / check (pull_request) Successful in 5m45s
2026-11-09 03:36:37 +08:00
codex-bot 789edcc61b ci: allow cold Go toolchain setup in backend checks
Foundry Go checks / check (push) Successful in 23m24s
Foundry Go checks / check (pull_request) Successful in 23m10s
2026-11-09 02:25:20 +08:00
codex-bot e38254821a Stream negotiated canonical model reads with snapshot framing
Foundry Go checks / check (push) Failing after 10m37s
Foundry Go checks / check (pull_request) Failing after 10m45s
2026-11-09 02:01:46 +08:00
codex-bot ff88865e91 test(canvas): restore a lifetime canceled before its first request
Foundry Go checks / check (push) Successful in 7m0s
Foundry Go checks / check (pull_request) Successful in 5m51s
2026-11-08 04:50:09 +08:00
codex-bot fb1bf4ab85 test(canvas): verify compacted logical coverage and lifecycle records
Foundry Go checks / check (push) Successful in 7m23s
Foundry Go checks / check (pull_request) Successful in 7m40s
2026-11-08 04:36:44 +08:00
codex-bot ca90b3fea3 test(canvas): verify ordered batch receipts and rollback
Foundry Go checks / check (push) Successful in 6m1s
Foundry Go checks / check (pull_request) Successful in 5m52s
2026-11-08 04:28:15 +08:00
codex-bot 31258b995f Avoid duplicate geometry fixture variable in scaled-move coverage
Foundry Go checks / check (push) Successful in 6m34s
Foundry Go checks / check (pull_request) Successful in 3m12s
2026-11-08 02:54:31 +08:00
codex-bot 24b27dcac4 Verify atomic scaled-container unit metadata and inverse writes
Foundry Go checks / check (push) Failing after 4m12s
Foundry Go checks / check (pull_request) Failing after 1m51s
2026-11-08 02:52:29 +08:00
codex-bot d6690c3764 Verify current-owner permissions before moved AI execution
Foundry Go checks / check (push) Successful in 3m4s
Foundry Go checks / check (pull_request) Successful in 2m54s
2026-11-08 01:24:53 +08:00
codex-bot c9bb38454d Preserve relocation context for conflicted AI outputs
Foundry Go checks / check (push) Successful in 3m13s
Foundry Go checks / check (pull_request) Successful in 2m57s
2026-11-08 01:20:06 +08:00
codex-bot 2d4aefbdc0 Remove dependent connections in moved-target deletion fixture
Foundry Go checks / check (push) Successful in 2m51s
Foundry Go checks / check (pull_request) Successful in 3m3s
2026-11-08 01:16:51 +08:00
codex-bot 56b6181598 Resolve canonical AI targets at their current canvas owner
Foundry Go checks / check (push) Failing after 2m49s
Foundry Go checks / check (pull_request) Failing after 2m41s
2026-11-08 01:16:28 +08:00
codex-bot cdf48f1691 Verify AI replan and cancellation completion boundaries
Foundry Go checks / check (push) Successful in 2m54s
Foundry Go checks / check (pull_request) Successful in 2m52s
2026-11-08 01:04:34 +08:00
codex-bot f12c4ad8bd Persist queryable AI action outcomes and zero-effect rejection receipts
Foundry Go checks / check (push) Successful in 2m51s
Foundry Go checks / check (pull_request) Successful in 3m6s
2026-11-08 00:53:11 +08:00
codex-bot 00ff738705 Bind canonical AI admission to the project version vector
Foundry Go checks / check (push) Successful in 2m52s
Foundry Go checks / check (pull_request) Successful in 2m58s
2026-11-08 00:28:13 +08:00
codex-bot fa76773efc Apply canonical AI outputs through scoped identity-checked changes
Foundry Go checks / check (push) Successful in 2m56s
Foundry Go checks / check (pull_request) Successful in 2m47s
2026-11-08 00:23:00 +08:00
codex-bot 0d7fc4dbe5 Preserve staged resource identities and expose upload receipts
Foundry Go checks / check (push) Successful in 2m56s
Foundry Go checks / check (pull_request) Successful in 2m49s
2026-11-07 23:18:20 +08:00
codex-bot bf8763e0de Preserve opaque JSON keys independently of field write guards
Foundry Go checks / check (push) Successful in 2m51s
Foundry Go checks / check (pull_request) Successful in 2m45s
2026-11-07 22:52:31 +08:00
codex-bot 4a89137e38 Embed protocol fixture for isolated integration test binaries
Foundry Go checks / check (push) Successful in 2m42s
Foundry Go checks / check (pull_request) Successful in 2m49s
2026-11-07 22:47:16 +08:00
codex-bot b7499e3815 Verify canonical partition restoration and frontend protocol fixture
Foundry Go checks / check (push) Failing after 3m6s
Foundry Go checks / check (pull_request) Failing after 2m36s
2026-11-07 22:40:39 +08:00
codex-bot 12458e10dc Fix canonical archive writes and retain scoped lifecycle evidence
Foundry Go checks / check (push) Successful in 2m41s
Foundry Go checks / check (pull_request) Successful in 2m40s
2026-11-07 22:34:42 +08:00
codex-bot b85e8bd2ca Add canonical canvas rows, stable identity migration and model operations
Foundry Go checks / check (push) Failing after 2m29s
Foundry Go checks / check (pull_request) Failing after 2m31s
2026-11-07 22:26:06 +08:00
codex-bot 19884b2a90 Stage atomic canvas operation batches and durable receipts
Foundry Go checks / check (push) Successful in 2m40s
Foundry Go checks / check (pull_request) Successful in 2m39s
2026-11-07 22:05:06 +08:00
Zayden-Jung 9f01aa3db8 Merge pull request '移除论文精确计数并优化游标与领域查询 [skip ci]' (#18) from codex/research-cursors into main
Reviewed-on: #18
2026-11-07 09:30:23 +00:00
codex-bot 026ee22c1e Page research without exact counts and bound candidate scans [skip ci] 2026-11-07 17:27:35 +08:00
Zayden-Jung 142c7b2d86 Merge pull request '共享 PostgreSQL 论文只读 API [skip ci]' (#17) from codex/research-api into main
Reviewed-on: #17
2026-11-07 08:23:36 +00:00
codex-bot 9dd166d5de Finalize research API validation and handoff notes [skip ci] 2026-11-07 16:13:36 +08:00
codex-bot 1363792bb0 Read the published research corpus and avoid expensive paging plans [skip ci] 2026-11-07 15:51:17 +08:00
codex-bot 913bf4292b Verify research SQL and read-only permissions in isolated PostgreSQL CI
Foundry Go checks / check (push) Successful in 3m43s
Foundry Go checks / check (pull_request) Successful in 4m1s
2026-11-07 02:44:55 +08:00
codex-bot 028e453d92 Prepare read-only PostgreSQL paper queries and optional Core wiring
Foundry Go checks / check (push) Successful in 3m57s
Foundry Go checks / check (pull_request) Successful in 5m2s
2026-11-07 02:38:28 +08:00
codex-bot 81cf7d9448 Add bounded public research HTTP contract and transport tests
Foundry Go checks / check (push) Successful in 2m54s
Foundry Go checks / check (pull_request) Successful in 2m55s
2026-11-07 01:58:30 +08:00
Zayden-Jung 2207c85ca6 Merge pull request 'Draft: 原子保存跨分区移动的最终坐标' (#16) from codex/member-drop-sync into main
Foundry Go checks / check (push) Successful in 5m42s
Deploy Foundry Core / deploy (push) Successful in 5m18s
Reviewed-on: #16
2026-11-06 14:50:02 +00:00
codex-bot 09c78d3ab8 Accept final member positions in ownership transactions
Foundry Go checks / check (push) Successful in 8m18s
Foundry Go checks / check (pull_request) Successful in 6m16s
2026-11-06 22:46:46 +08:00
Zayden-Jung b2ae48e250 Merge pull request '保留原图并提供单一预览,释放慢传输期间的空间锁' (#15) from codex/canvas-image-preview into main
Foundry Go checks / check (push) Successful in 3m23s
Deploy Foundry Core / deploy (push) Successful in 3m52s
Reviewed-on: #15
2026-11-06 13:55:30 +00:00
129 changed files with 8895 additions and 210 deletions
+12
View File
@@ -1,12 +1,16 @@
# 示例值供部署配置参考,真实 .env/凭据不得提交。公共地址必须是 HTTPS 根 origin。
PUBLIC_ORIGIN=https://api.example.com PUBLIC_ORIGIN=https://api.example.com
DATABASE_URL=postgresql://foundry:replace-me@postgres.internal:5432/foundry_auth DATABASE_URL=postgresql://foundry:replace-me@postgres.internal:5432/foundry_auth
GOOGLE_CLIENT_ID=replace-me.apps.googleusercontent.com GOOGLE_CLIENT_ID=replace-me.apps.googleusercontent.com
GOOGLE_CLIENT_SECRET=replace-me GOOGLE_CLIENT_SECRET=replace-me
# 项目→固定前端回调白名单;生产 HTTPS,开发仅允许回环 HTTP,不能由请求任意指定。
FOUNDRY_PROJECTS='{"notes":"http://localhost:3000/auth/callback","board":"http://localhost:3001/auth/callback"}' FOUNDRY_PROJECTS='{"notes":"http://localhost:3000/auth/callback","board":"http://localhost:3001/auth/callback"}'
# 默认监听回环,容器发布时 release.sh 显式改为 0.0.0.0;PORT 仅决定内部 HTTP 监听。
HOST=127.0.0.1 HOST=127.0.0.1
PORT=8080 PORT=8080
# Optional email verification through TLS SMTP. # Optional email verification through TLS SMTP.
# 邮件配置整组缺省可关闭,部分填写会启动失败;此示例只接受隐式 TLS 465。
SMTP_HOST=smtpdm.aliyun.com SMTP_HOST=smtpdm.aliyun.com
SMTP_PORT=465 SMTP_PORT=465
SMTP_USERNAME=noreply@notice.entroia.com SMTP_USERNAME=noreply@notice.entroia.com
@@ -14,5 +18,13 @@ SMTP_PASSWORD=replace-me
SMTP_FROM=noreply@notice.entroia.com SMTP_FROM=noreply@notice.entroia.com
# Optional Sign in with Slack. # Optional Sign in with Slack.
# Slack 客户端 ID 与 Secret 必须成对配置,回调 URL 由 PUBLIC_ORIGIN 派生。
SLACK_CLIENT_ID=replace-me SLACK_CLIENT_ID=replace-me
SLACK_CLIENT_SECRET=replace-me SLACK_CLIENT_SECRET=replace-me
# Optional shared paper corpus; enable only after PostgreSQL publication.
# Store the real read-only connection string in the protected server research.env.
FOUNDRY_RESEARCH_DATABASE_URL=
FOUNDRY_RESEARCH_SCHEMA=research
# Deployment migration container; independent of database/schema names.
FOUNDRY_POSTGRES_CONTAINER=foundry-postgres
+21 -3
View File
@@ -1,10 +1,13 @@
# 分支推送和 PR 检查:格式/编译、隔离数据库回归、固定版本 headless 客户端以及 HTTP smoke。
name: Foundry Go checks name: Foundry Go checks
on: [push, pull_request] on: [push, pull_request]
jobs: jobs:
check: check:
# 所有构建在此远程 runner 执行;脚本中的 Docker 挂载路径也基于它的工作区。
runs-on: ces-control runs-on: ces-control
timeout-minutes: 10 # Cold toolchain installation can exceed ten minutes on the existing runner.
timeout-minutes: 30
steps: steps:
- uses: actions/checkout@v4 - uses: actions/checkout@v4
- uses: actions/setup-go@v5 - uses: actions/setup-go@v5
@@ -17,6 +20,7 @@ jobs:
test -z "$(gofmt -l cmd internal)" test -z "$(gofmt -l cmd internal)"
go test -mod=readonly ./... go test -mod=readonly ./...
go build -mod=readonly -o bin/foundry ./cmd/foundry go build -mod=readonly -o bin/foundry ./cmd/foundry
# 仅 push 可使用已配置秘密做占位码探测,不能替代真实用户 OAuth 登录。
- name: Check Slack OAuth configuration and endpoint - name: Check Slack OAuth configuration and endpoint
if: gitea.event_name == 'push' if: gitea.event_name == 'push'
env: env:
@@ -68,12 +72,26 @@ jobs:
print("Negative control result:", control if control in known else "unclassified") print("Negative control result:", control if control in known else "unclassified")
sys.exit("Slack client preflight could not verify the configured credentials") sys.exit("Slack client preflight could not verify the configured credentials")
PYSLACK PYSLACK
- name: Verify schema migration in an isolated database # 固定客户端提交避免服务端回归随外部默认分支漂移,下载不使用用户本机凭据。
run: bash deploy/check-schema.sh - name: Fetch pinned headless HTTP integration client
env:
HEADLESS_CLIENT_REVISION: dcbbdad25de7c3b1d6bee317df6074da2c0642eb
run: |
set -eu
mkdir -p .headless-client
curl --fail --silent --show-error --location \
"https://gitea.entroia.com/Zayden-Jung/Endoleap/archive/$HEADLESS_CLIENT_REVISION.tar.gz" \
| tar -xz --strip-components=1 -C .headless-client
test -f .headless-client/tests/headless/foundry.integration.mjs
printf 'Pinned Endoleap client: %s\n' "$HEADLESS_CLIENT_REVISION"
- name: Verify schema migration and real headless HTTP client in an isolated database
run: HEADLESS_CLIENT_SOURCE="$PWD/.headless-client" bash deploy/check-schema.sh
# smoke 不依赖可连接数据库:healthz 只检查进程,缺 bearer 的 me 必须先返回 401。
- name: Smoke test HTTP routes - name: Smoke test HTTP routes
env: env:
PUBLIC_ORIGIN: https://api.example.com PUBLIC_ORIGIN: https://api.example.com
DATABASE_URL: postgres://foundry:fixture@127.0.0.1:5432/foundry DATABASE_URL: postgres://foundry:fixture@127.0.0.1:5432/foundry
FOUNDRY_RESEARCH_DATABASE_URL: ''
GOOGLE_CLIENT_ID: fixture GOOGLE_CLIENT_ID: fixture
GOOGLE_CLIENT_SECRET: fixture GOOGLE_CLIENT_SECRET: fixture
FOUNDRY_PROJECTS: '{"notes":"http://localhost:3000/auth/callback"}' FOUNDRY_PROJECTS: '{"notes":"http://localhost:3000/auth/callback"}'
+4
View File
@@ -1,3 +1,4 @@
# 仅 main 的相关路径变更触发发布;工作分支验证不应运行此生产切换。
name: Deploy Foundry Core name: Deploy Foundry Core
on: on:
push: push:
@@ -11,6 +12,7 @@ on:
- 'db/**' - 'db/**'
- '.gitea/workflows/deploy.yml' - '.gitea/workflows/deploy.yml'
# 发布串行排队且不取消正在进行的路由/数据库操作。
concurrency: concurrency:
group: foundry-core-main-deploy group: foundry-core-main-deploy
cancel-in-progress: false cancel-in-progress: false
@@ -26,12 +28,14 @@ jobs:
with: with:
go-version-file: go.mod go-version-file: go.mod
cache: false cache: false
# 在远程 runner 生成无 CGO 二进制,供只读 slim 容器执行。
- name: Verify and build - name: Verify and build
run: | run: |
set -eu set -eu
test -z "$(gofmt -l cmd internal)" test -z "$(gofmt -l cmd internal)"
go test -mod=readonly ./... go test -mod=readonly ./...
CGO_ENABLED=0 go build -mod=readonly -o bin/foundry ./cmd/foundry CGO_ENABLED=0 go build -mod=readonly -o bin/foundry ./cmd/foundry
# secrets 仅注入进程环境,项目/引导 JSON 来自 Actions Variables,release 再检查内容。
- name: Deploy and verify backend readiness - name: Deploy and verify backend readiness
env: env:
GOOGLE_CLIENT_ID: ${{ secrets.GOOGLE_CLIENT_ID }} GOOGLE_CLIENT_ID: ${{ secrets.GOOGLE_CLIENT_ID }}
+1
View File
@@ -1,3 +1,4 @@
# 本地配置可能含凭据,构建/文档生成目录不作为源码提交。
.env .env
/bin/ /bin/
/api-docs/ /api-docs/
+12
View File
@@ -10,6 +10,10 @@
4. 由 Gitea Actions 在 `ces-control` 上使用 Go 1.25 构建并检查。部署工作流仅处理 `main` 上影响后端或部署的改动,将二进制启动在服务器 Docker 私网,由 Traefik 提供 HTTPS。通过 `GET /healthz` 检查进程,通过 `GET /readyz` 检查认证库。 4. 由 Gitea Actions 在 `ces-control` 上使用 Go 1.25 构建并检查。部署工作流仅处理 `main` 上影响后端或部署的改动,将二进制启动在服务器 Docker 私网,由 Traefik 提供 HTTPS。通过 `GET /healthz` 检查进程,通过 `GET /readyz` 检查认证库。
5. 代理避免记录 Google 回调的查询参数及认证请求头。设置入口限流,并定时删除三张临时表(`oauth_attempts`、`login_grants`、`project_sessions`)中 `expires_at <= now()` 的记录。 5. 代理避免记录 Google 回调的查询参数及认证请求头。设置入口限流,并定时删除三张临时表(`oauth_attempts`、`login_grants`、`project_sessions`)中 `expires_at <= now()` 的记录。
## 共享论文库(Thesisly)
可选只读接入见[共享论文 API](docs/research-api.md)。Thesisly 使用同一后端的 `/projects/{project}/research/papers` 列表、搜索和详情;只有配置服务器上的 `FOUNDRY_RESEARCH_DATABASE_URL` 时才启用。连接串保存在受保护的 `research.env`,不放入前端或 Actions Variables。当前仍等待 Paper Atlas 全量 PostgreSQL 迁移完成及真实数据验收,尚未启用线上论文接口。
## Actions 部署配置 ## Actions 部署配置
在仓库的 Actions Secrets 配置 `GOOGLE_CLIENT_ID` 和 `GOOGLE_CLIENT_SECRET`,在 Actions Variables 配置 `FOUNDRY_PROJECTS`。变量值为 JSON 对象,例如 `{"prompt":"http://localhost:17321/auth/callback"}`。部署读取服务器上预先配置的 `/opt/endoleap-infra/foundry/database.env`,OAuth 值由 Actions 在启动容器时注入。 在仓库的 Actions Secrets 配置 `GOOGLE_CLIENT_ID` 和 `GOOGLE_CLIENT_SECRET`,在 Actions Variables 配置 `FOUNDRY_PROJECTS`。变量值为 JSON 对象,例如 `{"prompt":"http://localhost:17321/auth/callback"}`。部署读取服务器上预先配置的 `/opt/endoleap-infra/foundry/database.env`,OAuth 值由 Actions 在启动容器时注入。
@@ -628,3 +632,11 @@ Legacy inline images must be migrated through an explicit editor action: upload
unchanged bytes with idempotency keys, then save the same node IDs/geometry with unchanged bytes with idempotency keys, then save the same node IDs/geometry with
managed asset references and the current canvas version. Opening a canvas does managed asset references and the current canvas version. Opening a canvas does
not migrate it or cause an implicit PATCH. not migrate it or cause an implicit PATCH.
#### Atomic member drop positions
`POST B/subgraphs/{frame}/members` additionally accepts optional `positions`, an object with exactly one `{x,y}` entry for each `node_ids` item, expressed in the **source board's local coordinates**. Both coordinates are required, finite and within ±1,000,000. Capabilities advertise `subgraphs.member_positions: true`. Omission preserves legacy behavior. Positions, ownership, edge/port conversion, versions and undo receipt commit in one transaction; no preceding coordinate PATCH is needed. Validation failures or stale versions perform zero writes. The positions participate in the idempotency payload digest; retries must keep the entire body and key unchanged. Undo restores the pre-drop snapshot, including original positions.
## 源码阅读注释
Go 实现、测试与部署脚本内的中文注释说明调用关系、事务、版本、身份和资源生命周期。历史 `db/*.sql` 由部署校验和锁定,逐迁移、逐表及约束说明集中在 [数据库注释索引](docs/database-comments.sql),保留历史 SQL 字节以兼容已部署数据库。`go.sum` 和协议 JSON fixture 保留机器可读原文,不插入注释。
+37
View File
@@ -1,3 +1,4 @@
// Foundry 进程装配入口:HTTP 服务连接认证、平台、研究库和 Codex Unix socket。
package main package main
import ( import (
@@ -13,10 +14,12 @@ import (
"gitea.entroia.com/Zayden-Jung/foundry-core/internal/auth" "gitea.entroia.com/Zayden-Jung/foundry-core/internal/auth"
"gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex" "gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex"
"gitea.entroia.com/Zayden-Jung/foundry-core/internal/platform" "gitea.entroia.com/Zayden-Jung/foundry-core/internal/platform"
"gitea.entroia.com/Zayden-Jung/foundry-core/internal/research"
"github.com/jackc/pgx/v5" "github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/stdlib" "github.com/jackc/pgx/v5/stdlib"
) )
// env 将空环境变量视为缺省;仅用于允许默认值的配置项。
func env(key, fallback string) string { func env(key, fallback string) string {
if value := os.Getenv(key); value != "" { if value := os.Getenv(key); value != "" {
return value return value
@@ -24,10 +27,12 @@ func env(key, fallback string) string {
return fallback return fallback
} }
// main 支持独立 codex-worker 模式,其余启动方式进入 HTTP API 服务。
func main() { func main() {
if len(os.Args) == 2 && os.Args[1] == "codex-worker" { if len(os.Args) == 2 && os.Args[1] == "codex-worker" {
log.Fatal(codex.ServeWorker("/run/foundry-codex/worker.sock")) log.Fatal(codex.ServeWorker("/run/foundry-codex/worker.sock"))
} }
// 公共 origin 只允许 HTTPS 根地址,回调路径由程序拼接,避免配置夹带查询或用户信息。
origin, err := url.Parse(os.Getenv("PUBLIC_ORIGIN")) origin, err := url.Parse(os.Getenv("PUBLIC_ORIGIN"))
if err != nil || origin.Scheme != "https" || origin.Hostname() == "" || origin.User != nil || if err != nil || origin.Scheme != "https" || origin.Hostname() == "" || origin.User != nil ||
(origin.Path != "" && origin.Path != "/") || origin.RawQuery != "" || origin.Fragment != "" { (origin.Path != "" && origin.Path != "/") || origin.RawQuery != "" || origin.Fragment != "" {
@@ -45,12 +50,14 @@ func main() {
if err != nil { if err != nil {
log.Fatal("Invalid DATABASE_URL") log.Fatal("Invalid DATABASE_URL")
} }
// OpenDB 创建连接池,实际连接按需建立;HTTP 就绪检查再验证主库可用性。
db := stdlib.OpenDB(*config) db := stdlib.OpenDB(*config)
defer db.Close() defer db.Close()
email, err := auth.EmailConfigFromEnv() email, err := auth.EmailConfigFromEnv()
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
// nil 邮件配置会直接返回;此后台任务使用进程级上下文,没有单独的优雅停机取消。
go email.Run(context.Background(), db) go email.Run(context.Background(), db)
slack, err := auth.SlackConfigFromEnv(origin.ResolveReference(&url.URL{Path: "/auth/slack/callback"}).String()) slack, err := auth.SlackConfigFromEnv(origin.ResolveReference(&url.URL{Path: "/auth/slack/callback"}).String())
if err != nil { if err != nil {
@@ -61,6 +68,35 @@ func main() {
log.Fatal(err) log.Fatal(err)
} }
mux := http.NewServeMux() mux := http.NewServeMux()
// 研究数据使用可选、独立且只读的连接池;配置后必须在五秒启动探测内可访问。
var papers research.Repository
if researchDSN := os.Getenv("FOUNDRY_RESEARCH_DATABASE_URL"); researchDSN != "" {
researchConfig, err := pgx.ParseConfig(researchDSN)
if err != nil {
log.Fatal("Invalid research database configuration")
}
researchConfig.RuntimeParams["default_transaction_read_only"] = "on"
researchConfig.RuntimeParams["application_name"] = "foundry-research"
researchDB := stdlib.OpenDB(*researchConfig)
defer researchDB.Close()
researchDB.SetMaxOpenConns(2)
researchDB.SetMaxIdleConns(2)
researchDB.SetConnMaxIdleTime(5 * time.Minute)
researchDB.SetConnMaxLifetime(30 * time.Minute)
repository, err := research.NewPostgresRepository(researchDB, env("FOUNDRY_RESEARCH_SCHEMA", "research"))
if err != nil {
log.Fatal("Invalid research database configuration")
}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
err = repository.Check(ctx)
cancel()
if err != nil {
log.Fatal("Research database is unavailable or not published")
}
papers = repository
}
// 先注册具体业务路径,最后的根处理器承接认证及健康探测请求。
research.Register(mux, papers, callbacks)
if err := codex.Register(mux, callbacks, os.Getenv("FOUNDRY_CODEX_SOCKET"), os.Getenv("FOUNDRY_CODEX_GRANTS")); err != nil { if err := codex.Register(mux, callbacks, os.Getenv("FOUNDRY_CODEX_SOCKET"), os.Getenv("FOUNDRY_CODEX_GRANTS")); err != nil {
log.Fatal(err) log.Fatal(err)
} }
@@ -70,6 +106,7 @@ func main() {
} }
platform.Register(mux, db, callbacks, origin.Scheme+"://"+origin.Host, onboarding, codex.NewCanvasClient(os.Getenv("FOUNDRY_CODEX_SOCKET"))) platform.Register(mux, db, callbacks, origin.Scheme+"://"+origin.Host, onboarding, codex.NewCanvasClient(os.Getenv("FOUNDRY_CODEX_SOCKET")))
mux.Handle("/", handler) mux.Handle("/", handler)
// HOST 默认只监听回环,容器部署显式覆盖;较长写超时用于耗时业务响应。
server := &http.Server{ server := &http.Server{
Addr: net.JoinHostPort(env("HOST", "127.0.0.1"), env("PORT", "8080")), Addr: net.JoinHostPort(env("HOST", "127.0.0.1"), env("PORT", "8080")),
Handler: mux, ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 10 * time.Second, Handler: mux, ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 10 * time.Second,
+103
View File
@@ -0,0 +1,103 @@
BEGIN;
-- Canonical rows are separate from the legacy snapshot. Adoption is an explicit,
-- version-checked transaction; installing this schema does not migrate user data.
CREATE TABLE canvas_model_projects (
project text NOT NULL,
workspace_id uuid NOT NULL,
root_id uuid NOT NULL,
document_format_version integer NOT NULL DEFAULT 1 CHECK(document_format_version=1),
migration_id uuid NOT NULL,
source_versions jsonb NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY(project,workspace_id,root_id),
FOREIGN KEY(project,workspace_id,root_id) REFERENCES materials ON DELETE CASCADE
);
CREATE TABLE canvas_model_canvases (
project text NOT NULL,
workspace_id uuid NOT NULL,
root_id uuid NOT NULL,
canvas_id uuid NOT NULL,
parent_canvas_id uuid,
entry_element_id text,
version bigint NOT NULL CHECK(version>0),
archived boolean NOT NULL DEFAULT false,
PRIMARY KEY(project,workspace_id,canvas_id),
UNIQUE(project,canvas_id),
UNIQUE(project,workspace_id,root_id,canvas_id),
CHECK((parent_canvas_id IS NULL)=(entry_element_id IS NULL)),
CHECK(parent_canvas_id IS NOT NULL OR canvas_id=root_id),
FOREIGN KEY(project,workspace_id,root_id) REFERENCES canvas_model_projects ON DELETE CASCADE,
FOREIGN KEY(project,workspace_id,canvas_id) REFERENCES materials ON DELETE CASCADE,
FOREIGN KEY(project,workspace_id,root_id,parent_canvas_id) REFERENCES canvas_model_canvases(project,workspace_id,root_id,canvas_id) DEFERRABLE INITIALLY DEFERRED
);
CREATE UNIQUE INDEX canvas_model_active_entry ON canvas_model_canvases(project,workspace_id,entry_element_id) WHERE NOT archived;
CREATE TABLE canvas_model_elements (
project text NOT NULL,
workspace_id uuid NOT NULL,
root_id uuid NOT NULL,
element_id text NOT NULL CHECK(element_id ~ '^[A-Za-z0-9_-]{1,128}$'),
owner_canvas_id uuid NOT NULL,
incarnation bigint NOT NULL CHECK(incarnation>0 AND incarnation<=9007199254740991),
deleted_incarnation bigint NOT NULL DEFAULT 0 CHECK(deleted_incarnation>=0 AND deleted_incarnation<=incarnation),
record jsonb NOT NULL,
deleted boolean NOT NULL DEFAULT false,
PRIMARY KEY(project,element_id),
UNIQUE(project,workspace_id,element_id),
CHECK(jsonb_typeof(record)='object' AND record->>'id'=element_id AND record->>'ownerCanvasId'=owner_canvas_id::text AND (record->>'incarnation')::bigint=incarnation),
CHECK(NOT deleted OR deleted_incarnation=incarnation),
FOREIGN KEY(project,workspace_id,root_id) REFERENCES canvas_model_projects ON DELETE CASCADE,
FOREIGN KEY(project,workspace_id,root_id,owner_canvas_id) REFERENCES canvas_model_canvases(project,workspace_id,root_id,canvas_id) DEFERRABLE INITIALLY DEFERRED
);
CREATE INDEX canvas_model_owner ON canvas_model_elements(project,workspace_id,root_id,owner_canvas_id) WHERE NOT deleted;
ALTER TABLE canvas_model_canvases ADD CONSTRAINT canvas_model_entry_fk FOREIGN KEY(project,workspace_id,entry_element_id) REFERENCES canvas_model_elements(project,workspace_id,element_id) DEFERRABLE INITIALLY DEFERRED;
CREATE TABLE canvas_model_identity_map (
project text NOT NULL,
workspace_id uuid NOT NULL,
root_id uuid NOT NULL,
source_canvas_id uuid NOT NULL,
source_structure text NOT NULL CHECK(source_structure IN('node','connection')),
source_element_id text NOT NULL,
element_id text NOT NULL,
PRIMARY KEY(project,workspace_id,root_id,source_canvas_id,source_structure,source_element_id),
UNIQUE(project,element_id),
FOREIGN KEY(project,workspace_id,root_id) REFERENCES canvas_model_projects ON DELETE CASCADE,
FOREIGN KEY(project,workspace_id,element_id) REFERENCES canvas_model_elements(project,workspace_id,element_id) DEFERRABLE INITIALLY DEFERRED
);
-- Logical operations cannot acquire a second successful execution under a new request key.
CREATE TABLE canvas_model_requests (
project text NOT NULL,
workspace_id uuid NOT NULL,
account_id uuid NOT NULL,
request_id uuid NOT NULL,
root_id uuid NOT NULL,
action text NOT NULL,
protocol_version integer NOT NULL,
payload_hash text NOT NULL,
response_status integer NOT NULL,
response_body jsonb NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY(project,workspace_id,account_id,request_id),
FOREIGN KEY(project,workspace_id,root_id) REFERENCES materials ON DELETE RESTRICT,
FOREIGN KEY(project,account_id) REFERENCES project_accounts
);
CREATE TABLE canvas_model_operations (
project text NOT NULL,
workspace_id uuid NOT NULL,
operation_id uuid NOT NULL,
request_id uuid NOT NULL,
account_id uuid NOT NULL,
PRIMARY KEY(project,workspace_id,operation_id),
FOREIGN KEY(project,workspace_id,account_id,request_id) REFERENCES canvas_model_requests DEFERRABLE INITIALLY DEFERRED,
FOREIGN KEY(project,account_id) REFERENCES project_accounts
);
CREATE FUNCTION foundry_guard_canonical_canvas() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
IF (NEW.canvas_document IS DISTINCT FROM OLD.canvas_document OR NEW.canvas_version IS DISTINCT FROM OLD.canvas_version)
AND EXISTS(SELECT 1 FROM canvas_model_canvases c WHERE c.project=NEW.project AND c.workspace_id=NEW.workspace_id AND c.canvas_id=NEW.id)
AND current_setting('foundry.canonical_writer',true) IS DISTINCT FROM 'on' THEN
RAISE EXCEPTION 'canonical_write_required' USING ERRCODE='55000';
END IF;
RETURN NEW;
END $$;
CREATE TRIGGER canonical_canvas_write_barrier BEFORE UPDATE OF canvas_document,canvas_version ON materials FOR EACH ROW EXECUTE FUNCTION foundry_guard_canonical_canvas();
COMMIT;
+6
View File
@@ -0,0 +1,6 @@
BEGIN;
-- Legacy requests retain NULL. Canonical operation identity cannot be replayed
-- under another transport key to admit a second paid execution.
ALTER TABLE canvas_ai_runs ADD COLUMN logical_operation_id uuid;
CREATE UNIQUE INDEX canvas_ai_logical_operation ON canvas_ai_runs(project,workspace_id,account_id,logical_operation_id) WHERE logical_operation_id IS NOT NULL;
COMMIT;
+29
View File
@@ -0,0 +1,29 @@
BEGIN;
-- Keep transport receipts independently from execution retention. Their absence
-- must never be used as proof that a paid invocation did not happen.
CREATE TABLE canvas_ai_requests (
project text NOT NULL,
workspace_id uuid NOT NULL,
account_id uuid NOT NULL,
request_id uuid NOT NULL,
board_id uuid NOT NULL,
run_id uuid,
action text NOT NULL CHECK(action IN('run.start','run.cancel','run.apply')),
operation_id uuid NOT NULL,
payload_hash text NOT NULL,
outcome text NOT NULL CHECK(outcome IN('applied','not-applied')),
response_status integer NOT NULL,
response_body jsonb NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY(project,workspace_id,account_id,request_id),
FOREIGN KEY(project,workspace_id) REFERENCES workspaces(project,id) ON DELETE CASCADE
);
-- A known zero-effect rejection may be explicitly replanned under another key;
-- a completed logical action must never execute twice under different keys.
CREATE UNIQUE INDEX canvas_ai_request_operation ON canvas_ai_requests(project,workspace_id,account_id,operation_id) WHERE outcome='applied';
-- Preserve accepted canonical requests that predate this receipt table.
INSERT INTO canvas_ai_requests(project,workspace_id,account_id,request_id,board_id,action,operation_id,payload_hash,outcome,response_status,response_body)
SELECT project,workspace_id,account_id,idempotency_key,board_id,'run.start',logical_operation_id,payload_hash,'applied',202,create_response
FROM canvas_ai_runs WHERE logical_operation_id IS NOT NULL AND create_response->>'protocol_version'='2'
ORDER BY created_at,id ON CONFLICT DO NOTHING;
COMMIT;
+9
View File
@@ -0,0 +1,9 @@
BEGIN;
-- The frozen board remains the plan origin; result versions belong to the board
-- that actually received the output after any owner-only move.
ALTER TABLE canvas_ai_steps ADD COLUMN applied_board_id uuid;
ALTER TABLE canvas_ai_steps ADD FOREIGN KEY(project,workspace_id,applied_board_id) REFERENCES materials(project,workspace_id,id);
UPDATE canvas_ai_steps SET applied_board_id=board_id WHERE applied_version IS NOT NULL;
CREATE UNIQUE INDEX canvas_ai_canonical_target_busy ON canvas_ai_steps(project,workspace_id,(frozen_input->>'canonical_root'),node_id,(frozen_input->>'target_incarnation'))
WHERE status IN('queued','running') AND frozen_input->>'canonical_root' IS NOT NULL;
COMMIT;
+4
View File
@@ -1,5 +1,6 @@
#!/usr/bin/env bash #!/usr/bin/env bash
# Explicit remote-runner opt-in: invokes real models using the dedicated CLI login. # Explicit remote-runner opt-in: invokes real models using the dedicated CLI login.
# 此脚本会编译测试并实际调用模型;只用于明确授权的专用远程 runner,普通检查不自动运行。
set -euo pipefail set -euo pipefail
umask 077 umask 077
binary=$(realpath "$1") binary=$(realpath "$1")
@@ -9,6 +10,7 @@ login=${FOUNDRY_REAL_CODEX_HOME:-/opt/endoleap-infra/foundry/codex/home}
test -x "$binary" test -x "$binary"
test -s "$login/auth.json" test -s "$login/auth.json"
test -s "$login/models_cache.json" test -s "$login/models_cache.json"
# 随机命名 worker/数据库和临时 socket 目录,退出时一并清理,不复用生产队列。
suffix=$(openssl rand -hex 8) suffix=$(openssl rand -hex 8)
database=foundry-real-db-$suffix database=foundry-real-db-$suffix
worker=foundry-real-worker-$suffix worker=foundry-real-worker-$suffix
@@ -24,6 +26,7 @@ docker exec "$database" psql -X -U postgres -v ON_ERROR_STOP=1 -c 'CREATE ROLE f
python3 deploy/migrate.py --container "$database" --database postgres --role foundry_fixture python3 deploy/migrate.py --container "$database" --database postgres --role foundry_fixture
# Only the CLI container sees the login. Core/tests receive the private socket, # Only the CLI container sees the login. Core/tests receive the private socket,
# never the login, runtime configuration or Docker socket. # never the login, runtime configuration or Docker socket.
# 只有 CLI 容器只读读取专用登录和模型缓存,测试容器仅挂 socket,不能访问登录或 Docker socket。
docker run -d --name "$worker" --init --network bridge --user 1000:1000 \ docker run -d --name "$worker" --init --network bridge --user 1000:1000 \
--cap-drop ALL --security-opt no-new-privileges --read-only --pids-limit 128 --memory 1g \ --cap-drop ALL --security-opt no-new-privileges --read-only --pids-limit 128 --memory 1g \
--tmpfs /tmp:rw,nosuid,nodev,size=128m --tmpfs /work:ro,nosuid,nodev \ --tmpfs /tmp:rw,nosuid,nodev,size=128m --tmpfs /work:ro,nosuid,nodev \
@@ -38,6 +41,7 @@ docker run -d --name "$worker" --init --network bridge --user 1000:1000 \
node:24-bookworm-slim /opt/foundry codex-worker >/dev/null node:24-bookworm-slim /opt/foundry codex-worker >/dev/null
for attempt in {1..30}; do if [[ -S "$scratch/run/worker.sock" ]]; then break; fi; sleep 1; done for attempt in {1..30}; do if [[ -S "$scratch/run/worker.sock" ]]; then break; fi; sleep 1; done
test -S "$scratch/run/worker.sock" test -S "$scratch/run/worker.sock"
# 先等私有 socket 出现,再在 runner 编译并仅运行真实 worker 专项用例;与普通单元测试开关分离。
CGO_ENABLED=0 go test -mod=readonly -c -o bin/platform-real-tests ./internal/platform CGO_ENABLED=0 go test -mod=readonly -c -o bin/platform-real-tests ./internal/platform
docker run --rm --network "container:$database" --user 1000:1000 \ docker run --rm --network "container:$database" --user 1000:1000 \
--read-only --cap-drop ALL --security-opt no-new-privileges \ --read-only --cap-drop ALL --security-opt no-new-privileges \
+25 -1
View File
@@ -1,6 +1,8 @@
#!/usr/bin/env bash #!/usr/bin/env bash
# 远程 runner 的数据库/集成检查,会编译测试二进制并运行容器;不能在未授权本地环境执行。
set -euo pipefail set -euo pipefail
# 随机隔离数据库容器不映射宿主端口,EXIT 时销毁;trust 认证只用于该临时网络命名空间。
container=foundry-schema-$(openssl rand -hex 8) container=foundry-schema-$(openssl rand -hex 8)
cleanup() { docker rm -f "$container" >/dev/null 2>&1 || true; } cleanup() { docker rm -f "$container" >/dev/null 2>&1 || true; }
trap cleanup EXIT trap cleanup EXIT
@@ -12,6 +14,7 @@ for attempt in {1..30}; do
sleep 1 sleep 1
done done
psql() { docker exec -i "$container" psql -X -U postgres -v ON_ERROR_STOP=1; } psql() { docker exec -i "$container" psql -X -U postgres -v ON_ERROR_STOP=1; }
# 先安装最早认证版本并植入有效/过期旧会话,模拟部署前已有用户数据。
psql < db/001-auth.sql psql < db/001-auth.sql
psql <<'SQL' psql <<'SQL'
INSERT INTO project_accounts(project,id,google_subject,email) INSERT INTO project_accounts(project,id,google_subject,email)
@@ -23,8 +26,10 @@ SQL
psql <<'SQLROLE' psql <<'SQLROLE'
CREATE ROLE foundry_fixture LOGIN; CREATE ROLE foundry_fixture LOGIN;
SQLROLE SQLROLE
# 连续跑两次真实迁移器,验证旧基线接管和校验和重放,而不是仅验证全新数据库建表。
python3 deploy/migrate.py --container "$container" --database postgres --role foundry_fixture python3 deploy/migrate.py --container "$container" --database postgres --role foundry_fixture
python3 deploy/migrate.py --container "$container" --database postgres --role foundry_fixture python3 deploy/migrate.py --container "$container" --database postgres --role foundry_fixture
# SQL 断言旧 Google 绑定保留、过期会话不复活、绝对期限添加,再在回滚事务中验证资源与跨项目外键。
psql <<'SQL' psql <<'SQL'
DO $$ DO $$
BEGIN BEGIN
@@ -67,12 +72,31 @@ END $$;
ROLLBACK; ROLLBACK;
SQL SQL
printf 'Migration preserved existing logins and enforced project isolation.\n' printf 'Migration preserved existing logins and enforced project isolation.\n'
for package in platform auth; do psql < internal/research/testdata/corpus.sql
# runner 编译 Linux 静态测试程序,随后在同数据库网络空间用最小权限容器运行,源码不挂入测试容器。
for package in platform auth research; do
CGO_ENABLED=0 go test -mod=readonly -c -o "bin/$package-tests" "./internal/$package" CGO_ENABLED=0 go test -mod=readonly -c -o "bin/$package-tests" "./internal/$package"
docker run --rm --network "container:$container" --user 1000:1000 \ docker run --rm --network "container:$container" --user 1000:1000 \
--read-only --cap-drop ALL --security-opt no-new-privileges \ --read-only --cap-drop ALL --security-opt no-new-privileges \
--tmpfs /tmp:rw,nosuid,nodev,noexec,size=16m,mode=1777 \ --tmpfs /tmp:rw,nosuid,nodev,noexec,size=16m,mode=1777 \
--mount "type=bind,source=$(pwd)/bin/$package-tests,target=/opt/integration-tests,readonly" \ --mount "type=bind,source=$(pwd)/bin/$package-tests,target=/opt/integration-tests,readonly" \
-e PLATFORM_TEST_DATABASE_URL=postgres://foundry_fixture@127.0.0.1:5432/postgres?sslmode=disable \ -e PLATFORM_TEST_DATABASE_URL=postgres://foundry_fixture@127.0.0.1:5432/postgres?sslmode=disable \
-e RESEARCH_TEST_DATABASE_URL=postgres://foundry_research_fixture@127.0.0.1:5432/postgres?sslmode=disable \
--entrypoint /opt/integration-tests postgres:17-alpine -test.v --entrypoint /opt/integration-tests postgres:17-alpine -test.v
done done
# Run the actual pinned Endoleap runtime against this build's authenticated HTTP
# routes and the same disposable database. Only this remote container needs Node.
# 可选 pinned Endoleap 客户端需要 Node,额外运行一次真实 HTTP 客户端集成;未提供时跳过该阶段。
if [[ -n "${HEADLESS_CLIENT_SOURCE:-}" ]]; then
test -f "$HEADLESS_CLIENT_SOURCE/tests/headless/foundry.integration.mjs"
docker run --rm --network "container:$container" --user 1000:1000 \
--read-only --cap-drop ALL --security-opt no-new-privileges \
--tmpfs /tmp:rw,nosuid,nodev,noexec,size=32m,mode=1777 \
--mount "type=bind,source=$(pwd)/bin/platform-tests,target=/opt/integration-tests,readonly" \
--mount "type=bind,source=$HEADLESS_CLIENT_SOURCE,target=/opt/headless-client,readonly" \
-e PLATFORM_TEST_DATABASE_URL=postgres://foundry_fixture@127.0.0.1:5432/postgres?sslmode=disable \
-e FOUNDRY_HEADLESS_SOURCE=/opt/headless-client \
--entrypoint /opt/integration-tests node:24-bookworm-slim \
-test.v -test.run '^TestHeadlessClientHTTPIntegration$' -test.timeout 3m
fi
+5
View File
@@ -1,4 +1,5 @@
#!/usr/bin/env bash #!/usr/bin/env bash
# 远程私有 worker 启动器;使用与 Core 同一二进制的 codex-worker 模式,CLI 和登录目录由运维预先提供。
set -euo pipefail set -euo pipefail
base=/opt/endoleap-infra base=/opt/endoleap-infra
@@ -7,14 +8,18 @@ binary=$(realpath "$1")
test -x "$binary" test -x "$binary"
test -s "$dir/home/auth.json" test -s "$dir/home/auth.json"
test -s "$dir/grants/projects.json" test -s "$dir/grants/projects.json"
# socket 目录归容器 uid 1000,socket 本身由服务设为 0600;不公布宿主 TCP 端口。
install -d -m 700 "$dir/run" install -d -m 700 "$dir/run"
chown 1000:1000 "$dir/run" chown 1000:1000 "$dir/run"
# 可选目录声明已验证图片输出后端;没有此名单时不根据图片输入能力推测图片生成能力。
canvas_env=() canvas_env=()
if [[ -s "$dir/canvas.env" ]]; then canvas_env=(--env-file "$dir/canvas.env"); fi if [[ -s "$dir/canvas.env" ]]; then canvas_env=(--env-file "$dir/canvas.env"); fi
# The host operator supplies an isolated Codex home and starts a single worker. # The host operator supplies an isolated Codex home and starts a single worker.
# The Docker default bridge supplies egress independently of Foundry's network. # The Docker default bridge supplies egress independently of Foundry's network.
# 单 worker 使用独立 bridge 出网,根文件系统只读;临时任务写 /tmp,登录目录需允许 CLI 自身状态更新。
# CLI/二进制只读挂载,Core 只看到 socket,不共享本登录目录。
docker run -d --name foundry-codex-worker --restart unless-stopped --init \ docker run -d --name foundry-codex-worker --restart unless-stopped --init \
--network bridge --user 1000:1000 --cap-drop ALL --security-opt no-new-privileges \ --network bridge --user 1000:1000 --cap-drop ALL --security-opt no-new-privileges \
--read-only --pids-limit 128 --memory 1g --tmpfs /tmp:rw,nosuid,nodev \ --read-only --pids-limit 128 --memory 1g --tmpfs /tmp:rw,nosuid,nodev \
+10 -1
View File
@@ -1,13 +1,17 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
"""Apply checked migrations atomically from the trusted deployment runner.""" """Apply checked migrations atomically from the trusted deployment runner."""
# 部署 runner 入口:组合所有尚未执行的迁移及授权为单个外层事务,失败整体回滚。
# db/*.sql 的校验和覆盖原始注释;历史文件不可仅为加注释而改写,中文对象说明见 docs/database-comments.sql。
import argparse import argparse
import hashlib import hashlib
import os
from pathlib import Path from pathlib import Path
import re import re
import subprocess import subprocess
# 数据库/角色会插入 SQL 标识符,先严格限制为小写标识;container 通过 argv 传给 docker。
parser = argparse.ArgumentParser() parser = argparse.ArgumentParser()
parser.add_argument("--container", default="endoleap-dev-postgres-1") parser.add_argument("--container", default=os.environ.get("FOUNDRY_POSTGRES_CONTAINER", "foundry-postgres"))
parser.add_argument("--database", default="foundry_auth") parser.add_argument("--database", default="foundry_auth")
parser.add_argument("--role", default="foundry") parser.add_argument("--role", default="foundry")
args = parser.parse_args() args = parser.parse_args()
@@ -18,6 +22,7 @@ migrations = sorted((Path(__file__).resolve().parent.parent / "db").glob("[0-9]*
if not migrations: if not migrations:
raise SystemExit("No migrations found") raise SystemExit("No migrations found")
# psql 遇错立即退出,固定 advisory 事务锁串行化同库部署,lock_timeout 防止无限等锁。
script = [ script = [
"\\set ON_ERROR_STOP on", "\\set ON_ERROR_STOP on",
"BEGIN;", "BEGIN;",
@@ -32,6 +37,7 @@ for index, path in enumerate(migrations):
name = path.name name = path.name
if not re.fullmatch(r"[0-9]+-[a-z0-9-]+\.sql", name): if not re.fullmatch(r"[0-9]+-[a-z0-9-]+\.sql", name):
raise SystemExit("Invalid migration name") raise SystemExit("Invalid migration name")
# 原文 SHA-256 与已执行记录逐字匹配,禁止同名历史迁移在部署后被静默修改。
checksum = hashlib.sha256(source.encode()).hexdigest() checksum = hashlib.sha256(source.encode()).hexdigest()
tables.update(re.findall(r"CREATE TABLE ([a-z_]+)", source)) tables.update(re.findall(r"CREATE TABLE ([a-z_]+)", source))
# The first deployed version predates migration tracking. # The first deployed version predates migration tracking.
@@ -54,6 +60,7 @@ for index, path in enumerate(migrations):
"\\endif", "\\endif",
"\\else", "\\else",
]) ])
# 每份源文件显式 BEGIN/COMMIT;去除内层边界后放入外层统一事务,而非逐文件部分提交。
source = source.strip() source = source.strip()
if not source.startswith("BEGIN;") or not source.endswith("COMMIT;"): if not source.startswith("BEGIN;") or not source.endswith("COMMIT;"):
raise SystemExit("Migration must have explicit transaction boundaries") raise SystemExit("Migration must have explicit transaction boundaries")
@@ -62,12 +69,14 @@ for index, path in enumerate(migrations):
f"INSERT INTO foundry_schema_migrations(name,checksum) VALUES('{name}','{checksum}');", f"INSERT INTO foundry_schema_migrations(name,checksum) VALUES('{name}','{checksum}');",
"\\endif", "\\endif",
]) ])
# 从受信任源码的 CREATE TABLE 清单补应用 DML 权限;identity 序列另授予使用/读取权限。
for table in sorted(tables): for table in sorted(tables):
script.append(f'GRANT SELECT,INSERT,UPDATE,DELETE ON TABLE "{table}" TO "{args.role}";') script.append(f'GRANT SELECT,INSERT,UPDATE,DELETE ON TABLE "{table}" TO "{args.role}";')
script.extend([ script.extend([
f'GRANT USAGE,SELECT ON SEQUENCE link_clicks_id_seq TO "{args.role}";', f'GRANT USAGE,SELECT ON SEQUENCE link_clicks_id_seq TO "{args.role}";',
"COMMIT;", "COMMIT;",
]) ])
# SQL 经标准输入交给容器内 psql,不把数据库密码或整段 SQL 拼成 shell 命令参数。
subprocess.run( subprocess.run(
["docker", "exec", "-i", args.container, "sh", "-c", ["docker", "exec", "-i", args.container, "sh", "-c",
'exec psql -X -U "${POSTGRES_USER:-postgres}" -d "$1" -v ON_ERROR_STOP=1', "sh", args.database], 'exec psql -X -U "${POSTGRES_USER:-postgres}" -d "$1" -v ON_ERROR_STOP=1', "sh", args.database],
+18 -1
View File
@@ -1,4 +1,6 @@
#!/usr/bin/env bash #!/usr/bin/env bash
# 由 main 部署工作流在远程基础设施主机执行,参数一必须是已构建的 Foundry 二进制。
# 本脚本会迁移数据库、替换 worker 并启动候选服务,不能当作本地静态检查执行。
set -euo pipefail set -euo pipefail
umask 077 umask 077
@@ -8,6 +10,7 @@ origin=https://api.foundry.entroia.com
candidate=foundry-core-candidate candidate=foundry-core-candidate
network=endoleap-dev_default network=endoleap-dev_default
# 必需凭据仅从环境传入,拒绝换行以保持容器环境参数边界,日志不打印值。
for name in GOOGLE_CLIENT_ID GOOGLE_CLIENT_SECRET; do for name in GOOGLE_CLIENT_ID GOOGLE_CLIENT_SECRET; do
value=${!name-} value=${!name-}
if [[ -z "$value" || "$value" == *$'\n'* || "$value" == *$'\r'* ]]; then if [[ -z "$value" || "$value" == *$'\n'* || "$value" == *$'\r'* ]]; then
@@ -16,6 +19,7 @@ for name in GOOGLE_CLIENT_ID GOOGLE_CLIENT_SECRET; do
fi fi
done done
# Accept formatted JSON from Actions Variables and never print its contents. # Accept formatted JSON from Actions Variables and never print its contents.
# 将 Actions 中可多行排版的 JSON 压为单行;这里只校验映射形状,URL 协议由服务启动继续验证。
FOUNDRY_PROJECTS=$(python3 - <<'PYCONFIG' FOUNDRY_PROJECTS=$(python3 - <<'PYCONFIG'
import json import json
import os import os
@@ -44,15 +48,22 @@ test -s "$foundry/database.env"
ca_bundle=/etc/ssl/certs/ca-certificates.crt ca_bundle=/etc/ssl/certs/ca-certificates.crt
test -s "$ca_bundle" test -s "$ca_bundle"
docker network inspect "$network" >/dev/null docker network inspect "$network" >/dev/null
# 先运行全事务迁移及角色授权,迁移失败立即终止,不让新服务在半升级 schema 上启动。
python3 "$(dirname "$0")/migrate.py" python3 "$(dirname "$0")/migrate.py"
# 每次发布使用独立二进制目录供只读挂载;本脚本不清除旧 release 目录。
release=$(mktemp -d "$foundry/release.XXXXXXXX") release=$(mktemp -d "$foundry/release.XXXXXXXX")
install -m 755 "$1" "$release/foundry" install -m 755 "$1" "$release/foundry"
export HOST=0.0.0.0 PORT=8080 PUBLIC_ORIGIN="$origin" export HOST=0.0.0.0 PORT=8080 PUBLIC_ORIGIN="$origin"
# 邮件/研究配置可选且从受保护文件加载;Slack 优先 Actions 环境,缺省才回退服务器文件。
mail_env=() mail_env=()
if [[ -s "$foundry/mail.env" ]]; then if [[ -s "$foundry/mail.env" ]]; then
mail_env=(--env-file "$foundry/mail.env") mail_env=(--env-file "$foundry/mail.env")
fi fi
research_env=()
if [[ -s "$foundry/research.env" ]]; then
research_env=(--env-file "$foundry/research.env")
fi
slack_env=() slack_env=()
if [[ -n "${SLACK_CLIENT_ID:-}" || -n "${SLACK_CLIENT_SECRET:-}" ]]; then if [[ -n "${SLACK_CLIENT_ID:-}" || -n "${SLACK_CLIENT_SECRET:-}" ]]; then
for name in SLACK_CLIENT_ID SLACK_CLIENT_SECRET; do for name in SLACK_CLIENT_ID SLACK_CLIENT_SECRET; do
@@ -69,6 +80,7 @@ elif [[ -s "$foundry/slack.env" ]]; then
fi fi
codex_mounts=() codex_mounts=()
codex_dir=$foundry/codex codex_dir=$foundry/codex
# 存在 worker 配置才启用 IPC;worker 必须先与当前 Core 二进制协议对齐,启动失败恢复旧 worker。
if [[ -d "$codex_dir" ]]; then if [[ -d "$codex_dir" ]]; then
# Core and its private worker must speak the same Canvas artifact protocol. # Core and its private worker must speak the same Canvas artifact protocol.
# Keep the previous container definition for exact startup rollback. # Keep the previous container definition for exact startup rollback.
@@ -103,6 +115,7 @@ if [[ -d "$codex_dir" ]]; then
printf 'Canvas worker startup/catalog verification failed; previous worker restored.\n' >&2 printf 'Canvas worker startup/catalog verification failed; previous worker restored.\n' >&2
exit 1 exit 1
fi fi
# 目录探测成功后删除旧 worker 定义;后续候选/路由失败不会再恢复该 worker,回滚范围需据此理解。
if [[ -n "$worker_backup" ]]; then docker rm "$worker_backup" >/dev/null; fi if [[ -n "$worker_backup" ]]; then docker rm "$worker_backup" >/dev/null; fi
for attempt in {1..20}; do for attempt in {1..20}; do
[[ ! -S "$codex_dir/run/worker.sock" ]] || break [[ ! -S "$codex_dir/run/worker.sock" ]] || break
@@ -118,7 +131,8 @@ if [[ -d "$codex_dir" ]]; then
) )
fi fi
docker run -d --name "$candidate" "${codex_mounts[@]}" "${mail_env[@]}" "${slack_env[@]}" --network "$network" \ # Core 只挂载 IPC/授权表,不挂载 CLI 登录;以非 root、只读根文件系统和裁剪能力运行。
docker run -d --name "$candidate" "${codex_mounts[@]}" "${mail_env[@]}" "${slack_env[@]}" "${research_env[@]}" --network "$network" \
--env-file "$foundry/database.env" -e HOST -e PORT -e PUBLIC_ORIGIN \ --env-file "$foundry/database.env" -e HOST -e PORT -e PUBLIC_ORIGIN \
-e GOOGLE_CLIENT_ID -e GOOGLE_CLIENT_SECRET -e FOUNDRY_PROJECTS -e FOUNDRY_ONBOARDING \ -e GOOGLE_CLIENT_ID -e GOOGLE_CLIENT_SECRET -e FOUNDRY_PROJECTS -e FOUNDRY_ONBOARDING \
--user 1000:1000 --cap-drop ALL --security-opt no-new-privileges \ --user 1000:1000 --cap-drop ALL --security-opt no-new-privileges \
@@ -128,11 +142,13 @@ docker run -d --name "$candidate" "${codex_mounts[@]}" "${mail_env[@]}" "${slack
--mount "type=bind,source=$release/foundry,target=/opt/foundry,readonly" \ --mount "type=bind,source=$release/foundry,target=/opt/foundry,readonly" \
node:24-bookworm-slim /opt/foundry >/dev/null node:24-bookworm-slim /opt/foundry >/dev/null
# 候选或路由失败时删除本次新 Core;旧 Core 由 route 成功探测后才停止。
cleanup_candidate() { cleanup_candidate() {
docker rm -f "${live:-$candidate}" >/dev/null 2>&1 || true docker rm -f "${live:-$candidate}" >/dev/null 2>&1 || true
} }
trap cleanup_candidate EXIT trap cleanup_candidate EXIT
# 容器内 smoke 只验证 CA 文件、数据库就绪及匿名请求被拒,不执行真实 OAuth 或付费模型。
docker exec "$candidate" node -e ' docker exec "$candidate" node -e '
const assert = require("node:assert/strict"); const assert = require("node:assert/strict");
const fs = require("node:fs"); const fs = require("node:fs");
@@ -162,6 +178,7 @@ docker exec "$candidate" node -e '
# Keep the previous running container until the new candidate has passed checks. # Keep the previous running container until the new candidate has passed checks.
# Traefik reads the route atomically from its watched config directory. # Traefik reads the route atomically from its watched config directory.
# 使用容器 ID 前缀命名新 live,route.sh 负责原子路由写入、外部就绪检查和失败恢复路由。
id=$(docker inspect -f '{{.Id}}' "$candidate") id=$(docker inspect -f '{{.Id}}' "$candidate")
live=foundry-core-${id:0:12} live=foundry-core-${id:0:12}
docker rename "$candidate" "$live" docker rename "$candidate" "$live"
+18
View File
@@ -0,0 +1,18 @@
-- 运维手动索引步骤:对已发布 research schema 执行,不能由只读服务角色调用,也不能包进事务。
-- 不属于 db/ 版本迁移;CREATE INDEX CONCURRENTLY 需要独立顶层语句,避免长时间阻塞语料读取。
-- Manual operator step against the published Paper Atlas schema, outside a
-- transaction. Core's SELECT-only runtime role must never execute this file.
-- These indexes support the actual author search and exact category filter;
-- the migration already owns the title/abstract English GIN index.
SET lock_timeout = '2s';
SET statement_timeout = '20min';
SET maintenance_work_mem = '32MB';
SET max_parallel_maintenance_workers = 0;
-- (tag_id,paper_id) 支持纯主题页直接走关联索引,在 LIMIT 前避免读所有宽论文行。
CREATE INDEX CONCURRENTLY IF NOT EXISTS paper_tags_tag_paper
ON research.paper_tags(tag_id,paper_id);
-- simple 配置匹配作者查询的表达式,不对姓名做 english 词干化;索引表达式须与查询一致。
CREATE INDEX CONCURRENTLY IF NOT EXISTS papers_authors_search_gin
ON research.papers USING gin(to_tsvector('simple'::regconfig,authors_json));
-- After an interrupted concurrent build, inspect pg_index.indisvalid before
-- reuse. IF NOT EXISTS alone does not repair an invalid index.
+7
View File
@@ -1,4 +1,5 @@
#!/usr/bin/env bash #!/usr/bin/env bash
# 远程部署的路由切换阶段,参数必须是本次已通过内部就绪检查的 Core 容器名。
set -euo pipefail set -euo pipefail
umask 077 umask 077
cd /opt/endoleap-infra cd /opt/endoleap-infra
@@ -8,12 +9,14 @@ live=$1
install -d -m 700 dev/foundry-edge install -d -m 700 dev/foundry-edge
edge=dev/foundry-edge edge=dev/foundry-edge
route=$edge/foundry.yml route=$edge/foundry.yml
# 从现有动态配置提取旧容器;仅在新路由完成 HTTPS 探测后才停止它。
previous= previous=
if [[ -f "$route" ]]; then if [[ -f "$route" ]]; then
previous=$(sed -n 's@.*url: http://\(foundry-core-[a-f0-9]\{12\}\):8080.*@\1@p' "$route") previous=$(sed -n 's@.*url: http://\(foundry-core-[a-f0-9]\{12\}\):8080.*@\1@p' "$route")
fi fi
backup=$(mktemp) backup=$(mktemp)
if [[ -f "$route" ]]; then cp "$route" "$backup"; fi if [[ -f "$route" ]]; then cp "$route" "$backup"; fi
# EXIT trap 只恢复动态路由文件或删除新路由,不回滚已执行的数据库迁移/worker/Compose 配置。
rollback() { rollback() {
if [[ -s "$backup" ]]; then if [[ -s "$backup" ]]; then
cp "$backup" "$edge/.restore" cp "$backup" "$edge/.restore"
@@ -25,6 +28,7 @@ rollback() {
} }
trap rollback EXIT trap rollback EXIT
# ACME 文件保存证书状态,限制权限;动态路由先写隐藏临时文件再 mv,避免 watcher 读到半文件。
touch "$edge/acme.json" touch "$edge/acme.json"
chmod 600 "$edge/acme.json" chmod 600 "$edge/acme.json"
cat > "$edge/.foundry.yml" <<YAML cat > "$edge/.foundry.yml" <<YAML
@@ -49,6 +53,7 @@ http:
- url: http://$live:8080 - url: http://$live:8080
YAML YAML
mv "$edge/.foundry.yml" "$route" mv "$edge/.foundry.yml" "$route"
# Compose 覆盖文件保持 Traefik 入口、证书与目录 provider 配置,不重建其他服务。
cat > foundry-edge.yml <<'YAML' cat > foundry-edge.yml <<'YAML'
services: services:
traefik: traefik:
@@ -68,11 +73,13 @@ services:
YAML YAML
docker compose -p endoleap-dev --env-file dev/env -f compose.yml -f dev.yml -f foundry-edge.yml up -d --no-deps traefik docker compose -p endoleap-dev --env-file dev/env -f compose.yml -f dev.yml -f foundry-edge.yml up -d --no-deps traefik
# --resolve 在本机回环命中 Traefik,同时保留公开域名 Host/TLS 验证,探测真正的 HTTPS 路由。
curl --fail --silent --show-error --output /dev/null --max-time 6 \ curl --fail --silent --show-error --output /dev/null --max-time 6 \
--retry 15 --retry-delay 4 --retry-all-errors \ --retry 15 --retry-delay 4 --retry-all-errors \
--resolve api.foundry.entroia.com:443:127.0.0.1 \ --resolve api.foundry.entroia.com:443:127.0.0.1 \
https://api.foundry.entroia.com/readyz https://api.foundry.entroia.com/readyz
# HTTPS 就绪后解除回滚并删除备份;旧容器停止失败仅提示手工清理,不能误报新路由失败。
trap - EXIT trap - EXIT
rm -f "$backup" rm -f "$backup"
if [[ "$previous" =~ ^foundry-core-[a-f0-9]{12}$ && "$previous" != "$live" ]]; then if [[ "$previous" =~ ^foundry-core-[a-f0-9]{12}$ && "$previous" != "$live" ]]; then
+115
View File
@@ -0,0 +1,115 @@
-- Foundry 数据库源码阅读注释索引(仅注释,不执行迁移)。
-- 历史 db/*.sql 的 SHA-256 由 deploy/migrate.py 原文计算并记录;即使只改注释,
-- 已部署库也会拒绝同名文件的新校验和。因此按迁移文件与对象名在此维护中文说明。
-- 顺序:001 认证 → 002 平台 → 003 快照 → 004 会话期限 → 005 子图事务 →
-- 006 资产 → 007 AI 队列 → 008 canonical 模型 → 009–011 AI 身份/回执/位置。
-- db/001-auth.sql:四张基础认证表在一个事务中安装。
-- project_accounts:账户身份以 (project,id) 为主键,Google subject 在项目内唯一。
-- 同一 Google 用户可在不同项目有不同账户,邮箱是可空资料,不作为跨提供方自动合并依据。
-- oauth_attempts:十分钟 OAuth 尝试;state/browser 保存摘要,frontend_challenge 绑定
-- 前端兑换证明,google_verifier 原文用于服务器向 Google 兑换 PKCE 授权码。
-- 回调通过 DELETE ... RETURNING 原子消费,外部兑换失败也不会恢复已消费尝试。
-- login_grants:一分钟一次性交换码只存 token_hash,复合外键保证账户属于同一项目。
-- project_sessions:bearer 明文只交客户端,数据库仅存摘要和期限;删除账户级联清会话。
-- 三个 expires_at 索引提供过期定位能力,本文件本身不创建定时清理任务。
-- db/002-platform.sql:扩展身份提供方与协作资源,保留旧 Google 账户/会话。
-- project_accounts:google_subject 放宽可空;username 在项目内按 lower 唯一,
-- display_name/avatar_url 是可由用户维护的资料,updated_at 由应用更新。
-- oauth_attempts.provider 默认 google 兼容已有行;Slack 增加 oidc_nonce 防止 ID token 重放。
-- account_identities:以项目/提供方/subject 唯一定位账户,迁入既有 Google subject;
-- 项目/提供方/account 唯一约束限定同一账户每提供方只有一个绑定。
-- email_credentials:已验证邮箱凭据,邮箱须小写,password_hash 是 bcrypt;
-- 项目/email 主键及项目/account 唯一性不允许多个凭据冒用同一邮箱或账户。
-- email_registrations:未验证注册单独保存密码摘要和验证码摘要,未确认前不建立账户;
-- 重发注册由应用在邮箱级事务锁下替换待验证记录及过期时间。
-- email_outbox:邮件与注册同事务写入,available_at/attempts 控制重试;lease_id/
-- lease_until 使后台 worker 可认领并在租约失效后恢复,sent_at 标成功。
-- 发送成功后应用清空 body;SMTP 成功与数据库标记不原子,不能宣称严格只投递一次。
-- auth_rate_limits:仅保存限频键摘要,固定窗口过期后由应用 upsert 重置次数。
-- onboarding_responses:项目/账户唯一完成记录,answers/result 必须 JSON 对象;
-- 配合账户行锁,使并发首次引导只能创建一次工作区并重放已存结果。
-- workspaces:所有者外键指向同项目账户;工作区行锁是角色/所有权变更共享的串行点。
-- workspace_members:每人每工作区一个角色,admin/editor/viewer 的写权限由应用解释;
-- owner 必须保留 admin 成员的规则由服务控制,表约束没有单独自动生成该成员。
-- materials:按项目/工作区隔离的可复用内容对象,kind 为受限类型;version 是素材
-- 内容/元数据的乐观版本,后续新增 canvas_version 与它分离。
-- material_modified/material_created/material_alphabetical:对应列表排序的复合索引。
-- material_opens:账户级最近打开时间,可反复 upsert,不修改素材正文;专用索引支持最近打开。
-- tags/material_tags:标签名在工作区内忽略大小写唯一;双复合外键阻止跨工作区关联,
-- 标签/素材删除级联清关联,应用负责让受影响素材版本递增。
-- board_layouts:旧布局引用可复用素材,位置/尺寸与内容独立;禁止引用自身,
-- “必须 board 且不可嵌套 board”及每板最多 2000 条由服务检查。
-- material_grants:显式 editor/viewer 素材权限,不存在素材级 admin 授予;
-- 根画布继承和归档祖先检查由 lockMaterial 的递归查询决定。
-- share_links:仅保存邀请摘要;可指工作区或单素材,单素材不允许 admin;
-- max_uses/use_count 是额度,expires_at/revoked_at 控制之后的兑换资格。
-- share_redemptions:同账户同链接只兑换一次;应用在持锁事务内插入成功后才加额度并提升角色。
-- link_clicks:公开点击独立于兑换计数,仅存 Referer origin,避免收集路径、查询和令牌。
-- bigint identity 支持递减 ID 分页;应用角色需单独授予序列 USAGE/SELECT。
-- db/003-canvas.sql:为 board 增加独立 canvas_version 和可空 canvas_document。
-- canvas_board_only 禁止非 board 保存快照;旧空文档在读取时投影为初始空 v1 图。
-- workspaces/materials 的 slug 先按名称/标题加 UUID 回填,再设 NOT NULL 和作用域唯一。
-- foundry_default_slug:仅 INSERT 且未给 slug 才派生值,名字更改不会隐式改 URL。
-- label 规范化并限长,空结果回退 canvas;触发器在两个表共享,因此区分 name/title。
-- db/004-session-lifetime.sql:加入 created_at 和九十天 absolute_expires_at 缺省。
-- 旧会话原始发行时间未知,绝对上限从迁移时开始,但原 expires_at 完全不变,
-- 已闲置过期的旧会话不会被此迁移复活。应用续期取 min(三十天后,绝对期限)。
-- db/005-canvas-subgraphs.sql:持久唯一所有权与多画布事务恢复信息。
-- canvas_subgraphs:Child 是主键中的唯一所有者身份,活跃 Parent/Frame 受部分唯一索引限制;
-- archived_at 保留恢复关系但从活跃树移除;migration_source 保存旧框迁移证据。
-- 父/子外键均 RESTRICT,不能删掉素材而留下无法解释的所有权记录。
-- foundry_check_subgraph:先锁工作区,确认两端是 board,再递归算祖先和后代,
-- 拒绝循环与深度超八;数据库触发器也保护绕过 HTTP 的维护写入。
-- canvas_transactions:账户/画布/动作/幂等键唯一,payload_hash 防止同键换体。
-- response_status/body 冻结重放结果;before_state、after_versions、relation_changes
-- 支持条件撤销;expires_at 七天及 undone_at 控制撤销有效性,不会自动倒退当前版本。
-- db/006-canvas-assets.sql:编码原图 bytea 与绑定同库事务提交,URL 与存储后端解耦。
-- canvas_assets:限制格式和二十 MiB 编码预算,上传者/工作区/幂等键唯一,digest 为原图摘要;
-- 完整像素预算与解码有效性由应用在写入前检查,不能只依赖 MIME 字符串。
-- canvas_asset_bindings:资产可被多个画布引用,主键去重;删除画布级联清绑定,
-- 有绑定资产不能直接删除。可读性按当前绑定画布授权判断,缓存字节不能作为权限证明。
-- db/007-canvas-ai.sql:run/step/event 与旧取消/显式应用回执。
-- canvas_ai_runs:冻结 plan/create_response,保存队列时间、取消位、租约与单调 last_seq;
-- pending 部分索引服务认领,active 索引服务活跃列表;expires_at 表示三十天保留期限。
-- canvas_ai_steps:每 run 的拓扑 ordinal、冻结输入、目标指纹、输出与应用版本;
-- 局部 board/node 活跃部分唯一索引防止同目标同时重复生成。
-- canvas_ai_events:以 run/seq 主键保证重放顺序;appendAIEvent 用同一 SQL 推进 last_seq。
-- canvas_ai_mutations:旧协议按 run/账户/动作/键冻结应用和取消结果;不同于 run 生成重试。
-- 租约过期不证明模型尚未执行,恢复把未知执行标为中断,只有明确 codex_busy 才允许回队。
-- db/008-canvas-model.sql:只安装 canonical schema,不自动迁移已有用户快照。
-- canvas_model_projects:每根显式迁移身份屏障,记录源版本表与 migration_id。
-- canvas_model_canvases:树关系、入口元素、独立版本及 archived;父/入口同时可空,
-- 无父只能是根;延迟外键允许入口元素与孩子关系在同批创建,提交时再验证。
-- canvas_model_active_entry 部分唯一索引防止一个活跃入口拥有多个子画布。
-- canvas_model_elements:主键 (project,element_id) 使身份跨工作区/树不可被抢占;
-- record 的 id/owner/incarnation 必须与索引列相符,删除记录保留 deleted_incarnation。
-- owner 外键延迟验证,支持同事务移动所有权;应用验证整个最终树和连接共同祖先。
-- canvas_model_identity_map:保留来源画布/结构/旧 ID 到稳定元素 ID 的完整一次性映射。
-- canvas_model_requests:账户作用域请求键、动作、摘要、状态与冻结回执,确定拒绝也可恢复。
-- canvas_model_operations:逻辑 ID 独立于传输 request_id 去重,外键延迟到同事务回执落库;
-- 只有应用成功才消费逻辑身份,拒绝前缀不能把其中操作标为已执行。
-- foundry_guard_canonical_canvas:已迁入树的 canvas_document/version 改写需事务内
-- foundry.canonical_writer=on,阻止旧写入路径覆盖权威身份。此标志是应用协作约定,不替代数据库角色权限。
-- db/009-canvas-ai-operations.sql:为 run 增加可空 logical_operation_id,旧行保持 NULL。
-- 部分唯一索引限定项目/工作区/账户下同逻辑操作只能准入一个 run,换传输键不能重复付费执行。
-- db/010-canvas-ai-receipts.sql:把传输回执从执行保留周期中分离。
-- canvas_ai_requests:允许 run.start/cancel/apply,保存 applied/not-applied 与原始请求身份;
-- 不以 run 外键级联删除,使 run 清理后仍可判定已知结果,工作区删除则整体清理。
-- applied 逻辑操作部分唯一:确定零效果拒绝可显式用新键重计划,已应用操作不能再次执行。
-- INSERT ... SELECT 从旧 canonical run 回填 accepted 回执,ON CONFLICT 保留已有记录。
-- 回执缺失只能回答 unknown,不能证明历史付费调用从未发生。
-- db/011-canvas-ai-target-location.sql:分离冻结来源与实际应用位置。
-- applied_board_id:结果写到 owner 移动后的目标画布,旧已应用行按原 board_id 回填。
-- canvas_ai_canonical_target_busy:按根/稳定节点/代数而非原 board 唯一限制活跃步骤,
-- owner-only 移动不能逃过 node_busy,再次删除/恢复的新代则由生命周期检查单独处理。
+196
View File
@@ -0,0 +1,196 @@
# Shared research API
This work belongs to Thesisly 研迹 and uses Foundry Core rather than a separate
application backend. The corpus is public; account sessions and future private
collections remain project scoped.
## Current implementation boundary
`internal/research` implements the HTTP contract and a PostgreSQL repository
based on the fixed Paper Atlas `a3b677b` schema (TEXT/BIGINT columns, native
English title/abstract search index). `cmd/foundry` enables it only when
`FOUNDRY_RESEARCH_DATABASE_URL` is configured. The Paper Atlas migration is now published: 21 tables passed its independent
count/content-hash acceptance. A dedicated `foundry_research_reader` role has
SELECT on the ten tables consumed here, schema USAGE, and read-only defaults.
Its connection is stored only in the protected server file below.
The existing SQLite implementation was withdrawn. Real-corpus integration has
been checked through a loopback Core and the local frontend. Formal production
release still requires the user to merge and choose to deploy; this branch is
not deployed by these checks. Very broad queries remain subject to the budget
and performance limitation documented below.
Do not add `FOUNDRY_RESEARCH_DATABASE`.
The server-side deployment may load a protected
`/opt/endoleap-infra/foundry/research.env` containing
`FOUNDRY_RESEARCH_DATABASE_URL` and `FOUNDRY_RESEARCH_SCHEMA` (default `research`).
Keep the connection string out of Git, Actions variables, browser configuration
and command arguments. Use a dedicated role with schema USAGE and table SELECT
only. Core uses a separate two-connection pool, read-only connection defaults and
read-only transactions. Each research transaction disables JIT locally: the
measured count plan spent about 2.85 seconds compiling JIT functions, and its
end-to-end execution exceeded eight seconds. This does not alter shared
PostgreSQL settings or replace exact counts with estimates. Startup checks the published schema/SELECT permissions;
an explicitly enabled but invalid connection fails candidate readiness.
Deployment migration defaults now follow the shared `foundry-postgres`
container name. `FOUNDRY_POSTGRES_CONTAINER` or the existing `--container` option
can select a different container without changing database/table names.
## Routes
- `GET /projects/{project}/research/papers`
- `GET /projects/{project}/research/papers/{id}`
Only configured Foundry projects are accepted. Reading the public corpus does
not require a session; these routes do not expose private data or accept writes.
List parameters are `q` (200 Unicode characters, 20 words), `searchIn`
(`text` or `author`), `topic` (an exact arXiv category), `sort` (`recent` or
`title`), `cursor` (optional, opaque, at most 32768 characters), and
`pageSize` (1–50, default 8). Unknown, malformed
or repeated parameters return 400. `recent` means descending stable paper ID,
not publication date. Search terms must become bound query parameters, never
raw SQL or user-supplied full-text syntax.
Title/abstract search uses the migration's English vector with
`plainto_tsquery`; author search uses simple-language terms over the stored
author JSON. Both treat input as terms, never full-text operators. Initial full-corpus measurements showed eight-second timeouts for text,
author and topic counts; the unfiltered count took 7.25 seconds. Execution plans
confirmed sequential scans for authors and category joins.
`deploy/research/query-indexes.sql` supplies operator-run concurrent indexes for
those two missing access paths. It is separate from Core startup and auth
migrations; do not grant DDL to the runtime reader. Both indexes completed on the confirmed ECS (category 35.4 seconds, author
436.47 seconds); measured end-to-end checks are documented below.
List responses contain `items`, `nextCursor`, `previousCursor`, `topics`, and
`pageSize`. Empty cursor strings mean that direction is unavailable. There is
no `total`, page number, total page count or deep-page cap. The old `page`
parameter is rejected; coordinate the frontend/backend contract update.
Each paper preserves original title/abstract, authors, source dates, topics and
source links. Publication decisions need source evidence; absent decisions stay
unknown. No invented repositories, metrics or generated research conclusions.
Lists use a read-only repeatable-read snapshot without `count(*)` or `OFFSET`.
Keyset paging uses ID descending for recent order and `(title_key, id)` ascending
for title order, including a reverse query for previous pages. The title key is
kept in its stored codec and C collation. Cursors bind normalized query, search
scope, topic, sort and page size; changing filters requires a fresh cursor. They
are public row positions, not authorization tokens or guaranteed frozen snapshots
across requests. Concurrent corpus edits may alter later pages.
Only pageSize+1 positions are selected; the extra position indicates more data,
then full rows and batched metadata are loaded for at most pageSize papers.
For recent order with only a topic filter, page directly through the existing
`(tag_id,paper_id)` index and deduplicate evidence before LIMIT. For text/author
search in recent order, try an ID interval of 512 near the cursor, expanding
once to 4096 only if there are some matches but fewer than pageSize+1.
Only a full page plus one proves that interval contains the next page. If neither bounded attempt fills the page,
all local candidates are discarded and the complete indexed search is used;
rare or older matches are never silently truncated. The fallback materializes
matching IDs before sorting, avoiding an unbounded ordered heap scan for sparse
terms. Title-order filtered queries still use that complete search and can time
out for broad terms. No global database or proxy resource settings are changed.
The
HTTP layer permits two in-flight queries with an eight-second context budget.
Busy requests return 429 with `Retry-After: 1`; deadlines return 504; storage
errors return a generic 503 without database details. Missing papers return 404.
## Validation
`go test -race -count=1 ./internal/research` covers routing, query limits,
Unicode, anonymous reads, rejected mutations, project lookup, errors, saturation
and timeout slot release. Run compilation/tests only on the user-confirmed ECS
runner. These transport tests do not prove a database connection, full-corpus
query performance or production availability.
The PostgreSQL repository batches source/tag/identifier/submission queries in
the same read-only repeatable-read transaction. Author tuples are displayed as
given name, family name and suffix; an optional fourth affiliation field
is excluded from the display name (observed in real arXiv records); null abstracts/dates remain null. Publication
status comes from the latest observed decision, using decision date and ID as
tie-breakers, and stays unknown when no decision exists. Unit checks cover
author shapes, bound user values and schema qualification. The real Core detail
and homepage HTTP routes have returned 200.
The frontend has also rendered the actual 3,526,999-paper corpus through a
loopback SSH tunnel: eight rows, matching detail title/source, desktop and
mobile layout, no page exceptions or horizontal overflow in that check.
The earlier count-based API returned 146 author records in 0.336 seconds. Before the cursor optimization, after paging/author fixes, category `cs.AR` returned 9,457 records in 4.906
seconds, `CartoonGAN` returned three in 0.332 seconds, and the multi-term search
`attention is all you need` returned 8,653 in 6.325 seconds. These were sequential
manual HTTP checks, not a load test. Very broad text searches can still exceed
the eight-second budget; clients retain search controls so users can narrow
the query or retry. This known limit is not an estimated count or sample
fallback. This is not a
production deployment or an authentication acceptance result.
The existing `deploy/check-schema.sh` also loads the synthetic fixture in
`internal/research/testdata/corpus.sql` inside its disposable PostgreSQL
container (`--network none`, no host port). The research test process receives a
separate SELECT-only fixture role via `RESEARCH_TEST_DATABASE_URL`. These
integration checks execute real SQL for filtering, stable paging, nullable
content, source/tag/identifier joins, latest decision tie-breakers, permission
denial and SQL-backed HTTP routes. They never connect to the shared migration
instance and do not establish full-corpus performance or live-data correctness.
## Text storage compatibility (repair 4e62710)
The Paper Atlas repair uses `nul-soh-v1`: NUL is stored as SOH/SOH, and a
literal SOH as SOH/STX, preserving binary text ordering. Core reads the schema
comment `paper-atlas:text-codec=nul-soh-v1` through `pg_catalog` at startup,
restores SQL text before JSON parsing/API responses, and encodes bound search
terms. An absent/unrelated schema comment keeps legacy text unchanged; an
unsupported marked codec or malformed encoded text fails explicitly.
Schema comments are public metadata, so consumers need no privileges on the
private migration controller. The research role still needs only schema USAGE
and table SELECT. The codec adaptation is on the review branch, pushed with [skip ci] under the
user's no-CI instruction; the published schema marker has been verified with
the runtime reader.
All research tests passed manually against disposable PostgreSQL on the
confirmed ECS, including the encoded SQL fixture for schema detection, raw TEXT restoration,
JSON author/metadata decoding, search and the HTTP round trip. Passing isolated
fixtures does not establish full-corpus API performance.
## Identity handoff
The existing production Core received a configuration-only reload using its
unchanged release binary: the original projects were retained and thesisly was
registered. Both Google and Slack identity records were observed in this
project. The user independently confirmed each provider's real authorization,
reload/new-tab persistence and logout behavior. Browser control was unavailable,
so these browser results are attributed to user acceptance rather than an
automated real-account test. This does not deploy the research work branch;
mail delivery was not exercised.
## Cursor regression coverage
The disposable PostgreSQL fixture covers forward/backward traversal, identical
title keys with different IDs, published control-character encoding, sparse
matches separated by a large ID gap, and fallback from the bounded interval.
Invalid, oversized, cross-filter and wrong-version cursors are rejected before
repository execution. The runtime reader retains SELECT-only privileges; no DDL
or writes are added. Run tests manually on the confirmed ECS; skip CI for this
iteration and retain `[skip ci]` in commit and PR titles.
## Manual cursor measurements (2026-11-07)
On the confirmed ECS, after this task's compilation and disposable fixture had
finished, sequential direct requests to the temporary Core returned: homepage
65 ms, next/previous 39/21 ms, `graph` 345 ms, `CartoonGAN` 731 ms (3 papers),
`cs.AR` 145 ms, title order 180 ms, author `Buhrman` 769 ms, and
`attention is all you need` 1312 ms. Recent, topic and title cursor round trips
returned the same first page without overlap. These are individual manual
samples, not production latency guarantees; concurrent compilation earlier
produced multi-second cold measurements. No proxy, database memory, CPU or
production configuration was changed.
The final source compiled manually on the ECS; package unit checks and all ten
selected cursor/PostgreSQL integration tests passed, including interval expansion
and complete fallback. No CI or local build ran. The local authorized Next dev
uses the temporary API through the existing SSH tunnel. Independent Chrome also
verified real homepage/search navigation, a preserved document, one mobile
header/main, no page exceptions and no horizontal overflow. The production Core
was not replaced by these temporary preview updates.
+4
View File
@@ -1,12 +1,16 @@
// Foundry Go 模块身份,internal 包的导入前缀必须与此一致。
module gitea.entroia.com/Zayden-Jung/foundry-core module gitea.entroia.com/Zayden-Jung/foundry-core
// CI 从此读取工具链版本,避免开发和远程构建使用不同语言契约。
go 1.25.0 go 1.25.0
// 直接依赖提供 PostgreSQL 驱动/事务与图片解码缩放能力。
require ( require (
github.com/jackc/pgx/v5 v5.7.6 github.com/jackc/pgx/v5 v5.7.6
golang.org/x/image v0.25.0 golang.org/x/image v0.25.0
) )
// 以下保留 Go 模块图要求的间接依赖;版本校验摘要由 go.sum 管理。
require ( require (
github.com/jackc/pgpassfile v1.0.0 // indirect github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
+22
View File
@@ -1,3 +1,4 @@
// Package auth 管理项目隔离的登录:提供方回调产生 grant,前端凭 verifier 换取 bearer 会话。
package auth package auth
import ( import (
@@ -19,9 +20,11 @@ import (
"time" "time"
) )
// 项目名限制为可用于路由的短标识;令牌格式对应 32 随机字节的无填充 base64url。
var projectName = regexp.MustCompile(`^[a-z][a-z0-9-]*$`) var projectName = regexp.MustCompile(`^[a-z][a-z0-9-]*$`)
var tokenPattern = regexp.MustCompile(`^[A-Za-z0-9_-]{43}$`) var tokenPattern = regexp.MustCompile(`^[A-Za-z0-9_-]{43}$`)
// service 共享数据库、回调白名单和外部 HTTP 客户端;passwordSlots 限制 bcrypt 并发。
type service struct { type service struct {
db *sql.DB db *sql.DB
projects map[string]*url.URL projects map[string]*url.URL
@@ -33,13 +36,16 @@ type service struct {
slack *SlackConfig slack *SlackConfig
} }
// New 由进程入口调用,验证项目回调并返回独立认证路由;db 的关闭由调用方负责。
func New(db *sql.DB, callbacks map[string]string, redirectURI, id, secret string, email *EmailConfig, slack *SlackConfig) (http.Handler, error) { func New(db *sql.DB, callbacks map[string]string, redirectURI, id, secret string, email *EmailConfig, slack *SlackConfig) (http.Handler, error) {
// 未注册邮箱也执行同成本密码比对,减少通过响应耗时区分账号存在性的差异。
dummy, err := bcrypt.GenerateFromPassword([]byte("foundry-invalid-login-placeholder"), bcrypt.DefaultCost) dummy, err := bcrypt.GenerateFromPassword([]byte("foundry-invalid-login-placeholder"), bcrypt.DefaultCost)
if err != nil { if err != nil {
return nil, err return nil, err
} }
s := &service{db: db, email: email, slack: slack, passwordSlots: make(chan struct{}, 4), dummyPassword: dummy, projects: make(map[string]*url.URL), redirectURI: redirectURI, clientID: id, secret: secret, s := &service{db: db, email: email, slack: slack, passwordSlots: make(chan struct{}, 4), dummyPassword: dummy, projects: make(map[string]*url.URL), redirectURI: redirectURI, clientID: id, secret: secret,
google: &http.Client{Timeout: 10 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}} google: &http.Client{Timeout: 10 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}}
// 回调固定在配置白名单,生产要求 HTTPS,开发仅允许回环主机使用 HTTP。
for name, raw := range callbacks { for name, raw := range callbacks {
u, err := url.Parse(raw) u, err := url.Parse(raw)
if err != nil { if err != nil {
@@ -52,6 +58,7 @@ func New(db *sql.DB, callbacks map[string]string, redirectURI, id, secret string
} }
s.projects[name] = u s.projects[name] = u
} }
// healthz 仅说明进程可响应;readyz 查询账户表,覆盖连接与基础 schema 就绪性。
mux := http.NewServeMux() mux := http.NewServeMux()
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { reply(w, 200, payload{"status": "ok"}) }) mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { reply(w, 200, payload{"status": "ok"}) })
mux.HandleFunc("GET /readyz", s.wrap(func(w http.ResponseWriter, r *http.Request) error { mux.HandleFunc("GET /readyz", s.wrap(func(w http.ResponseWriter, r *http.Request) error {
@@ -73,8 +80,10 @@ func New(db *sql.DB, callbacks map[string]string, redirectURI, id, secret string
}), nil }), nil
} }
// payload 是小型 JSON 响应对象,nil 响应体用于 204 等无内容结果。
type payload map[string]any type payload map[string]any
// reply 必须在尚未写响应时调用;编码/网络错误当前由调用链忽略。
func reply(w http.ResponseWriter, status int, body payload) { func reply(w http.ResponseWriter, status int, body payload) {
if body != nil { if body != nil {
w.Header().Set("Content-Type", "application/json") w.Header().Set("Content-Type", "application/json")
@@ -85,11 +94,13 @@ func reply(w http.ResponseWriter, status int, body payload) {
} }
} }
// reject 已写出预期业务错误并返回 nil,避免 wrap 再次将它改写为 503。
func reject(w http.ResponseWriter, status int, code string) error { func reject(w http.ResponseWriter, status int, code string) error {
reply(w, status, payload{"error": code}) reply(w, status, payload{"error": code})
return nil return nil
} }
// wrap 将未处理依赖错误统一返回 503,日志仅记录类型,避免泄露凭据和提供方响应。
func (s *service) wrap(handle func(http.ResponseWriter, *http.Request) error) http.HandlerFunc { func (s *service) wrap(handle func(http.ResponseWriter, *http.Request) error) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) { return func(w http.ResponseWriter, r *http.Request) {
if err := handle(w, r); err != nil { if err := handle(w, r); err != nil {
@@ -99,17 +110,20 @@ func (s *service) wrap(handle func(http.ResponseWriter, *http.Request) error) ht
} }
} }
// token 生成可放入 Cookie、URL fragment 或请求头的随机凭据。
func token() string { func token() string {
var value [32]byte var value [32]byte
rand.Read(value[:]) rand.Read(value[:])
return base64.RawURLEncoding.EncodeToString(value[:]) return base64.RawURLEncoding.EncodeToString(value[:])
} }
// digest 用于凭据落库摘要和 S256 challenge;不用于密码存储,密码使用 bcrypt。
func digest(value string) string { func digest(value string) string {
sum := sha256.Sum256([]byte(value)) sum := sha256.Sum256([]byte(value))
return base64.RawURLEncoding.EncodeToString(sum[:]) return base64.RawURLEncoding.EncodeToString(sum[:])
} }
// project 先校验项目,再分派登录与会话动作;Origin 缺省的服务端请求仍可进入认证。
func (s *service) project(w http.ResponseWriter, r *http.Request) error { func (s *service) project(w http.ResponseWriter, r *http.Request) error {
project, action := r.PathValue("project"), r.PathValue("action") project, action := r.PathValue("project"), r.PathValue("action")
frontend := s.projects[project] frontend := s.projects[project]
@@ -150,11 +164,14 @@ func (s *service) project(w http.ResponseWriter, r *http.Request) error {
return nil return nil
} }
// oauthCookie 以随机 state 区分并行登录,__Host- 前缀配合 Secure、根路径和无 Domain。
func oauthCookie(state, value string, maxAge int) *http.Cookie { func oauthCookie(state, value string, maxAge int) *http.Cookie {
return &http.Cookie{Name: "__Host-foundry-oauth-" + state, Value: value, Path: "/", MaxAge: maxAge, return &http.Cookie{Name: "__Host-foundry-oauth-" + state, Value: value, Path: "/", MaxAge: maxAge,
Secure: true, HttpOnly: true, SameSite: http.SameSiteLaxMode} Secure: true, HttpOnly: true, SameSite: http.SameSiteLaxMode}
} }
// start 保存十分钟 OAuth 尝试;browser 绑定浏览器,verifier 用于 Google 端 PKCE。
// 前端 challenge 是另一层兑换证明,最终与 login_grants 绑定。
func (s *service) start(w http.ResponseWriter, r *http.Request, project string) error { func (s *service) start(w http.ResponseWriter, r *http.Request, project string) error {
challenge := r.URL.Query().Get("challenge") challenge := r.URL.Query().Get("challenge")
if !tokenPattern.MatchString(challenge) { if !tokenPattern.MatchString(challenge) {
@@ -177,6 +194,7 @@ func (s *service) start(w http.ResponseWriter, r *http.Request, project string)
return nil return nil
} }
// googleJSON 同时用于 Google 和 Slack;客户端拒绝重定向,响应解码最多读取 1 MiB。
func (s *service) googleJSON(ctx context.Context, method, endpoint string, form url.Values, bearer string, result any) error { func (s *service) googleJSON(ctx context.Context, method, endpoint string, form url.Values, bearer string, result any) error {
var body io.Reader var body io.Reader
if form != nil { if form != nil {
@@ -203,6 +221,7 @@ func (s *service) googleJSON(ctx context.Context, method, endpoint string, form
return json.NewDecoder(io.LimitReader(res.Body, 1<<20)).Decode(result) return json.NewDecoder(io.LimitReader(res.Body, 1<<20)).Decode(result)
} }
// callback 原子删除 OAuth 尝试后换取 Google 身份;后续网络失败也不能重放该 state。
func (s *service) callback(w http.ResponseWriter, r *http.Request) error { func (s *service) callback(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context() ctx := r.Context()
query := r.URL.Query() query := r.URL.Query()
@@ -232,6 +251,7 @@ func (s *service) callback(w http.ResponseWriter, r *http.Request) error {
} }
http.SetCookie(w, oauthCookie(state, "", -1)) http.SetCookie(w, oauthCookie(state, "", -1))
// 复制共享 URL 后再写 fragment,避免并发请求改动项目白名单;交换码不放查询参数。
destination := *frontend destination := *frontend
code := query.Get("code") code := query.Get("code")
if code == "" || query.Has("error") { if code == "" || query.Has("error") {
@@ -278,6 +298,7 @@ func (s *service) callback(w http.ResponseWriter, r *http.Request) error {
return nil return nil
} }
// exchange 在同一 SQL 中消费一次性 grant 并建会话;项目、challenge、期限必须全部匹配。
func (s *service) exchange(w http.ResponseWriter, r *http.Request, project string) error { func (s *service) exchange(w http.ResponseWriter, r *http.Request, project string) error {
code, verifier := r.Header.Get("X-Foundry-Code"), r.Header.Get("X-Foundry-Verifier") code, verifier := r.Header.Get("X-Foundry-Code"), r.Header.Get("X-Foundry-Verifier")
if !tokenPattern.MatchString(code) || !tokenPattern.MatchString(verifier) { if !tokenPattern.MatchString(code) || !tokenPattern.MatchString(verifier) {
@@ -307,6 +328,7 @@ func (s *service) exchange(w http.ResponseWriter, r *http.Request, project strin
return nil return nil
} }
// account 的 me 分支校验并续期,logout 按项目删除摘要且允许重复注销返回 204。
func (s *service) account(w http.ResponseWriter, r *http.Request, project string, logout bool) error { func (s *service) account(w http.ResponseWriter, r *http.Request, project string, logout bool) error {
token, ok := strings.CutPrefix(r.Header.Get("Authorization"), "Bearer ") token, ok := strings.CutPrefix(r.Header.Get("Authorization"), "Bearer ")
if !ok || !tokenPattern.MatchString(token) { if !ok || !tokenPattern.MatchString(token) {
+12
View File
@@ -1,3 +1,4 @@
// 邮箱登录链路:注册写待验证记录和 outbox,确认链接才创建账户;登录直接校验 bcrypt。
package auth package auth
import ( import (
@@ -13,11 +14,14 @@ import (
"golang.org/x/crypto/bcrypt" "golang.org/x/crypto/bcrypt"
) )
// emailAddress 统一大小写并拒绝显示名形式,只接受最多 254 字节的纯邮箱地址。
func emailAddress(value string) (string, bool) { func emailAddress(value string) (string, bool) {
value = strings.ToLower(strings.TrimSpace(value)) value = strings.ToLower(strings.TrimSpace(value))
address, err := mail.ParseAddress(value) address, err := mail.ParseAddress(value)
return value, err == nil && address.Address == value && len(value) <= 254 return value, err == nil && address.Address == value && len(value) <= 254
} }
// emailBody 限制 16 KiB、拒绝未知字段及尾随 JSON;失败时已经写出 400。
func emailBody(w http.ResponseWriter, r *http.Request, input any) bool { func emailBody(w http.ResponseWriter, r *http.Request, input any) bool {
decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 16384)) decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 16384))
decoder.DisallowUnknownFields() decoder.DisallowUnknownFields()
@@ -28,6 +32,7 @@ func emailBody(w http.ResponseWriter, r *http.Request, input any) bool {
return true return true
} }
// rateLimit 将键摘要计入数据库十五分钟固定窗口,过期后第一次访问重新计数。
func (s *service) rateLimit(ctx context.Context, key string, limit int) (bool, error) { func (s *service) rateLimit(ctx context.Context, key string, limit int) (bool, error) {
var count int var count int
err := s.db.QueryRowContext(ctx, ` err := s.db.QueryRowContext(ctx, `
@@ -40,6 +45,7 @@ RETURNING attempts
return count <= limit, err return count <= limit, err
} }
// emailAction 由 project 路由调用;先限频,再以非阻塞信号量限制密码哈希占用。
func (s *service) emailAction(w http.ResponseWriter, r *http.Request, project, action string) error { func (s *service) emailAction(w http.ResponseWriter, r *http.Request, project, action string) error {
if action == "verify-email" { if action == "verify-email" {
return s.verifyEmail(w, r, project) return s.verifyEmail(w, r, project)
@@ -70,6 +76,7 @@ func (s *service) emailAction(w http.ResponseWriter, r *http.Request, project, a
w.Header().Set("Retry-After", "900") w.Header().Set("Retry-After", "900")
return reject(w, 429, "rate_limited") return reject(w, 429, "rate_limited")
} }
// 四个槽位都忙时立即返回 429,不让昂贵 bcrypt 请求无限排队。
select { select {
case s.passwordSlots <- struct{}{}: case s.passwordSlots <- struct{}{}:
defer func() { <-s.passwordSlots }() defer func() { <-s.passwordSlots }()
@@ -87,6 +94,7 @@ func (s *service) emailAction(w http.ResponseWriter, r *http.Request, project, a
return err return err
} }
passwordHash := []byte(hash) passwordHash := []byte(hash)
// 不存在的账户使用启动时生成的 dummy 哈希,但无论密码比对结果如何均拒绝登录。
if missing { if missing {
passwordHash = s.dummyPassword passwordHash = s.dummyPassword
} }
@@ -102,6 +110,8 @@ func (s *service) emailAction(w http.ResponseWriter, r *http.Request, project, a
return nil return nil
} }
// registerEmail 在邮箱级事务锁下更新三十分钟验证记录,邮件与记录共同提交。
// 已注册邮箱不写新邮件,仍返回相同 202,避免从此响应枚举账号。
func (s *service) registerEmail(w http.ResponseWriter, r *http.Request, project, email, password string) error { func (s *service) registerEmail(w http.ResponseWriter, r *http.Request, project, email, password string) error {
hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost) hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err != nil { if err != nil {
@@ -147,6 +157,8 @@ INSERT INTO email_outbox(project,recipient,subject,body,expires_at) VALUES($1,$2
return nil return nil
} }
// verifyEmail 先定位邮箱再加同一事务锁,随后删除并返回有效记录以保证验证码一次性消费。
// 账户、邮箱凭据、会话都成功后才提交,任何失败交由 defer 回滚。
func (s *service) verifyEmail(w http.ResponseWriter, r *http.Request, project string) error { func (s *service) verifyEmail(w http.ResponseWriter, r *http.Request, project string) error {
var input struct { var input struct {
Token string `json:"token"` Token string `json:"token"`
+3
View File
@@ -1,3 +1,4 @@
// 认证回归:数据库用例需要 PLATFORM_TEST_DATABASE_URL 指向隔离且已迁移的 fixture。
package auth package auth
import ( import (
@@ -12,6 +13,7 @@ import (
"testing" "testing"
) )
// TestConcurrentRegistrationAndVerification 并发重发注册与消费原验证链接,允许任一先取得邮箱锁;最终只能留下一个凭据或一个待验证记录。
func TestConcurrentRegistrationAndVerification(t *testing.T) { func TestConcurrentRegistrationAndVerification(t *testing.T) {
dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL") dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL")
if dsn == "" { if dsn == "" {
@@ -45,6 +47,7 @@ func TestConcurrentRegistrationAndVerification(t *testing.T) {
if len(match) != 2 { if len(match) != 2 {
t.Fatal("missing verification link") t.Fatal("missing verification link")
} }
// 缓冲通道收集两条 goroutine 的结果;这里断言最终数据库一致性,不规定抢锁顺序。
done := make(chan error, 2) done := make(chan error, 2)
go func() { go func() {
r := httptest.NewRequest("POST", "https://api.example.com/register", nil) r := httptest.NewRequest("POST", "https://api.example.com/register", nil)
+9 -1
View File
@@ -1,3 +1,4 @@
// 本文件把 Google、Slack、邮箱等提供方身份归一为项目账户,并签发一次性交换码。
package auth package auth
import ( import (
@@ -8,7 +9,10 @@ import (
"strings" "strings"
) )
// identityGrant 由已完成提供方验证的登录流程调用;subject 必须是该提供方的稳定身份。
// challenge 来自前端登录起点,后续 exchange 必须提交对应 verifier 才能换取会话。
func (s *service) identityGrant(ctx context.Context, project, provider, subject string, email *string, name, picture, challenge string) (string, error) { func (s *service) identityGrant(ctx context.Context, project, provider, subject string, email *string, name, picture, challenge string) (string, error) {
// 外部资料仅作为初始显示信息:限制姓名长度,头像只接受无用户信息的 HTTPS URL。
name = strings.TrimSpace(name) name = strings.TrimSpace(name)
if len(name) > 160 { if len(name) > 160 {
name = "" name = ""
@@ -20,13 +24,15 @@ func (s *service) identityGrant(ctx context.Context, project, provider, subject
if err != nil { if err != nil {
return "", err return "", err
} }
// 账户、身份关联和短期 grant 同事务提交;任一步失败都不遗留半注册账户。
defer tx.Rollback() defer tx.Rollback()
// Serialize first registration for the same provider identity. // 事务级 advisory lock 串行化同项目、同提供方、同 subject 的首次注册;事务结束即释放。
if _, err = tx.ExecContext(ctx, "SELECT pg_advisory_xact_lock(hashtextextended($1,0))", project+":"+provider+":"+subject); err != nil { if _, err = tx.ExecContext(ctx, "SELECT pg_advisory_xact_lock(hashtextextended($1,0))", project+":"+provider+":"+subject); err != nil {
return "", err return "", err
} }
var account string var account string
err = tx.QueryRowContext(ctx, "SELECT account_id::text FROM account_identities WHERE project=$1 AND provider=$2 AND subject=$3", project, provider, subject).Scan(&account) err = tx.QueryRowContext(ctx, "SELECT account_id::text FROM account_identities WHERE project=$1 AND provider=$2 AND subject=$3", project, provider, subject).Scan(&account)
// 身份不存在才建账户;不会仅凭相同邮箱自动合并不同提供方的身份。
if errors.Is(err, sql.ErrNoRows) { if errors.Is(err, sql.ErrNoRows) {
var googleSubject *string var googleSubject *string
if provider == "google" { if provider == "google" {
@@ -44,6 +50,7 @@ SELECT $1,id,$2,$3,
} }
_, err = tx.ExecContext(ctx, "INSERT INTO account_identities(project,provider,subject,account_id) VALUES($1,$2,$3,$4)", project, provider, subject, account) _, err = tx.ExecContext(ctx, "INSERT INTO account_identities(project,provider,subject,account_id) VALUES($1,$2,$3,$4)", project, provider, subject, account)
} else if err == nil { } else if err == nil {
// 老账户保留已有显示名/头像,只补空值;非空提供方邮箱会更新账户邮箱。
_, err = tx.ExecContext(ctx, ` _, err = tx.ExecContext(ctx, `
UPDATE project_accounts SET email=COALESCE($3,email), UPDATE project_accounts SET email=COALESCE($3,email),
display_name=CASE WHEN display_name='' THEN $4 ELSE display_name END, display_name=CASE WHEN display_name='' THEN $4 ELSE display_name END,
@@ -55,6 +62,7 @@ UPDATE project_accounts SET email=COALESCE($3,email),
if err != nil { if err != nil {
return "", err return "", err
} }
// 只落库交换码摘要,明文仅返回给回调方;一分钟期限和前端 challenge 限制兑换。
grant := token() grant := token()
_, err = tx.ExecContext(ctx, "INSERT INTO login_grants VALUES($1,$2,$3,$4,now()+interval '1 minute')", digest(grant), project, account, challenge) _, err = tx.ExecContext(ctx, "INSERT INTO login_grants VALUES($1,$2,$3,$4,now()+interval '1 minute')", digest(grant), project, account, challenge)
if err != nil { if err != nil {
+12
View File
@@ -1,3 +1,4 @@
// 邮件发送采用数据库 outbox:登录请求写队列,Run 后台轮询租约并通过 SMTP 投递。
package auth package auth
import ( import (
@@ -15,10 +16,12 @@ import (
"time" "time"
) )
// EmailConfig 是可选 SMTP 能力配置;Password 仅用于内存中的 SMTP 认证。
type EmailConfig struct { type EmailConfig struct {
Host, Port, Username, Password, From string Host, Port, Username, Password, From string
} }
// EmailConfigFromEnv 允许整组缺省以关闭邮件登录;部分配置或非 465 TLS 配置会启动失败。
func EmailConfigFromEnv() (*EmailConfig, error) { func EmailConfigFromEnv() (*EmailConfig, error) {
c := &EmailConfig{Host: os.Getenv("SMTP_HOST"), Port: os.Getenv("SMTP_PORT"), Username: os.Getenv("SMTP_USERNAME"), Password: os.Getenv("SMTP_PASSWORD"), From: os.Getenv("SMTP_FROM")} c := &EmailConfig{Host: os.Getenv("SMTP_HOST"), Port: os.Getenv("SMTP_PORT"), Username: os.Getenv("SMTP_USERNAME"), Password: os.Getenv("SMTP_PASSWORD"), From: os.Getenv("SMTP_FROM")}
if c.Host == "" && c.Port == "" && c.Username == "" && c.Password == "" && c.From == "" { if c.Host == "" && c.Port == "" && c.Username == "" && c.Password == "" && c.From == "" {
@@ -31,6 +34,8 @@ func EmailConfigFromEnv() (*EmailConfig, error) {
return c, nil return c, nil
} }
// send 同步发送一封纯文本邮件;拒绝头部换行,并用 TLS 主机名验证和连接期限约束网络操作。
// SMTP 调用不接收 context,Run 的取消要等当前发送结束或网络期限到达。
func (c *EmailConfig) send(recipient, subject, body string) error { func (c *EmailConfig) send(recipient, subject, body string) error {
if strings.ContainsAny(recipient+subject, "\r\n") { if strings.ContainsAny(recipient+subject, "\r\n") {
return errors.New("invalid mail headers") return errors.New("invalid mail headers")
@@ -69,6 +74,7 @@ func (c *EmailConfig) send(recipient, subject, body string) error {
return client.Quit() return client.Quit()
} }
// Run 由进程入口启动;每三秒最多认领一封,nil 配置直接返回,取消上下文停止后续轮询。
func (c *EmailConfig) Run(ctx context.Context, db *sql.DB) { func (c *EmailConfig) Run(ctx context.Context, db *sql.DB) {
if c == nil { if c == nil {
return return
@@ -86,6 +92,9 @@ func (c *EmailConfig) Run(ctx context.Context, db *sql.DB) {
} }
} }
} }
// deliver 用 SKIP LOCKED 避开其他 worker 正在认领的行,两分钟租约允许进程失败后重试。
// SMTP 成功与数据库标记并非同一事务;标记失败时后续可能再次投递。
func (c *EmailConfig) deliver(ctx context.Context, db *sql.DB) error { func (c *EmailConfig) deliver(ctx context.Context, db *sql.DB) error {
var id, lease, recipient, subject, body string var id, lease, recipient, subject, body string
var attempts int var attempts int
@@ -99,11 +108,14 @@ RETURNING id::text,lease_id::text,recipient,subject,body,attempts
if err != nil { if err != nil {
return err return err
} }
// lease 是本轮所有权标记;回写时匹配它,避免旧 worker 覆盖租约到期后的新认领结果。
sendErr := c.send(recipient, subject, body) sendErr := c.send(recipient, subject, body)
if sendErr == nil { if sendErr == nil {
// 成功后清空邮件正文,减少验证码在队列中的保留;收件人和投递记录仍保留。
_, err = db.ExecContext(ctx, "UPDATE email_outbox SET sent_at=now(),body='',lease_until=NULL,lease_id=NULL WHERE id=$1 AND lease_id=$2", id, lease) _, err = db.ExecContext(ctx, "UPDATE email_outbox SET sent_at=now(),body='',lease_until=NULL,lease_id=NULL WHERE id=$1 AND lease_id=$2", id, lease)
return err return err
} }
// attempts 在认领时递增:第一次失败延迟 60 秒,指数退避最多 3840 秒,最多尝试十次。
delay := 30 * (1 << min(attempts, 7)) delay := 30 * (1 << min(attempts, 7))
_, err = db.ExecContext(ctx, "UPDATE email_outbox SET available_at=now()+$3*interval '1 second',lease_until=NULL,lease_id=NULL WHERE id=$1 AND lease_id=$2", id, lease, delay) _, err = db.ExecContext(ctx, "UPDATE email_outbox SET available_at=now()+$3*interval '1 second',lease_until=NULL,lease_id=NULL WHERE id=$1 AND lease_id=$2", id, lease, delay)
if err != nil { if err != nil {
+11
View File
@@ -1,3 +1,4 @@
// 本文件是认证与 platform/research 路由共享的会话入口:数据库同时检查项目、闲置期限和绝对期限。
package auth package auth
import ( import (
@@ -9,11 +10,16 @@ import (
"strings" "strings"
) )
// SessionIdleSeconds 是每次有效访问可续期的闲置窗口,绝对期限仍由数据库列限制。
const SessionIdleSeconds = 30 * 24 * 60 * 60 const SessionIdleSeconds = 30 * 24 * 60 * 60
// SessionExpiryHeader 向客户端返回本次续期后的剩余秒数,供其更新本地会话提示。
const SessionExpiryHeader = "X-Foundry-Session-Expires-In" const SessionExpiryHeader = "X-Foundry-Session-Expires-In"
// ErrInvalidSession 区分凭据无效与数据库故障,调用方可据此选择 401 或服务错误。
var ErrInvalidSession = errors.New("invalid session") var ErrInvalidSession = errors.New("invalid session")
// Session 只携带项目内账户和剩余有效期;原始 bearer token 不进入返回结构。
type Session struct { type Session struct {
AccountID string AccountID string
ExpiresIn int64 ExpiresIn int64
@@ -21,11 +27,13 @@ type Session struct {
// AuthenticateSession atomically validates and renews a live session, bounded by // AuthenticateSession atomically validates and renews a live session, bounded by
// its absolute deadline. Expired, revoked and wrong-project tokens never renew. // its absolute deadline. Expired, revoked and wrong-project tokens never renew.
// AuthenticateSession 在单条 UPDATE 中检查项目、闲置和绝对期限,仅续期仍有效会话并返回剩余秒数。
func AuthenticateSession(ctx context.Context, db *sql.DB, project, authorization string) (Session, error) { func AuthenticateSession(ctx context.Context, db *sql.DB, project, authorization string) (Session, error) {
value, ok := strings.CutPrefix(authorization, "Bearer ") value, ok := strings.CutPrefix(authorization, "Bearer ")
if !ok || !tokenPattern.MatchString(value) { if !ok || !tokenPattern.MatchString(value) {
return Session{}, ErrInvalidSession return Session{}, ErrInvalidSession
} }
// 单条 UPDATE 完成校验和续期,避免先查后写把已经撤销或过期的会话重新激活。
var session Session var session Session
err := db.QueryRowContext(ctx, ` err := db.QueryRowContext(ctx, `
UPDATE project_sessions UPDATE project_sessions
@@ -33,17 +41,20 @@ SET expires_at=LEAST(now()+interval '30 days',absolute_expires_at)
WHERE project=$1 AND token_hash=$2 AND expires_at>now() AND absolute_expires_at>now() WHERE project=$1 AND token_hash=$2 AND expires_at>now() AND absolute_expires_at>now()
RETURNING account_id::text,GREATEST(0,FLOOR(EXTRACT(EPOCH FROM (expires_at-now()))))::bigint RETURNING account_id::text,GREATEST(0,FLOOR(EXTRACT(EPOCH FROM (expires_at-now()))))::bigint
`, project, digest(value)).Scan(&session.AccountID, &session.ExpiresIn) `, project, digest(value)).Scan(&session.AccountID, &session.ExpiresIn)
// 无匹配行包含错误项目、已注销、闲置过期和绝对过期,统一隐藏具体原因。
if errors.Is(err, sql.ErrNoRows) { if errors.Is(err, sql.ErrNoRows) {
return Session{}, ErrInvalidSession return Session{}, ErrInvalidSession
} }
return session, err return session, err
} }
// WriteSessionHeaders 由 HTTP 调用方在写出响应体前执行;它本身不校验或续期。
func WriteSessionHeaders(w http.ResponseWriter, session Session) { func WriteSessionHeaders(w http.ResponseWriter, session Session) {
w.Header().Set(SessionExpiryHeader, strconv.FormatInt(session.ExpiresIn, 10)) w.Header().Set(SessionExpiryHeader, strconv.FormatInt(session.ExpiresIn, 10))
} }
// Authenticate preserves the existing API for clients that only need an account ID. // Authenticate preserves the existing API for clients that only need an account ID.
// Authenticate 供只需账户 ID 的旧调用方使用,同样会触发 AuthenticateSession 的续期。
func Authenticate(ctx context.Context, db *sql.DB, project, authorization string) (string, error) { func Authenticate(ctx context.Context, db *sql.DB, project, authorization string) (string, error) {
session, err := AuthenticateSession(ctx, db, project, authorization) session, err := AuthenticateSession(ctx, db, project, authorization)
return session.AccountID, err return session.AccountID, err
+5
View File
@@ -1,3 +1,4 @@
// 认证回归:数据库用例需要 PLATFORM_TEST_DATABASE_URL 指向隔离且已迁移的 fixture。
package auth package auth
import ( import (
@@ -14,6 +15,7 @@ import (
_ "github.com/jackc/pgx/v5/stdlib" _ "github.com/jackc/pgx/v5/stdlib"
) )
// sessionFixture 建随机项目账户,通过 t.Cleanup 级联删除相关数据并关闭连接池。
func sessionFixture(t *testing.T) (*sql.DB, string, string) { func sessionFixture(t *testing.T) (*sql.DB, string, string) {
t.Helper() t.Helper()
dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL") dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL")
@@ -33,6 +35,7 @@ func sessionFixture(t *testing.T) (*sql.DB, string, string) {
return db, project, account return db, project, account
} }
// TestSessionIdleAndAbsoluteExpiry 覆盖闲置/绝对过期与续期上限;过期记录的时间戳不得被认证请求更新。
func TestSessionIdleAndAbsoluteExpiry(t *testing.T) { func TestSessionIdleAndAbsoluteExpiry(t *testing.T) {
db, project, account := sessionFixture(t) db, project, account := sessionFixture(t)
for _, test := range []struct { for _, test := range []struct {
@@ -85,6 +88,7 @@ func TestSessionIdleAndAbsoluteExpiry(t *testing.T) {
} }
} }
// TestSessionIsolationRevocationAndConcurrentRenewal 检查错误项目与坏凭据拒绝、四个并发续期受绝对期限限制、删除后不能重新续期。
func TestSessionIsolationRevocationAndConcurrentRenewal(t *testing.T) { func TestSessionIsolationRevocationAndConcurrentRenewal(t *testing.T) {
db, project, account := sessionFixture(t) db, project, account := sessionFixture(t)
value := token() value := token()
@@ -116,6 +120,7 @@ func TestSessionIsolationRevocationAndConcurrentRenewal(t *testing.T) {
} }
} }
// TestOAuthExchangeIssuesLongLivedSessionAndMeReturnsRemainingLifetime 从真实 grant 兑换会话,检查三十天闲置/九十天绝对期限,以及 me 响应的续期头。
func TestOAuthExchangeIssuesLongLivedSessionAndMeReturnsRemainingLifetime(t *testing.T) { func TestOAuthExchangeIssuesLongLivedSessionAndMeReturnsRemainingLifetime(t *testing.T) {
db, project, account := sessionFixture(t) db, project, account := sessionFixture(t)
code, verifier := token(), token() code, verifier := token(), token()
+13
View File
@@ -1,3 +1,4 @@
// Slack OIDC 登录验证独立 ID token,再复用 identityGrant 和前端 grant 兑换协议。
package auth package auth
import ( import (
@@ -18,6 +19,7 @@ import (
"time" "time"
) )
// SlackConfig 保存可选客户端凭据以及由 mu 保护的签名公钥缓存。
type SlackConfig struct { type SlackConfig struct {
ClientID, Secret, RedirectURI string ClientID, Secret, RedirectURI string
mu sync.Mutex mu sync.Mutex
@@ -25,6 +27,7 @@ type SlackConfig struct {
fetchedAt time.Time fetchedAt time.Time
} }
// SlackConfigFromEnv 允许整组缺省以关闭 Slack;只配置一半会阻止服务启动。
func SlackConfigFromEnv(redirect string) (*SlackConfig, error) { func SlackConfigFromEnv(redirect string) (*SlackConfig, error) {
id, secret := os.Getenv("SLACK_CLIENT_ID"), os.Getenv("SLACK_CLIENT_SECRET") id, secret := os.Getenv("SLACK_CLIENT_ID"), os.Getenv("SLACK_CLIENT_SECRET")
if id == "" && secret == "" { if id == "" && secret == "" {
@@ -36,6 +39,7 @@ func SlackConfigFromEnv(redirect string) (*SlackConfig, error) {
return &SlackConfig{ClientID: id, Secret: secret, RedirectURI: redirect}, nil return &SlackConfig{ClientID: id, Secret: secret, RedirectURI: redirect}, nil
} }
// slackClaims 仅在验签、发行方/受众/时间和 nonce 校验后用于账户身份。
type slackClaims struct { type slackClaims struct {
Issuer string `json:"iss"` Issuer string `json:"iss"`
Subject string `json:"sub"` Subject string `json:"sub"`
@@ -50,6 +54,7 @@ type slackClaims struct {
Picture string `json:"picture"` Picture string `json:"picture"`
} }
// slackKey 在互斥锁内加载并缓存 JWKS 一分钟;缓存期遇到未知 kid 直接拒绝,避免重复拉取。
func (s *service) slackKey(ctx context.Context, kid string) (*rsa.PublicKey, error) { func (s *service) slackKey(ctx context.Context, kid string) (*rsa.PublicKey, error) {
c := s.slack c := s.slack
c.mu.Lock() c.mu.Lock()
@@ -73,6 +78,7 @@ func (s *service) slackKey(ctx context.Context, kid string) (*rsa.PublicKey, err
if err := s.googleJSON(ctx, "GET", "https://slack.com/openid/connect/keys", nil, "", &document); err != nil { if err := s.googleJSON(ctx, "GET", "https://slack.com/openid/connect/keys", nil, "", &document); err != nil {
return nil, err return nil, err
} }
// 只接收可用于 RS256 签名的 RSA 公钥,并约束模数和指数大小。
keys := map[string]*rsa.PublicKey{} keys := map[string]*rsa.PublicKey{}
for _, key := range document.Keys { for _, key := range document.Keys {
n, nErr := base64.RawURLEncoding.DecodeString(key.N) n, nErr := base64.RawURLEncoding.DecodeString(key.N)
@@ -93,6 +99,8 @@ func (s *service) slackKey(ctx context.Context, kid string) (*rsa.PublicKey, err
} }
return nil, errors.New("unknown Slack signing key") return nil, errors.New("unknown Slack signing key")
} }
// verifySlack 限制 token 长度与算法,先验签再信任 payload;nonce 将身份绑定到本次登录。
func (s *service) verifySlack(ctx context.Context, value, nonce string) (slackClaims, error) { func (s *service) verifySlack(ctx context.Context, value, nonce string) (slackClaims, error) {
var claims slackClaims var claims slackClaims
invalid := errors.New("invalid Slack identity token") invalid := errors.New("invalid Slack identity token")
@@ -136,6 +144,8 @@ func (s *service) verifySlack(ctx context.Context, value, nonce string) (slackCl
} }
return claims, nil return claims, nil
} }
// startSlack 写十分钟尝试和 OIDC nonce,Cookie 采用 SameSite=None 以接收跨站 POST 回调。
func (s *service) startSlack(w http.ResponseWriter, r *http.Request, project string) error { func (s *service) startSlack(w http.ResponseWriter, r *http.Request, project string) error {
if s.slack == nil { if s.slack == nil {
return reject(w, 503, "slack_not_configured") return reject(w, 503, "slack_not_configured")
@@ -159,6 +169,8 @@ VALUES($1,$2,$3,$4,'',now()+interval '10 minutes','slack',$5)
http.Redirect(w, r, "https://slack.com/openid/connect/authorize?"+query.Encode(), 302) http.Redirect(w, r, "https://slack.com/openid/connect/authorize?"+query.Encode(), 302)
return nil return nil
} }
// slackCallback 接受 GET/POST,先一次性消费浏览器绑定的尝试,再向 Slack 兑换 ID token。
func (s *service) slackCallback(w http.ResponseWriter, r *http.Request) error { func (s *service) slackCallback(w http.ResponseWriter, r *http.Request) error {
if s.slack == nil { if s.slack == nil {
return reject(w, 503, "slack_not_configured") return reject(w, 503, "slack_not_configured")
@@ -216,6 +228,7 @@ RETURNING project,frontend_challenge,oidc_nonce
if err != nil { if err != nil {
return err return err
} }
// 团队和用户共同构成 subject;verifySlack 已拒绝冒号,避免拼接身份产生歧义。
grant, err := s.identityGrant(r.Context(), project, "slack", claims.Team+":"+claims.Subject, claims.Email, claims.Name, claims.Picture, challenge) grant, err := s.identityGrant(r.Context(), project, "slack", claims.Team+":"+claims.Subject, claims.Email, claims.Name, claims.Picture, challenge)
if err != nil { if err != nil {
return err return err
+9
View File
@@ -1,3 +1,4 @@
// 认证回归:数据库用例需要 PLATFORM_TEST_DATABASE_URL 指向隔离且已迁移的 fixture。
package auth package auth
import ( import (
@@ -21,6 +22,7 @@ import (
_ "github.com/jackc/pgx/v5/stdlib" _ "github.com/jackc/pgx/v5/stdlib"
) )
// signIdentity 为 fixture kid 生成 RS256 JWT;测试公钥缓存在内存,不访问 Slack JWKS。
func signIdentity(t *testing.T, key *rsa.PrivateKey, claims slackClaims) string { func signIdentity(t *testing.T, key *rsa.PrivateKey, claims slackClaims) string {
t.Helper() t.Helper()
header := base64.RawURLEncoding.EncodeToString([]byte(`{"alg":"RS256","kid":"fixture"}`)) header := base64.RawURLEncoding.EncodeToString([]byte(`{"alg":"RS256","kid":"fixture"}`))
@@ -36,6 +38,8 @@ func signIdentity(t *testing.T, key *rsa.PrivateKey, claims slackClaims) string
} }
return value + "." + base64.RawURLEncoding.EncodeToString(sig) return value + "." + base64.RawURLEncoding.EncodeToString(sig)
} }
// TestSlackIdentityVerification 使用本地 RSA 私钥签发样本,分别破坏发行方、受众、时间、nonce、签名及算法,仅有效样本可通过。
func TestSlackIdentityVerification(t *testing.T) { func TestSlackIdentityVerification(t *testing.T) {
key, err := rsa.GenerateKey(rand.Reader, 2048) key, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil { if err != nil {
@@ -76,6 +80,8 @@ func TestSlackIdentityVerification(t *testing.T) {
}) })
} }
} }
// TestSlackCallbackAndExchange 使用临时 HTTP 上游和真实测试库走 Slack 起点、POST 回调、grant 兑换;拒绝回调重放并保留用户已选资料。
func TestSlackCallbackAndExchange(t *testing.T) { func TestSlackCallbackAndExchange(t *testing.T) {
dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL") dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL")
if dsn == "" { if dsn == "" {
@@ -184,8 +190,10 @@ func TestSlackCallbackAndExchange(t *testing.T) {
} }
} }
// rewriteTransport 只把测试外部调用改写到本地上游,保留路径和请求上下文。
type rewriteTransport struct{ destination string } type rewriteTransport struct{ destination string }
// RoundTrip 克隆请求后改目标,避免修改被测函数持有的原请求对象。
func (t rewriteTransport) RoundTrip(r *http.Request) (*http.Response, error) { func (t rewriteTransport) RoundTrip(r *http.Request) (*http.Response, error) {
cloned := r.Clone(r.Context()) cloned := r.Clone(r.Context())
target, _ := url.Parse(t.destination) target, _ := url.Parse(t.destination)
@@ -193,6 +201,7 @@ func (t rewriteTransport) RoundTrip(r *http.Request) (*http.Response, error) {
return http.DefaultTransport.RoundTrip(cloned) return http.DefaultTransport.RoundTrip(cloned)
} }
// TestGoogleIdentityKeepsLegacyAccount 依赖迁移 fixture 的旧 Google 身份与会话,验证新身份归一流程仍使用原账户且不删除旧会话。
func TestGoogleIdentityKeepsLegacyAccount(t *testing.T) { func TestGoogleIdentityKeepsLegacyAccount(t *testing.T) {
dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL") dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL")
if dsn == "" { if dsn == "" {
+12
View File
@@ -1,3 +1,4 @@
// 画布 AI 的私有 IPC 客户端与模型目录:平台侧只看到稳定模型 ID,执行后端保留在 worker 内。
package codex package codex
import ( import (
@@ -15,8 +16,10 @@ import (
"time" "time"
) )
// CanvasInputLimit 限制提示词字节数;图片另按解码后的总字节限制。
const CanvasInputLimit = 1 << 20 const CanvasInputLimit = 1 << 20
// CanvasModel 是过滤后的模型能力快照;Backend 不序列化,仅供 worker 启动 CLI。
type CanvasModel struct { type CanvasModel struct {
ID string `json:"id"` ID string `json:"id"`
Label string `json:"label"` Label string `json:"label"`
@@ -32,6 +35,7 @@ type CanvasModel struct {
// Only curated catalog fields leave the worker. Raw CLI cache metadata, // Only curated catalog fields leave the worker. Raw CLI cache metadata,
// local paths, authentication files and backend configuration stay private. // local paths, authentication files and backend configuration stay private.
// workerCanvasModels 读取 worker 本地缓存,只公布 list 可见且支持文本/图像输入的条目。
func workerCanvasModels() ([]CanvasModel, error) { func workerCanvasModels() ([]CanvasModel, error) {
raw, err := os.ReadFile("/home/node/.codex/models_cache.json") raw, err := os.ReadFile("/home/node/.codex/models_cache.json")
if err != nil { if err != nil {
@@ -53,6 +57,7 @@ func workerCanvasModels() ([]CanvasModel, error) {
if entry.Visibility != "list" || entry.Slug == "" || strings.HasPrefix(entry.Slug, "-") || len(entry.Slug) > 128 { if entry.Visibility != "list" || entry.Slug == "" || strings.HasPrefix(entry.Slug, "-") || len(entry.Slug) > 128 {
continue continue
} }
// 稳定散列生成公开 ID;标签可展示,实际 slug 不作为公开 Backend 字段输出。
sum := sha256.Sum256([]byte("codex-cli/" + entry.Slug)) sum := sha256.Sum256([]byte("codex-cli/" + entry.Slug))
inputs := []string{} inputs := []string{}
for _, value := range entry.Inputs { for _, value := range entry.Inputs {
@@ -72,6 +77,7 @@ func workerCanvasModels() ([]CanvasModel, error) {
} }
result = append(result, CanvasModel{ID: "codex-" + hex.EncodeToString(sum[:16]), Label: label, Provider: "codex-cli", InputModalities: inputs, OutputModalities: []string{"text"}, Available: true, MaxExecutionMS: 90000, MaxInputBytes: CanvasInputLimit, ParametersSchema: map[string]any{"type": "object", "properties": map[string]any{}, "additionalProperties": false}, Backend: entry.Slug}) result = append(result, CanvasModel{ID: "codex-" + hex.EncodeToString(sum[:16]), Label: label, Provider: "codex-cli", InputModalities: inputs, OutputModalities: []string{"text"}, Available: true, MaxExecutionMS: 90000, MaxInputBytes: CanvasInputLimit, ParametersSchema: map[string]any{"type": "object", "properties": map[string]any{}, "additionalProperties": false}, Backend: entry.Slug})
} }
// 图片输出能力必须显式列入已验证后端名单,不能根据支持图片输入推断支持图片生成。
verified := map[string]bool{} verified := map[string]bool{}
for _, id := range strings.Split(os.Getenv("FOUNDRY_CANVAS_IMAGE_MODELS"), ",") { for _, id := range strings.Split(os.Getenv("FOUNDRY_CANVAS_IMAGE_MODELS"), ",") {
id = strings.TrimSpace(id) id = strings.TrimSpace(id)
@@ -95,8 +101,10 @@ func workerCanvasModels() ([]CanvasModel, error) {
return result, nil return result, nil
} }
// CanvasClient 通过固定 Unix socket 发送 HTTP;URL 主机名只是协议占位符,不进行 DNS 连接。
type CanvasClient struct{ client *http.Client } type CanvasClient struct{ client *http.Client }
// NewCanvasClient 在未配置 socket 时返回 nil,调用方法会转换为明确的不可用错误。
func NewCanvasClient(socket string) *CanvasClient { func NewCanvasClient(socket string) *CanvasClient {
if socket == "" { if socket == "" {
return nil return nil
@@ -106,6 +114,8 @@ func NewCanvasClient(socket string) *CanvasClient {
}} }}
return &CanvasClient{client: &http.Client{Transport: transport, Timeout: 182 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}} return &CanvasClient{client: &http.Client{Transport: transport, Timeout: 182 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}}
} }
// Models 限制目录响应为 256 KiB,只接受成功状态和完整 JSON,隐藏 worker 内部失败原因。
func (c *CanvasClient) Models(ctx context.Context) ([]CanvasModel, error) { func (c *CanvasClient) Models(ctx context.Context) ([]CanvasModel, error) {
if c == nil { if c == nil {
return nil, errors.New("codex_unavailable") return nil, errors.New("codex_unavailable")
@@ -135,6 +145,7 @@ func (c *CanvasClient) Models(ctx context.Context) ([]CanvasModel, error) {
return result.Models, nil return result.Models, nil
} }
// CanvasTask 在 platform 调度器与 worker 之间传递提示、模型及可选图片;当前参数对象必须为空。
type CanvasTask struct { type CanvasTask struct {
OutputModality string `json:"output_modality,omitempty"` OutputModality string `json:"output_modality,omitempty"`
Images []CanvasImage `json:"images,omitempty"` Images []CanvasImage `json:"images,omitempty"`
@@ -143,6 +154,7 @@ type CanvasTask struct {
Parameters map[string]any `json:"parameters"` Parameters map[string]any `json:"parameters"`
} }
// Generate 是只需文本的兼容入口;复用结构化输出校验,并拒绝图片结果。
func (c *CanvasClient) Generate(ctx context.Context, input CanvasTask) (string, error) { func (c *CanvasClient) Generate(ctx context.Context, input CanvasTask) (string, error) {
output, err := c.GenerateOutput(ctx, input) output, err := c.GenerateOutput(ctx, input)
if err != nil { if err != nil {
+8
View File
@@ -1,3 +1,4 @@
// 画布生成的结构化 IPC 输出;图片以字节传到核心,再由平台资产流程验证和持久化。
package codex package codex
import ( import (
@@ -9,13 +10,17 @@ import (
"net/http" "net/http"
) )
// CanvasImageBytesLimit 限制原始图片总字节,响应上限另为 JSON/base64 编码留出空间。
const CanvasImageBytesLimit = 20 << 20 const CanvasImageBytesLimit = 20 << 20
const canvasArtifactResponseLimit = 32 << 20 const canvasArtifactResponseLimit = 32 << 20
// CanvasImage 的 Data 在 JSON 中编码为 base64,仅用于私有 Unix 通道。
type CanvasImage struct { type CanvasImage struct {
MIME string `json:"mime_type"` MIME string `json:"mime_type"`
Data []byte `json:"data"` Data []byte `json:"data"`
} }
// CanvasOutput 用 Kind 区分文本和图片,由 GenerateOutput 再校验形态与请求模态相符。
type CanvasOutput struct { type CanvasOutput struct {
Kind string `json:"kind"` Kind string `json:"kind"`
Text string `json:"text,omitempty"` Text string `json:"text,omitempty"`
@@ -24,6 +29,7 @@ type CanvasOutput struct {
// Encoded image bytes exist only on the private Unix IPC channel. Public Canvas // Encoded image bytes exist only on the private Unix IPC channel. Public Canvas
// jobs expose stable asset IDs/URLs and never serialize these bytes to browsers. // jobs expose stable asset IDs/URLs and never serialize these bytes to browsers.
// GenerateOutput 先检查输入预算,再发送 IPC;映射稳定错误码,兼容旧 worker 的 result 文本字段。
func (c *CanvasClient) GenerateOutput(ctx context.Context, input CanvasTask) (CanvasOutput, error) { func (c *CanvasClient) GenerateOutput(ctx context.Context, input CanvasTask) (CanvasOutput, error) {
if c == nil { if c == nil {
return CanvasOutput{}, errors.New("codex_unavailable") return CanvasOutput{}, errors.New("codex_unavailable")
@@ -51,6 +57,7 @@ func (c *CanvasClient) GenerateOutput(ctx context.Context, input CanvasTask) (Ca
return CanvasOutput{}, err return CanvasOutput{}, err
} }
defer response.Body.Close() defer response.Body.Close()
// 多读一字节区分刚好达到上限与实际超限,防止截断响应被当成成功结果。
raw, err = io.ReadAll(io.LimitReader(response.Body, canvasArtifactResponseLimit+1)) raw, err = io.ReadAll(io.LimitReader(response.Body, canvasArtifactResponseLimit+1))
if err != nil || len(raw) > canvasArtifactResponseLimit { if err != nil || len(raw) > canvasArtifactResponseLimit {
return CanvasOutput{}, errors.New("generation_failed") return CanvasOutput{}, errors.New("generation_failed")
@@ -80,6 +87,7 @@ func (c *CanvasClient) GenerateOutput(ctx context.Context, input CanvasTask) (Ca
return CanvasOutput{}, errors.New("generation_failed") return CanvasOutput{}, errors.New("generation_failed")
} }
} }
// 旧响应只允许回退到文本;图片请求缺少结构化图片时必须失败。
if result.Output == nil { if result.Output == nil {
if input.OutputModality == "image" { if input.OutputModality == "image" {
return CanvasOutput{}, errors.New("generation_failed") return CanvasOutput{}, errors.New("generation_failed")
+4
View File
@@ -1,3 +1,4 @@
// 本文件用临时目录和固定事件验证产物隔离及完成判定,不启动 CLI 或真实模型。
package codex package codex
import ( import (
@@ -7,6 +8,7 @@ import (
"testing" "testing"
) )
// TestCanvasArtifactDirectoryIsolation 拒绝目录外图片、多张图片和软链接,只接收生成目录内唯一图片。
func TestCanvasArtifactDirectoryIsolation(t *testing.T) { func TestCanvasArtifactDirectoryIsolation(t *testing.T) {
root := t.TempDir() root := t.TempDir()
generated := filepath.Join(root, "generated_images") generated := filepath.Join(root, "generated_images")
@@ -48,6 +50,8 @@ func TestCanvasArtifactDirectoryIsolation(t *testing.T) {
t.Fatal("symlink escaped job output directory") t.Fatal("symlink escaped job output directory")
} }
} }
// TestCanvasAgentCompletionRequiresSuccessfulTurn 拒绝仅有部分文本或完成后报错的流,接受成功结束的流。
func TestCanvasAgentCompletionRequiresSuccessfulTurn(t *testing.T) { func TestCanvasAgentCompletionRequiresSuccessfulTurn(t *testing.T) {
if _, ok := canvasAgentText([]byte("{\"type\":\"item.completed\",\"item\":{\"type\":\"agent_message\",\"text\":\"partial\"}}\n")); ok { if _, ok := canvasAgentText([]byte("{\"type\":\"item.completed\",\"item\":{\"type\":\"agent_message\",\"text\":\"partial\"}}\n")); ok {
t.Fatal("partial generation accepted") t.Fatal("partial generation accepted")
+12
View File
@@ -1,3 +1,4 @@
// worker 侧画布执行:每次任务新建临时 CODEX_HOME,按模态启动 CLI 并提取完成结果。
package codex package codex
import ( import (
@@ -16,6 +17,7 @@ import (
"time" "time"
) )
// executeCanvasTask 由共享执行槽保护;模型已从目录选出,但仍须核对请求模态和输入图片。
func executeCanvasTask(w http.ResponseWriter, r *http.Request, input CanvasTask, model CanvasModel) { func executeCanvasTask(w http.ResponseWriter, r *http.Request, input CanvasTask, model CanvasModel) {
imageOutput := input.OutputModality == "image" imageOutput := input.OutputModality == "image"
if input.OutputModality != "" && input.OutputModality != "text" && !imageOutput { if input.OutputModality != "" && input.OutputModality != "text" && !imageOutput {
@@ -32,6 +34,7 @@ func executeCanvasTask(w http.ResponseWriter, r *http.Request, input CanvasTask,
} }
ctx, cancel := context.WithTimeout(r.Context(), duration) ctx, cancel := context.WithTimeout(r.Context(), duration)
defer cancel() defer cancel()
// 临时目录承载认证软链接、输入图片和生成产物;成功与所有失败路径都由 defer 删除。
job, err := os.MkdirTemp("", "foundry-canvas-") job, err := os.MkdirTemp("", "foundry-canvas-")
if err != nil { if err != nil {
fail(w, 503, "codex_unavailable") fail(w, 503, "codex_unavailable")
@@ -43,11 +46,13 @@ func executeCanvasTask(w http.ResponseWriter, r *http.Request, input CanvasTask,
fail(w, 503, "codex_unavailable") fail(w, 503, "codex_unavailable")
return return
} }
// 关闭 shell、应用、插件等能力;文本模型还关闭图片生成,画布模式忽略用户配置与规则。
args := []string{"--ask-for-approval", "never", "--disable", "shell_tool", "--disable", "apps", "--disable", "plugins", "--disable", "multi_agent", "--disable", "hooks", "--disable", "memories", "-c", `web_search="disabled"`} args := []string{"--ask-for-approval", "never", "--disable", "shell_tool", "--disable", "apps", "--disable", "plugins", "--disable", "multi_agent", "--disable", "hooks", "--disable", "memories", "-c", `web_search="disabled"`}
if !imageOutput { if !imageOutput {
args = append(args, "--disable", "image_generation") args = append(args, "--disable", "image_generation")
} }
args = append(args, "exec", "--json", "--sandbox", "read-only", "--skip-git-repo-check", "--ephemeral", "--ignore-user-config", "--ignore-rules", "--model", model.Backend) args = append(args, "exec", "--json", "--sandbox", "read-only", "--skip-git-repo-check", "--ephemeral", "--ignore-user-config", "--ignore-rules", "--model", model.Backend)
// 对图片内容嗅探 MIME,而非仅信任传入类型;只允许已知栅格格式并限制总大小。
total := 0 total := 0
for i, image := range input.Images { for i, image := range input.Images {
total += len(image.Data) total += len(image.Data)
@@ -80,6 +85,7 @@ func executeCanvasTask(w http.ResponseWriter, r *http.Request, input CanvasTask,
cmd.Dir = "/work" cmd.Dir = "/work"
cmd.Env = []string{"PATH=/usr/local/bin:/usr/bin:/bin", "HOME=/home/node", "CODEX_HOME=" + home, "SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt"} cmd.Env = []string{"PATH=/usr/local/bin:/usr/bin:/bin", "HOME=/home/node", "CODEX_HOME=" + home, "SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt"}
cmd.Stdin = strings.NewReader(prompt) cmd.Stdin = strings.NewReader(prompt)
// 独立进程组使请求取消/超时可杀掉 CLI 及其子进程,避免残留后台任务。
cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
cmd.Cancel = func() error { cmd.Cancel = func() error {
err := syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL) err := syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
@@ -103,6 +109,7 @@ func executeCanvasTask(w http.ResponseWriter, r *http.Request, input CanvasTask,
fail(w, 502, "generation_failed") fail(w, 502, "generation_failed")
return return
} }
// CLI 退出零还不够:事件流必须完成且无错误,图片结果还需从专用产物目录读取。
text, completed := canvasAgentText(output.buffer.Bytes()) text, completed := canvasAgentText(output.buffer.Bytes())
if !completed { if !completed {
fail(w, 502, "generation_failed") fail(w, 502, "generation_failed")
@@ -122,6 +129,8 @@ func executeCanvasTask(w http.ResponseWriter, r *http.Request, input CanvasTask,
} }
writeJSON(w, 200, map[string]any{"output": result}) writeJSON(w, 200, map[string]any{"output": result})
} }
// canvasAgentText 逐行读取 JSON 事件,保留最后一条 agent_message;任何坏行或失败事件均拒绝。
func canvasAgentText(raw []byte) (string, bool) { func canvasAgentText(raw []byte) (string, bool) {
result := "" result := ""
completed := false completed := false
@@ -148,6 +157,9 @@ func canvasAgentText(raw []byte) (string, bool) {
} }
return result, completed return result, completed
} }
// readCanvasGeneratedImage 只遍历本次 generated_images,拒绝软链接、非常规文件和多张候选图片。
// 此处只做格式嗅探与字节限制;完整解码和尺寸验证由平台资产接收流程负责。
func readCanvasGeneratedImage(root string) (*CanvasImage, error) { func readCanvasGeneratedImage(root string) (*CanvasImage, error) {
var result *CanvasImage var result *CanvasImage
err := filepath.WalkDir(root, func(path string, entry fs.DirEntry, walkErr error) error { err := filepath.WalkDir(root, func(path string, entry fs.DirEntry, walkErr error) error {
+10
View File
@@ -1,3 +1,4 @@
// 公开文本生成代理:用项目专属凭据授权后,把受限任务通过 Unix IPC 转发给 worker。
package codex package codex
import ( import (
@@ -16,16 +17,19 @@ import (
"time" "time"
) )
// 公开请求 32 KiB、返回 512 KiB;worker 执行期限九十秒,IPC 客户端另留两秒收尾。
const ( const (
maxRequest = 32 << 10 maxRequest = 32 << 10
maxOutput = 512 << 10 maxOutput = 512 << 10
timeout = 90 * time.Second timeout = 90 * time.Second
) )
// task 仅允许 prompt,公开调用方不能传 sandbox、工具配置或可执行参数。
type task struct { type task struct {
Prompt string `json:"prompt"` Prompt string `json:"prompt"`
} }
// writeJSON 统一输出 JSON 并禁用缓存,内部调用者须在此之前完成状态码选择。
func writeJSON(w http.ResponseWriter, status int, value any) { func writeJSON(w http.ResponseWriter, status int, value any) {
w.Header().Set("Content-Type", "application/json") w.Header().Set("Content-Type", "application/json")
w.Header().Set("Cache-Control", "no-store") w.Header().Set("Cache-Control", "no-store")
@@ -33,10 +37,12 @@ func writeJSON(w http.ResponseWriter, status int, value any) {
_ = json.NewEncoder(w).Encode(value) _ = json.NewEncoder(w).Encode(value)
} }
// fail 将依赖或授权失败转换为稳定错误码,避免向公开 API 泄露本地路径和配置。
func fail(w http.ResponseWriter, status int, code string) { func fail(w http.ResponseWriter, status int, code string) {
writeJSON(w, status, map[string]string{"error": code}) writeJSON(w, status, map[string]string{"error": code})
} }
// readTask 限制 JSON 大小、未知字段、尾随值与空白 prompt;失败时已写响应。
func readTask(w http.ResponseWriter, r *http.Request, limit int64) (task, bool) { func readTask(w http.ResponseWriter, r *http.Request, limit int64) (task, bool) {
var input task var input task
decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, limit)) decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, limit))
@@ -59,6 +65,7 @@ func readTask(w http.ResponseWriter, r *http.Request, limit int64) (task, bool)
// Register enables the public endpoint only when both configuration files are supplied. // Register enables the public endpoint only when both configuration files are supplied.
// Each credential digest belongs to exactly one project. // Each credential digest belongs to exactly one project.
// Register 在两项配置齐备时挂载路由,凭据文件每次请求重新读取以支持撤销。
func Register(mux *http.ServeMux, projects map[string]string, socket, grantsFile string) error { func Register(mux *http.ServeMux, projects map[string]string, socket, grantsFile string) error {
if socket == "" && grantsFile == "" { if socket == "" && grantsFile == "" {
return nil return nil
@@ -91,6 +98,7 @@ func Register(mux *http.ServeMux, projects map[string]string, socket, grantsFile
fail(w, 503, "codex_unavailable") fail(w, 503, "codex_unavailable")
return return
} }
// 凭据是 32 字节十六进制值;将摘要与授权表恒定时间比较,再核对目标项目作用域。
hash := sha256.Sum256(key) hash := sha256.Sum256(key)
var scope string var scope string
for digest, project := range grants { for digest, project := range grants {
@@ -113,6 +121,7 @@ func Register(mux *http.ServeMux, projects map[string]string, socket, grantsFile
if !ok { if !ok {
return return
} }
// IPC 只发送解析后的任务体,不转发公开 Authorization 头;连接目的地固定为配置的 socket。
body, _ := json.Marshal(input) body, _ := json.Marshal(input)
req, err := http.NewRequestWithContext(r.Context(), http.MethodPost, "http://codex/exec", bytes.NewReader(body)) req, err := http.NewRequestWithContext(r.Context(), http.MethodPost, "http://codex/exec", bytes.NewReader(body))
if err != nil { if err != nil {
@@ -129,6 +138,7 @@ func Register(mux *http.ServeMux, projects map[string]string, socket, grantsFile
return return
} }
defer resp.Body.Close() defer resp.Body.Close()
// worker 响应必须在预算内且为合法 JSON;保留其状态与 Retry-After,隐藏传输错误细节。
data, err = io.ReadAll(io.LimitReader(resp.Body, maxOutput+1)) data, err = io.ReadAll(io.LimitReader(resp.Body, maxOutput+1))
if err != nil || len(data) > maxOutput || !json.Valid(data) { if err != nil || len(data) > maxOutput || !json.Valid(data) {
fail(w, 502, "invalid_codex_response") fail(w, 502, "invalid_codex_response")
+3
View File
@@ -1,3 +1,4 @@
// 公开代理回归使用临时 Unix socket 假 worker,不访问外部服务或真实 CLI。
package codex package codex
import ( import (
@@ -13,6 +14,7 @@ import (
"testing" "testing"
) )
// TestProjectAuthorizationAndForwarding 检查缺凭据/跨项目拒绝、严格任务体、大小限制及授权文件即时撤销。
func TestProjectAuthorizationAndForwarding(t *testing.T) { func TestProjectAuthorizationAndForwarding(t *testing.T) {
dir := t.TempDir() dir := t.TempDir()
socket := filepath.Join(dir, "worker.sock") socket := filepath.Join(dir, "worker.sock")
@@ -20,6 +22,7 @@ func TestProjectAuthorizationAndForwarding(t *testing.T) {
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
// 假 worker 要求代理已移除 Authorization,只回显 prompt,用于确认最小化转发契约。
worker := &http.Server{Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { worker := &http.Server{Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/exec" || r.Header.Get("Authorization") != "" { if r.URL.Path != "/exec" || r.Header.Get("Authorization") != "" {
fail(w, 500, "unexpected_worker_request") fail(w, 500, "unexpected_worker_request")
+12
View File
@@ -1,3 +1,4 @@
// Package codex 在核心 API 与受限 CLI worker 间通过 Unix socket 通信,隔离公开凭据与本地执行环境。
package codex package codex
import ( import (
@@ -15,16 +16,19 @@ import (
"time" "time"
) )
// executable 指向部署容器预装 CLI,不从请求或 PATH 选择可执行文件。
const executable = "/opt/codex/node_modules/.bin/codex" const executable = "/opt/codex/node_modules/.bin/codex"
var errOutputLimit = errors.New("Codex output limit exceeded") var errOutputLimit = errors.New("Codex output limit exceeded")
// outputBuffer 对 CLI stdout 累计限额;超限标记用于进程结束后选择稳定错误响应。
type outputBuffer struct { type outputBuffer struct {
buffer bytes.Buffer buffer bytes.Buffer
exceeded bool exceeded bool
limit int limit int
} }
// Write 实现 io.Writer,默认使用公共输出限制,画布事件流可另设更大内部预算。
func (b *outputBuffer) Write(p []byte) (int, error) { func (b *outputBuffer) Write(p []byte) (int, error) {
limit := b.limit limit := b.limit
if limit == 0 { if limit == 0 {
@@ -37,6 +41,7 @@ func (b *outputBuffer) Write(p []byte) (int, error) {
return b.buffer.Write(p) return b.buffer.Write(p)
} }
// ServeWorker 由 main 的 codex-worker 模式调用,重建 0600 socket,只允许一个生成任务同时执行。
func ServeWorker(socket string) error { func ServeWorker(socket string) error {
syscall.Umask(0077) syscall.Umask(0077)
if err := os.Remove(socket); err != nil && !errors.Is(err, os.ErrNotExist) { if err := os.Remove(socket); err != nil && !errors.Is(err, os.ErrNotExist) {
@@ -50,6 +55,7 @@ func ServeWorker(socket string) error {
if err := os.Chmod(socket, 0600); err != nil { if err := os.Chmod(socket, 0600); err != nil {
return err return err
} }
// 文本 /exec 与 /canvas/exec 共享一个槽位;忙时立即 429,目录读取不占执行槽。
slot := make(chan struct{}, 1) slot := make(chan struct{}, 1)
mux := http.NewServeMux() mux := http.NewServeMux()
mux.HandleFunc("POST /exec", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("POST /exec", func(w http.ResponseWriter, r *http.Request) {
@@ -87,6 +93,7 @@ func ServeWorker(socket string) error {
fail(w, 503, "codex_unavailable") fail(w, 503, "codex_unavailable")
return return
} }
// 仅按公开 ID 匹配当前目录,再在 worker 内取 Backend,调用方不能任意指定 CLI 模型名。
var selected *CanvasModel var selected *CanvasModel
for _, model := range models { for _, model := range models {
if model.ID == input.ModelID { if model.ID == input.ModelID {
@@ -112,7 +119,10 @@ func ServeWorker(socket string) error {
return server.Serve(listener) return server.Serve(listener)
} }
// execute 为旧文本入口保留默认模型选择,实际进程生命周期集中在 executeModel。
func execute(w http.ResponseWriter, r *http.Request, prompt string) { executeModel(w, r, prompt, "") } func execute(w http.ResponseWriter, r *http.Request, prompt string) { executeModel(w, r, prompt, "") }
// executeModel 用请求期限约束 CLI,禁用外部工具能力;失败仅公开错误码,不转发 stderr。
func executeModel(w http.ResponseWriter, r *http.Request, prompt, model string) { func executeModel(w http.ResponseWriter, r *http.Request, prompt, model string) {
ctx, cancel := context.WithTimeout(r.Context(), timeout) ctx, cancel := context.WithTimeout(r.Context(), timeout)
defer cancel() defer cancel()
@@ -126,6 +136,7 @@ func executeModel(w http.ResponseWriter, r *http.Request, prompt, model string)
cmd.Dir = "/work" cmd.Dir = "/work"
cmd.Env = []string{"PATH=/usr/local/bin:/usr/bin:/bin", "HOME=/home/node", "CODEX_HOME=/home/node/.codex", "SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt"} cmd.Env = []string{"PATH=/usr/local/bin:/usr/bin:/bin", "HOME=/home/node", "CODEX_HOME=/home/node/.codex", "SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt"}
cmd.Stdin = strings.NewReader(prompt) cmd.Stdin = strings.NewReader(prompt)
// Setpgid 配合负 PID kill 终止整个进程组;WaitDelay 约束取消后的输出管道等待。
cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
cmd.Cancel = func() error { cmd.Cancel = func() error {
err := syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL) err := syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
@@ -146,6 +157,7 @@ func executeModel(w http.ResponseWriter, r *http.Request, prompt, model string)
case err != nil: case err != nil:
fail(w, 502, "codex_failed") fail(w, 502, "codex_failed")
default: default:
// 只有合法事件流、成功结束事件及非空最终文本才能作为公开生成结果返回。
var result string var result string
var completed bool var completed bool
for _, line := range bytes.Split(bytes.TrimSpace(output.buffer.Bytes()), []byte("\n")) { for _, line := range bytes.Split(bytes.TrimSpace(output.buffer.Bytes()), []byte("\n")) {
+20
View File
@@ -1,3 +1,4 @@
// 预览派生与进程内缓存:只缓存不可变图片字节,权限必须由调用方每次读取前另行检查。
package platform package platform
import ( import (
@@ -17,23 +18,30 @@ import (
"golang.org/x/image/draw" "golang.org/x/image/draw"
) )
// assetPreviewResult 只包含编码字节和 MIME,可与原图共用只读切片,禁止调用者原地修改。
type assetPreviewResult struct { type assetPreviewResult struct {
data []byte data []byte
mime string mime string
} }
// assetPreviewEntry 存储在 LRU 链表中,key 同时作为 map 索引,便于常数时间淘汰。
type assetPreviewEntry struct { type assetPreviewEntry struct {
key string key string
value assetPreviewResult value assetPreviewResult
} }
// 缓存最多保留 32 MiB/128 项编码结果,互斥锁只覆盖索引操作,不覆盖解码缩放。
var previewMemory = struct { var previewMemory = struct {
sync.Mutex sync.Mutex
entries map[string]*list.Element entries map[string]*list.Element
order *list.List order *list.List
bytes int bytes int
}{entries: make(map[string]*list.Element), order: list.New()} }{entries: make(map[string]*list.Element), order: list.New()}
// previewSlots 将所有预览完整解码限制为单并发,避免多个大图同时分配像素内存。
var previewSlots = make(chan struct{}, 1) var previewSlots = make(chan struct{}, 1)
// previewWidth 仅接受原图或固定 1024 预览,不允许任意宽度组合造成无界缓存键。
func previewWidth(variant, width string) (int, error) { func previewWidth(variant, width string) (int, error) {
if variant == "" && width == "" { if variant == "" && width == "" {
return 0, nil return 0, nil
@@ -46,6 +54,7 @@ func previewWidth(variant, width string) (int, error) {
// Cache only immutable bytes, after the caller checks current asset permission. // Cache only immutable bytes, after the caller checks current asset permission.
// Bound both decoded concurrency and retained encoded data. // Bound both decoded concurrency and retained encoded data.
// cachedAssetPreview 用原图摘要与宽度做键,命中即提升 LRU;等待执行槽可随请求取消。
func cachedAssetPreview(ctx context.Context, encoded []byte, mime string, width int) (assetPreviewResult, error) { func cachedAssetPreview(ctx context.Context, encoded []byte, mime string, width int) (assetPreviewResult, error) {
key := fmt.Sprintf("%x:%d", sha256.Sum256(encoded), width) key := fmt.Sprintf("%x:%d", sha256.Sum256(encoded), width)
previewMemory.Lock() previewMemory.Lock()
@@ -75,6 +84,7 @@ func cachedAssetPreview(ctx context.Context, encoded []byte, mime string, width
if err != nil { if err != nil {
return result, err return result, err
} }
// 单项过大仍可响应,但不留在缓存;其余按字节和项数双预算淘汰末尾最久未用项。
if len(result.data) > 8<<20 { if len(result.data) > 8<<20 {
return result, nil return result, nil
} }
@@ -95,6 +105,7 @@ func cachedAssetPreview(ctx context.Context, encoded []byte, mime string, width
return result, nil return result, nil
} }
// makeAssetPreview 保留 GIF 动画和足够小的原图,其余应用 EXIF 后等比例缩至最长边预算。
func makeAssetPreview(encoded []byte, mime string, width int) (assetPreviewResult, error) { func makeAssetPreview(encoded []byte, mime string, width int) (assetPreviewResult, error) {
original := assetPreviewResult{encoded, mime} original := assetPreviewResult{encoded, mime}
// Keep animation intact. Original bytes remain the canonical AI/download input. // Keep animation intact. Original bytes remain the canonical AI/download input.
@@ -134,6 +145,7 @@ func makeAssetPreview(encoded []byte, mime string, width int) (assetPreviewResul
draw.CatmullRom.Scale(resized, resized.Bounds(), source, source.Bounds(), draw.Src, nil) draw.CatmullRom.Scale(resized, resized.Bounds(), source, source.Bounds(), draw.Src, nil)
var output bytes.Buffer var output bytes.Buffer
outputMime := "image/png" outputMime := "image/png"
// 不透明预览编码 JPEG 以减体积,透明预览保留 PNG;原图字节始终不被覆盖。
if resized.Opaque() { if resized.Opaque() {
err = jpeg.Encode(&output, resized, &jpeg.Options{Quality: 82}) err = jpeg.Encode(&output, resized, &jpeg.Options{Quality: 82})
outputMime = "image/jpeg" outputMime = "image/jpeg"
@@ -143,6 +155,7 @@ func makeAssetPreview(encoded []byte, mime string, width int) (assetPreviewResul
if err != nil { if err != nil {
return original, err return original, err
} }
// 无需修正方向且重编码没有变小时直接用原图,避免更大派生文件。
if output.Len() >= len(encoded) && orientation == 1 { if output.Len() >= len(encoded) && orientation == 1 {
return original, nil return original, nil
} }
@@ -151,6 +164,7 @@ func makeAssetPreview(encoded []byte, mime string, width int) (assetPreviewResul
// JPEG EXIF orientation is applied to previews instead of silently rotating a // JPEG EXIF orientation is applied to previews instead of silently rotating a
// phone photograph after its EXIF metadata is removed by the image encoder. // phone photograph after its EXIF metadata is removed by the image encoder.
// jpegOrientation 仅解析 JPEG APP1 中 TIFF 的 Orientation,逐层检查长度,异常/缺省均返回正常方向一。
func jpegOrientation(data []byte) int { func jpegOrientation(data []byte) int {
if len(data) < 4 || data[0] != 0xff || data[1] != 0xd8 { if len(data) < 4 || data[0] != 0xff || data[1] != 0xd8 {
return 1 return 1
@@ -206,11 +220,13 @@ func jpegOrientation(data []byte) int {
return 1 return 1
} }
// orientedAsset 是只读坐标适配视图,不复制像素;5–8 方向旋转后宽高交换。
type orientedAsset struct { type orientedAsset struct {
image.Image image.Image
orientation int orientation int
} }
// Bounds 报告纠正方向后的零起点矩形,供缩放器计算目标比例。
func (im orientedAsset) Bounds() image.Rectangle { func (im orientedAsset) Bounds() image.Rectangle {
b := im.Image.Bounds() b := im.Image.Bounds()
if im.orientation >= 5 { if im.orientation >= 5 {
@@ -218,7 +234,11 @@ func (im orientedAsset) Bounds() image.Rectangle {
} }
return image.Rect(0, 0, b.Dx(), b.Dy()) return image.Rect(0, 0, b.Dx(), b.Dy())
} }
// ColorModel 继承原图颜色模型,实际像素读取交由 At 做反向坐标映射。
func (im orientedAsset) ColorModel() color.Model { return im.Image.ColorModel() } func (im orientedAsset) ColorModel() color.Model { return im.Image.ColorModel() }
// At 将显示坐标映回原图,再补 Bounds.Min,覆盖 EXIF 八种旋转/镜像组合。
func (im orientedAsset) At(x, y int) color.Color { func (im orientedAsset) At(x, y int) color.Color {
b := im.Image.Bounds() b := im.Image.Bounds()
w, h := b.Dx(), b.Dy() w, h := b.Dx(), b.Dy()
+10
View File
@@ -1,3 +1,4 @@
// 画布与资产纯函数回归;测试说明对应实际断言,不依赖浏览器或真实模型。
package platform package platform
import ( import (
@@ -11,6 +12,7 @@ import (
"testing" "testing"
) )
// TestAssetPreviewDownscalesWithoutChangingOriginal 生成 1600×900 不透明图,验证缩至 512×288、转 JPEG、体积变小且原图字节不变,并比对缓存结果。
func TestAssetPreviewDownscalesWithoutChangingOriginal(t *testing.T) { func TestAssetPreviewDownscalesWithoutChangingOriginal(t *testing.T) {
source := image.NewNRGBA(image.Rect(0, 0, 1600, 900)) source := image.NewNRGBA(image.Rect(0, 0, 1600, 900))
for y := 0; y < 900; y++ { for y := 0; y < 900; y++ {
@@ -39,6 +41,8 @@ func TestAssetPreviewDownscalesWithoutChangingOriginal(t *testing.T) {
t.Fatal("cache result mismatch") t.Fatal("cache result mismatch")
} }
} }
// TestAssetPreviewPreservesTransparencyAndAnimation 验证透明图继续用 PNG,GIF 分支直接保留传入字节;该 GIF 样本不验证真实动画解码。
func TestAssetPreviewPreservesTransparencyAndAnimation(t *testing.T) { func TestAssetPreviewPreservesTransparencyAndAnimation(t *testing.T) {
source := image.NewNRGBA(image.Rect(0, 0, 800, 400)) source := image.NewNRGBA(image.Rect(0, 0, 800, 400))
source.SetNRGBA(1, 1, color.NRGBA{255, 0, 0, 255}) source.SetNRGBA(1, 1, color.NRGBA{255, 0, 0, 255})
@@ -62,6 +66,8 @@ func TestAssetPreviewPreservesTransparencyAndAnimation(t *testing.T) {
t.Fatal("GIF animation changed") t.Fatal("GIF animation changed")
} }
} }
// TestAssetPreviewRejectsUnboundedWidths 验证公开参数仅接受原图或 1024 预览,拒绝任意宽度/未知变体;额外检查坏图片拒绝。
func TestAssetPreviewRejectsUnboundedWidths(t *testing.T) { func TestAssetPreviewRejectsUnboundedWidths(t *testing.T) {
for _, value := range []string{"0", "1", "256", "512", "2048", "999999", "-1", "abc"} { for _, value := range []string{"0", "1", "256", "512", "2048", "999999", "-1", "abc"} {
if _, err := previewWidth("preview", value); err == nil { if _, err := previewWidth("preview", value); err == nil {
@@ -83,6 +89,8 @@ func TestAssetPreviewRejectsUnboundedWidths(t *testing.T) {
t.Fatal("malformed image accepted") t.Fatal("malformed image accepted")
} }
} }
// TestAssetPreviewAppliesJPEGOrientation 手工插入小端 EXIF 方向六,验证缩图前旋转使最终尺寸由横向变为 128×256。
func TestAssetPreviewAppliesJPEGOrientation(t *testing.T) { func TestAssetPreviewAppliesJPEGOrientation(t *testing.T) {
source := image.NewNRGBA(image.Rect(0, 0, 800, 400)) source := image.NewNRGBA(image.Rect(0, 0, 800, 400))
for y := 0; y < 400; y++ { for y := 0; y < 400; y++ {
@@ -116,6 +124,8 @@ func TestAssetPreviewAppliesJPEGOrientation(t *testing.T) {
t.Fatalf("rotated dimensions %dx%d %v", config.Width, config.Height, err) t.Fatalf("rotated dimensions %dx%d %v", config.Width, config.Height, err)
} }
} }
// TestAllAssetOrientationMappings 在八个方向视图中遍历像素,检查唯一红像素不丢失或重复;不逐点断言每种方向的完整布局。
func TestAllAssetOrientationMappings(t *testing.T) { func TestAllAssetOrientationMappings(t *testing.T) {
source := image.NewNRGBA(image.Rect(0, 0, 3, 2)) source := image.NewNRGBA(image.Rect(0, 0, 3, 2))
source.SetNRGBA(0, 0, color.NRGBA{255, 0, 0, 255}) source.SetNRGBA(0, 0, color.NRGBA{255, 0, 0, 255})
+126 -4
View File
@@ -1,3 +1,4 @@
// 不可变画布图片资产:上传原图字节并保留身份,读取时按当前绑定画布权限决定可见性。
package platform package platform
import ( import (
@@ -20,9 +21,11 @@ import (
_ "golang.org/x/image/webp" _ "golang.org/x/image/webp"
) )
// assetLimit 是单图编码字节上限,assetPixelLimit 在完整解码前限制像素分配预算。
const assetLimit = 20 << 20 const assetLimit = 20 << 20
const assetPixelLimit = 40_000_000 const assetPixelLimit = 40_000_000
// assetInfo 是公开元数据,URL 稳定引用私有原图路由,不包含图片内容或上传者身份。
type assetInfo struct { type assetInfo struct {
ID string `json:"id"` ID string `json:"id"`
MIME string `json:"mime_type"` MIME string `json:"mime_type"`
@@ -32,12 +35,14 @@ type assetInfo struct {
URL string `json:"url"` URL string `json:"url"`
} }
// assetURL 将项目与工作区按路径段转义,所有绑定校验使用同一 URL 生成规则。
func (s *service) assetURL(project, workspace, id string) string { func (s *service) assetURL(project, workspace, id string) string {
return s.origin + "/projects/" + url.PathEscape(project) + "/workspaces/" + url.PathEscape(workspace) + "/assets/" + id return s.origin + "/projects/" + url.PathEscape(project) + "/workspaces/" + url.PathEscape(workspace) + "/assets/" + id
} }
// Decode headers first and bound allocation before decoding the actual image. // Decode headers first and bound allocation before decoding the actual image.
// The MIME comes from the decoder, never from the filename or upload header. // The MIME comes from the decoder, never from the filename or upload header.
// inspectAsset 先读取尺寸预算再完整解码,并比较两次识别格式/尺寸,拒绝截断或伪造头部图片。
func inspectAsset(encoded []byte) (string, int, int, error) { func inspectAsset(encoded []byte) (string, int, int, error) {
config, format, err := image.DecodeConfig(bytes.NewReader(encoded)) config, format, err := image.DecodeConfig(bytes.NewReader(encoded))
if err != nil { if err != nil {
@@ -55,6 +60,9 @@ func inspectAsset(encoded []byte) (string, int, int, error) {
} }
return "image/" + format, config.Width, config.Height, nil return "image/" + format, config.Width, config.Height, nil
} }
// uploadAsset 分两次事务检查编辑权限:接收慢 multipart 正文和解码时不持有工作区锁。
// 幂等键限定在上传者/工作区,重复请求必须保持相同图片摘要和可选资源 ID。
func (s *service) uploadAsset(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) uploadAsset(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodPost { if r.Method != http.MethodPost {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -65,6 +73,19 @@ func (s *service) uploadAsset(w http.ResponseWriter, r *http.Request, project, a
reject(w, 400, "invalid_idempotency_key") reject(w, 400, "invalid_idempotency_key")
return nil return nil
} }
resourceID := strings.ToLower(r.Header.Get("X-Resource-Id"))
if resourceID != "" && !uuidSlugPattern.MatchString(resourceID) {
reject(w, 400, "invalid_resource_id")
return nil
}
// 兼容旧版直接返回 assetInfo;指定 X-Resource-Id 的客户端获得带请求 ID 的 v2 应用回执。
respond := func(info assetInfo) {
if resourceID == "" {
reply(w, 201, info)
} else {
reply(w, 201, response{"protocol_version": 2, "request_id": key, "status": "applied", "asset": info})
}
}
tx, err := s.db.BeginTx(r.Context(), nil) tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil { if err != nil {
return err return err
@@ -140,24 +161,35 @@ func (s *service) uploadAsset(w http.ResponseWriter, r *http.Request, project, a
reject(w, 403, "forbidden") reject(w, 403, "forbidden")
return nil return nil
} }
// 第二次取锁后重读权限和幂等记录,防止上传期间撤权或并发重试产生重复资产。
digest := sha256.Sum256(encoded) digest := sha256.Sum256(encoded)
hash := hex.EncodeToString(digest[:]) hash := hex.EncodeToString(digest[:])
info := assetInfo{MIME: mime, Bytes: len(encoded), Width: width, Height: height} info := assetInfo{MIME: mime, Bytes: len(encoded), Width: width, Height: height}
var previous string var previous string
err = tx.QueryRowContext(r.Context(), `SELECT id::text,digest FROM canvas_assets WHERE project=$1 AND workspace_id=$2 AND uploaded_by=$3 AND idempotency_key=$4`, project, workspace, account, key).Scan(&info.ID, &previous) err = tx.QueryRowContext(r.Context(), `SELECT id::text,digest FROM canvas_assets WHERE project=$1 AND workspace_id=$2 AND uploaded_by=$3 AND idempotency_key=$4`, project, workspace, account, key).Scan(&info.ID, &previous)
if err == nil { if err == nil {
if previous != hash { if previous != hash || resourceID != "" && resourceID != info.ID {
reject(w, 409, "idempotency_conflict") reject(w, 409, "idempotency_conflict")
return nil return nil
} }
info.URL = s.assetURL(project, workspace, info.ID) info.URL = s.assetURL(project, workspace, info.ID)
reply(w, 201, info) respond(info)
return nil return nil
} }
if err != sql.ErrNoRows { if err != sql.ErrNoRows {
return err return err
} }
err = tx.QueryRowContext(r.Context(), `INSERT INTO canvas_assets(project,workspace_id,uploaded_by,mime_type,bytes,width,height,digest,idempotency_key) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9) RETURNING id::text`, project, workspace, account, mime, encoded, width, height, hash, key).Scan(&info.ID) if resourceID != "" {
var occupied bool
if err = tx.QueryRowContext(r.Context(), `SELECT EXISTS(SELECT 1 FROM canvas_assets WHERE project=$1 AND workspace_id=$2 AND id=$3)`, project, workspace, resourceID).Scan(&occupied); err != nil {
return err
}
if occupied {
reject(w, 409, "resource_identity_conflict")
return nil
}
}
err = tx.QueryRowContext(r.Context(), `INSERT INTO canvas_assets(project,workspace_id,uploaded_by,mime_type,bytes,width,height,digest,idempotency_key,id) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,COALESCE(NULLIF($10,'')::uuid,gen_random_uuid())) RETURNING id::text`, project, workspace, account, mime, encoded, width, height, hash, key, resourceID).Scan(&info.ID)
if err != nil { if err != nil {
return err return err
} }
@@ -165,9 +197,46 @@ func (s *service) uploadAsset(w http.ResponseWriter, r *http.Request, project, a
return err return err
} }
info.URL = s.assetURL(project, workspace, info.ID) info.URL = s.assetURL(project, workspace, info.ID)
reply(w, 201, info) respond(info)
return nil return nil
} }
// A missing receipt is unknown: callers may only retry the same resource/key/bytes.
// assetOperation 在当前成员授权下查找本人上传回执;缺记录为 unknown,不能据此换键重传或判定零写入。
func (s *service) assetOperation(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet {
reject(w, 405, "method_not_allowed")
return nil
}
key, workspace := r.PathValue("request"), r.PathValue("workspace")
if !uuidSlugPattern.MatchString(key) {
reject(w, 400, "invalid_idempotency_key")
return nil
}
tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil {
return err
}
defer tx.Rollback()
if _, _, err = lockWorkspace(r.Context(), tx, project, workspace, account); err != nil {
return err
}
var info assetInfo
err = tx.QueryRowContext(r.Context(), `SELECT id::text,mime_type,octet_length(bytes),width,height FROM canvas_assets WHERE project=$1 AND workspace_id=$2 AND uploaded_by=$3 AND idempotency_key=$4`, project, workspace, account, key).Scan(&info.ID, &info.MIME, &info.Bytes, &info.Width, &info.Height)
if err == sql.ErrNoRows {
reply(w, 404, response{"protocol_version": 2, "request_id": key, "status": "unknown", "error": "asset_receipt_unknown"})
return nil
}
if err != nil {
return err
}
info.URL = s.assetURL(project, workspace, info.ID)
reply(w, 200, response{"protocol_version": 2, "request_id": key, "status": "applied", "asset": info})
return nil
}
// assetReadable 依赖调用方持有工作区锁:无绑定时只允许上传者/admin,有绑定时需至少一个绑定画布可读。
// 绑定可读性复用 lockMaterial,因此继承根画布权限并尊重子图归档状态。
func assetReadable(r *http.Request, tx *sql.Tx, project, workspace, id, account string) (bool, error) { func assetReadable(r *http.Request, tx *sql.Tx, project, workspace, id, account string) (bool, error) {
var uploader string var uploader string
err := tx.QueryRowContext(r.Context(), `SELECT uploaded_by::text FROM canvas_assets WHERE project=$1 AND workspace_id=$2 AND id=$3`, project, workspace, id).Scan(&uploader) err := tx.QueryRowContext(r.Context(), `SELECT uploaded_by::text FROM canvas_assets WHERE project=$1 AND workspace_id=$2 AND id=$3`, project, workspace, id).Scan(&uploader)
@@ -216,6 +285,55 @@ func assetReadable(r *http.Request, tx *sql.Tx, project, workspace, id, account
} }
return false, nil return false, nil
} }
// Metadata uses the same read policy as original bytes; it is not a persistent grant.
// getAssetMetadata 每次重新鉴权,读取不可变身份摘要后先提交释放锁,再写 JSON,不发放持久权限。
func (s *service) getAssetMetadata(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet {
reject(w, 405, "method_not_allowed")
return nil
}
id, workspace := r.PathValue("asset"), r.PathValue("workspace")
if !uuidSlugPattern.MatchString(id) {
reject(w, 404, "not_found")
return nil
}
tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil {
return err
}
defer tx.Rollback()
var locked string
err = tx.QueryRowContext(r.Context(), `SELECT id::text FROM workspaces WHERE project=$1 AND id=$2 FOR UPDATE`, project, workspace).Scan(&locked)
if err != nil {
return err
}
allowed, err := assetReadable(r, tx, project, workspace, id, account)
if err != nil {
return err
}
if !allowed {
reject(w, 404, "not_found")
return nil
}
var info assetInfo
var digest string
err = tx.QueryRowContext(r.Context(), `SELECT id::text,mime_type,octet_length(bytes),width,height,digest FROM canvas_assets WHERE project=$1 AND workspace_id=$2 AND id=$3`, project, workspace, id).Scan(&info.ID, &info.MIME, &info.Bytes, &info.Width, &info.Height, &digest)
if err != nil {
return err
}
if err = tx.Commit(); err != nil {
return err
}
info.URL = s.assetURL(project, workspace, id)
w.Header().Set("Cache-Control", "private, no-store")
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_ = json.NewEncoder(w).Encode(response{"metadata_version": 1, "asset": info, "sha256": digest})
return nil
}
// getAsset 同时服务原图与固定预览变体;先一致读取权限/字节,释放事务后才缩图或写响应。
func (s *service) getAsset(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) getAsset(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet { if r.Method != http.MethodGet {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -281,6 +399,7 @@ func (s *service) getAsset(w http.ResponseWriter, r *http.Request, project, acco
return err return err
} }
// attachCanvasAssets 为文档内显式 assetId 或同工作区托管 URL 追加绑定;不删除旧绑定,调用方先验证权限。
func (s *service) attachCanvasAssets(r *http.Request, tx *sql.Tx, project, workspace, board string, raw json.RawMessage) error { func (s *service) attachCanvasAssets(r *http.Request, tx *sql.Tx, project, workspace, board string, raw json.RawMessage) error {
for _, data := range canvasNodeData(raw) { for _, data := range canvasNodeData(raw) {
id, _ := data["assetId"].(string) id, _ := data["assetId"].(string)
@@ -304,6 +423,9 @@ func (s *service) attachCanvasAssets(r *http.Request, tx *sql.Tx, project, works
} }
return nil return nil
} }
// validateCanvasAssets 对托管 URL 强制 ID/URL 一致并实时验证可读性,合法引用在同事务中建立当前画布绑定。
// 普通外部图片 URL 在此跳过,交给快照结构校验;它们不会成为私有资产绑定。
func (s *service) validateCanvasAssets(r *http.Request, tx *sql.Tx, project, workspace, account string, raw json.RawMessage) (bool, error) { func (s *service) validateCanvasAssets(r *http.Request, tx *sql.Tx, project, workspace, account string, raw json.RawMessage) (bool, error) {
for _, data := range canvasNodeData(raw) { for _, data := range canvasNodeData(raw) {
id, explicit := data["assetId"].(string) id, explicit := data["assetId"].(string)
+2
View File
@@ -1,3 +1,4 @@
// 资产解码纯函数回归,编码小型真实栅格样本后检查格式与尺寸,不访问数据库。
package platform package platform
import ( import (
@@ -10,6 +11,7 @@ import (
"testing" "testing"
) )
// TestAssetDecodersUseActualContent 验证 PNG/JPEG/GIF 从实际内容识别,拒绝截断样本和未支持的 SVG。
func TestAssetDecodersUseActualContent(t *testing.T) { func TestAssetDecodersUseActualContent(t *testing.T) {
im := image.NewRGBA(image.Rect(0, 0, 3, 2)) im := image.NewRGBA(image.Rect(0, 0, 3, 2))
im.Set(1, 1, color.RGBA{R: 255, A: 255}) im.Set(1, 1, color.RGBA{R: 255, A: 255})
+25
View File
@@ -1,3 +1,4 @@
// 画布快照协议的结构规范化与旧整文档 GET/PATCH;跨画布所有权变更必须走专用事务命令。
package platform package platform
import ( import (
@@ -13,20 +14,26 @@ import (
"unicode/utf8" "unicode/utf8"
) )
// canvasLimit 同时约束快照文档及该路由请求体预算,较大的嵌入图片也计算在内。
const canvasLimit = 5 << 20 const canvasLimit = 5 << 20
var canvasColor = regexp.MustCompile(`^#[0-9a-fA-F]{6}$`) var canvasColor = regexp.MustCompile(`^#[0-9a-fA-F]{6}$`)
var canvasID = regexp.MustCompile(`^[A-Za-z0-9_-]{1,128}$`) var canvasID = regexp.MustCompile(`^[A-Za-z0-9_-]{1,128}$`)
var canvasIcon = regexp.MustCompile(`^[A-Z][A-Za-z0-9]{0,63}$`) var canvasIcon = regexp.MustCompile(`^[A-Z][A-Za-z0-9]{0,63}$`)
// canvasNumber 面向 JSON 解码后的 float64,拒绝非数、无穷和超出闭区间的值。
func canvasNumber(v any, low, high float64) bool { func canvasNumber(v any, low, high float64) bool {
n, ok := v.(float64) n, ok := v.(float64)
return ok && !math.IsNaN(n) && !math.IsInf(n, 0) && n >= low && n <= high return ok && !math.IsNaN(n) && !math.IsInf(n, 0) && n >= low && n <= high
} }
// canvasString 按 Unicode 码点数限制展示文本,与请求体的字节预算分别约束。
func canvasString(v any, limit int) bool { func canvasString(v any, limit int) bool {
s, ok := v.(string) s, ok := v.(string)
return ok && utf8.RuneCountInString(s) <= limit return ok && utf8.RuneCountInString(s) <= limit
} }
// canvasChoice 用于协议枚举白名单;缺省字段由调用处决定是否允许,不能自动匹配零值。
func canvasChoice(v any, choices ...string) bool { func canvasChoice(v any, choices ...string) bool {
for _, s := range choices { for _, s := range choices {
if v == s { if v == s {
@@ -35,6 +42,8 @@ func canvasChoice(v any, choices ...string) bool {
} }
return false return false
} }
// canvasFields 拒绝 nil 和未知键,但不要求所有允许键都存在;必填性由后续类型/值检查保证。
func canvasFields(m map[string]any, fields ...string) bool { func canvasFields(m map[string]any, fields ...string) bool {
if m == nil { if m == nil {
return false return false
@@ -53,6 +62,9 @@ func canvasFields(m map[string]any, fields ...string) bool {
} }
return true return true
} }
// canvasImage 接受无用户信息的 HTTPS URL,或最多 2 MiB 且 MIME 嗅探相符的栅格 data URL。
// 此处不下载 HTTPS 图片,内嵌图也只做头部嗅探,不承担完整图片解码。
func canvasImage(v any) bool { func canvasImage(v any) bool {
s, ok := v.(string) s, ok := v.(string)
if !ok { if !ok {
@@ -71,6 +83,9 @@ func canvasImage(v any) bool {
} }
return false return false
} }
// normalizeCanvas 验证 v1/v2 文档,移除界面临时状态,再重编码为持久快照。
// 仅校验单文档结构;数据库所有权、模型能力与资产权限仍由保存流程另行检查。
func normalizeCanvas(raw json.RawMessage) (json.RawMessage, bool) { func normalizeCanvas(raw json.RawMessage) (json.RawMessage, bool) {
if len(raw) > canvasLimit { if len(raw) > canvasLimit {
return nil, false return nil, false
@@ -95,6 +110,7 @@ func normalizeCanvas(raw json.RawMessage) (json.RawMessage, bool) {
if v2 && (!canvasNumber(viewport["x"], -1e6, 1e6) || !canvasNumber(viewport["y"], -1e6, 1e6)) { if v2 && (!canvasNumber(viewport["x"], -1e6, 1e6) || !canvasNumber(viewport["y"], -1e6, 1e6)) {
return nil, false return nil, false
} }
// 先收集节点类型和框端口,第二遍才检查 frameId/边引用,因此允许合法的前向引用。
kinds := map[string]string{} kinds := map[string]string{}
framePorts := map[string]map[string]string{} framePorts := map[string]map[string]string{}
for _, v := range nodes { for _, v := range nodes {
@@ -102,6 +118,7 @@ func normalizeCanvas(raw json.RawMessage) (json.RawMessage, bool) {
if !ok { if !ok {
return nil, false return nil, false
} }
// 兼容前端 style 中的测量尺寸,但显式 width/height 优先;随后去除 selected/dragging 等临时状态。
if style, ok := n["style"].(map[string]any); ok { if style, ok := n["style"].(map[string]any); ok {
if _, exists := n["width"]; !exists { if _, exists := n["width"]; !exists {
if v, exists := style["width"]; exists { if v, exists := style["width"]; exists {
@@ -130,6 +147,7 @@ func normalizeCanvas(raw json.RawMessage) (json.RawMessage, bool) {
} }
_, w := n["width"] _, w := n["width"]
_, h := n["height"] _, h := n["height"]
// 普通节点与 v2 frame 使用不同尺寸预算,宽高必须同时缺省或同时合法。
low, high := float64(20), float64(3000) low, high := float64(20), float64(3000)
if data, _ := n["data"].(map[string]any); v2 && data["kind"] == "frame" { if data, _ := n["data"].(map[string]any); v2 && data["kind"] == "frame" {
low, high = 32, 100000 low, high = 32, 100000
@@ -189,6 +207,7 @@ func normalizeCanvas(raw json.RawMessage) (json.RawMessage, bool) {
return nil, false return nil, false
} }
} }
// validCanvasFrameExtensions 已检查端口对象形状,此处建立方向索引供边端点验证。
if kind == "frame" && v2 { if kind == "frame" && v2 {
ports := map[string]string{} ports := map[string]string{}
if values, ok := d["ports"].([]any); ok { if values, ok := d["ports"].([]any); ok {
@@ -249,6 +268,7 @@ func normalizeCanvas(raw json.RawMessage) (json.RawMessage, bool) {
} }
// Resolve memberships after all nodes so forward references are valid. // Resolve memberships after all nodes so forward references are valid.
// Geometry never creates membership: only explicit frameId is persisted. // Geometry never creates membership: only explicit frameId is persisted.
// 成员关系只由显式 frameId 决定,几何重叠不产生所有权;框本身不能成为框成员。
for _, value := range nodes { for _, value := range nodes {
data := value.(map[string]any)["data"].(map[string]any) data := value.(map[string]any)["data"].(map[string]any)
if id, exists := data["frameId"]; exists && kinds[id.(string)] != "frame" { if id, exists := data["frameId"]; exists && kinds[id.(string)] != "frame" {
@@ -279,6 +299,7 @@ func normalizeCanvas(raw json.RawMessage) (json.RawMessage, bool) {
if !ok { if !ok {
return nil, false return nil, false
} }
// 边连接 frame 时必须使用已声明端口,源只能 output,目标只能 input。
if v2 && kinds[s] == "frame" { if v2 && kinds[s] == "frame" {
handle, _ := e[key+"Handle"].(string) handle, _ := e[key+"Handle"].(string)
direction := "input" direction := "input"
@@ -315,6 +336,7 @@ func normalizeCanvas(raw json.RawMessage) (json.RawMessage, bool) {
return out, err == nil return out, err == nil
} }
// canvas 读取时在发送响应体前释放事务;保存时将文档、资产绑定及 AI 目标失效一并提交。
func (s *service) canvas(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) canvas(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet && r.Method != http.MethodPatch { if r.Method != http.MethodGet && r.Method != http.MethodPatch {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -390,6 +412,7 @@ func (s *service) canvas(w http.ResponseWriter, r *http.Request, project, accoun
reject(w, 409, "canvas_schema_upgrade_required") reject(w, 409, "canvas_schema_upgrade_required")
return nil return nil
} }
// 已升级文档不可通过旧客户端降回 v1,避免丢失子图和端口等结构。
if previousSchema == 2 && canvasSchema(document) != 2 { if previousSchema == 2 && canvasSchema(document) != 2 {
reject(w, 409, "canvas_schema_upgrade_required") reject(w, 409, "canvas_schema_upgrade_required")
return nil return nil
@@ -398,6 +421,7 @@ func (s *service) canvas(w http.ResponseWriter, r *http.Request, project, accoun
reject(w, 412, "version_conflict") reject(w, 412, "version_conflict")
return nil return nil
} }
// 通过版本检查后仍须保持现有跨画布关系;普通快照不能自行创建或重定向所有权。
if valid, e := validateCanvasRelations(r, tx, project, workspace, material, previousDocument, document); e != nil { if valid, e := validateCanvasRelations(r, tx, project, workspace, material, previousDocument, document); e != nil {
return e return e
} else if !valid { } else if !valid {
@@ -413,6 +437,7 @@ func (s *service) canvas(w http.ResponseWriter, r *http.Request, project, accoun
reject(w, 400, "invalid_asset_reference") reject(w, 400, "invalid_asset_reference")
return nil return nil
} }
// 在相同事务中建立资产引用、使被删除/改变的 AI 目标失效,再推进独立的 canvas_version。
if err = s.attachCanvasAssets(r, tx, project, workspace, material, document); err != nil { if err = s.attachCanvasAssets(r, tx, project, workspace, material, document); err != nil {
return err return err
} }
+81 -37
View File
@@ -1,19 +1,35 @@
// AI 步骤开始/完成的事务边界:执行前与回写前分别校验权限、租约和目标身份,防止迟到输出覆盖新状态。
package platform package platform
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "encoding/json"
"errors"
"gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex" "gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex"
) )
// startCanvasStep 持工作区锁解析目标当前 owner,再检查租约、编辑权限与内容指纹,成功才将 queued 改 running。
// 不可执行时先释放事务,再调用完成流程记录拒绝状态,避免嵌套事务互锁。
func (s *service) startCanvasStep(ctx context.Context, run canvasQueueRun, step canvasAIStepPlan) (bool, error) { func (s *service) startCanvasStep(ctx context.Context, run canvasQueueRun, step canvasAIStepPlan) (bool, error) {
tx, err := s.db.BeginTx(ctx, nil) tx, err := s.db.BeginTx(ctx, nil)
if err != nil { if err != nil {
return false, err return false, err
} }
defer tx.Rollback() defer tx.Rollback()
_, role, permissionErr := lockMaterial(ctx, tx, run.Project, run.Workspace, step.BoardID, run.Account) if err = lockCanvasAIWorkspace(ctx, tx, run.Project, run.Workspace); err != nil {
return false, err
}
board, identityOK, err := resolveCanvasAITarget(ctx, tx, run.Project, run.Workspace, step)
if err != nil {
return false, err
}
if !identityOK {
tx.Rollback()
_, err = s.finishCanvasStep(ctx, run, step, "", "target_removed", false)
return false, err
}
_, role, permissionErr := lockMaterial(ctx, tx, run.Project, run.Workspace, board, run.Account)
if permissionErr != nil || role == "viewer" { if permissionErr != nil || role == "viewer" {
tx.Rollback() tx.Rollback()
if permissionErr != nil && permissionErr != sql.ErrNoRows { if permissionErr != nil && permissionErr != sql.ErrNoRows {
@@ -32,12 +48,12 @@ func (s *service) startCanvasStep(ctx context.Context, run canvasQueueRun, step
_, err = s.finishCanvasStep(ctx, run, step, "", "generation_cancelled", false) _, err = s.finishCanvasStep(ctx, run, step, "", "generation_cancelled", false)
return false, err return false, err
} }
snapshot, err := loadCanvas(queueRequest(ctx), tx, run.Project, run.Workspace, step.BoardID) snapshot, err := loadCanvas(queueRequest(ctx), tx, run.Project, run.Workspace, board)
if err != nil { if err != nil {
return false, err return false, err
} }
data := canvasNodeData(snapshot.Document)[step.NodeID] data := canvasNodeData(snapshot.Document)[step.NodeID]
if data == nil || canvasTargetFingerprint(step.BoardID, step.NodeID, data) != step.Fingerprint { if !identityOK || data == nil || canvasTargetFingerprint(step.BoardID, step.NodeID, data) != step.Fingerprint {
tx.Rollback() tx.Rollback()
_, err = s.finishCanvasStep(ctx, run, step, "", "target_changed", false) _, err = s.finishCanvasStep(ctx, run, step, "", "target_changed", false)
return false, err return false, err
@@ -65,9 +81,13 @@ func (s *service) startCanvasStep(ctx context.Context, run canvasQueueRun, step
} }
return true, nil return true, nil
} }
// finishCanvasStep 是文本/无输出失败路径的兼容包装,所有落库与事件逻辑集中在结构化完成函数。
func (s *service) finishCanvasStep(ctx context.Context, run canvasQueueRun, step canvasAIStepPlan, text, code string, started bool) (string, error) { func (s *service) finishCanvasStep(ctx context.Context, run canvasQueueRun, step canvasAIStepPlan, text, code string, started bool) (string, error) {
return s.finishCanvasStepOutput(ctx, run, step, codex.CanvasOutput{Kind: "text", Text: text}, code, started) return s.finishCanvasStepOutput(ctx, run, step, codex.CanvasOutput{Kind: "text", Text: text}, code, started)
} }
// finishCanvasStepOutput 在同一事务中保存输出、条件应用、步骤终态与事件;已终态或租约失效则直接保留旧结果。
func (s *service) finishCanvasStepOutput(ctx context.Context, run canvasQueueRun, step canvasAIStepPlan, generated codex.CanvasOutput, code string, started bool) (string, error) { func (s *service) finishCanvasStepOutput(ctx context.Context, run canvasQueueRun, step canvasAIStepPlan, generated codex.CanvasOutput, code string, started bool) (string, error) {
tx, err := s.db.BeginTx(ctx, nil) tx, err := s.db.BeginTx(ctx, nil)
if err != nil { if err != nil {
@@ -91,19 +111,21 @@ func (s *service) finishCanvasStepOutput(ctx context.Context, run canvasQueueRun
if err != nil { if err != nil {
return "", err return "", err
} }
// 取消、删除失效和其他完成者已写出的终态优先,迟到 worker 结果不得改回成功。
if oldStatus != "queued" && oldStatus != "running" { if oldStatus != "queued" && oldStatus != "running" {
return oldStatus, nil return oldStatus, nil
} }
if runStatus != "running" || !lease.Valid || lease.String != run.Lease { if runStatus != "running" || !lease.Valid || lease.String != run.Lease {
return oldStatus, nil return oldStatus, nil
} }
// 统一映射依赖失败、内容冲突、取消与生成错误,run.cancel_requested 优先于局部生成结果。
status := "succeeded" status := "succeeded"
switch code { switch code {
case "dependency_failed": case "dependency_failed":
status = "skipped" status = "skipped"
case "target_changed": case "target_changed":
status = "conflict" status = "conflict"
case "generation_cancelled": case "generation_cancelled", "target_removed":
status = "cancelled" status = "cancelled"
default: default:
if code != "" { if code != "" {
@@ -114,8 +136,19 @@ func (s *service) finishCanvasStepOutput(ctx context.Context, run canvasQueueRun
status = "cancelled" status = "cancelled"
code = "generation_cancelled" code = "generation_cancelled"
} }
board, identityOK, err := resolveCanvasAITarget(ctx, tx, run.Project, run.Workspace, step)
if err != nil {
return "", err
}
eventBoard := board
if !identityOK {
eventBoard = step.BoardID
}
var appliedBoard any
var appliedEvent response
var output any var output any
var version any var version any
// 生成成功才保存可供恢复的输出;内容指纹冲突时仍保留 output,但不覆盖当前节点。
if code == "" && started { if code == "" && started {
var outputID string var outputID string
err = tx.QueryRowContext(ctx, `SELECT gen_random_uuid()::text`).Scan(&outputID) err = tx.QueryRowContext(ctx, `SELECT gen_random_uuid()::text`).Scan(&outputID)
@@ -136,10 +169,7 @@ func (s *service) finishCanvasStepOutput(ctx context.Context, run canvasQueueRun
patch["text"] = generated.Text patch["text"] = generated.Text
} }
if err = appendAIEvent(ctx, tx, run.Project, run.Workspace, run.ID, "step.output", response{"step_id": step.ID, "board_id": step.BoardID, "node_id": step.NodeID, "output": output}); err != nil { _, role, permissionErr := lockCanvasAIRunRoute(ctx, tx, run.Project, run.Workspace, eventBoard, run.Account)
return "", err
}
_, role, permissionErr := lockMaterial(ctx, tx, run.Project, run.Workspace, step.BoardID, run.Account)
if permissionErr != nil && permissionErr != sql.ErrNoRows { if permissionErr != nil && permissionErr != sql.ErrNoRows {
return "", permissionErr return "", permissionErr
} }
@@ -147,53 +177,64 @@ func (s *service) finishCanvasStepOutput(ctx context.Context, run canvasQueueRun
status = "failed" status = "failed"
code = "permission_revoked" code = "permission_revoked"
} else { } else {
snapshot, err := loadCanvas(queueRequest(ctx), tx, run.Project, run.Workspace, step.BoardID) snapshot, err := loadCanvas(queueRequest(ctx), tx, run.Project, run.Workspace, eventBoard)
if err != nil { if err != nil {
return "", err return "", err
} }
var doc map[string]any target := canvasNodeData(snapshot.Document)[step.NodeID]
if err = json.Unmarshal(snapshot.Document, &doc); err != nil { if image, ok := output.(response); ok && image["kind"] == "image" && identityOK {
return "", err if _, err = tx.ExecContext(ctx, `INSERT INTO canvas_asset_bindings(project,workspace_id,asset_id,board_id) VALUES($1,$2,$3,$4) ON CONFLICT DO NOTHING`, run.Project, run.Workspace, image["assetId"], eventBoard); err != nil {
} return "", err
var target map[string]any
for _, v := range doc["nodes"].([]any) {
n := v.(map[string]any)
if n["id"] == step.NodeID {
target = n["data"].(map[string]any)
} }
} }
if target == nil || canvasTargetFingerprint(step.BoardID, step.NodeID, target) != step.Fingerprint { // 仍使用原计划来源构造指纹,owner 变化由 canonical 稳定身份单独解析,拖动不造成假冲突。
status = "conflict" if !identityOK || target == nil || canvasTargetFingerprint(step.BoardID, step.NodeID, target) != step.Fingerprint {
code = "target_changed" status, code = "conflict", "target_changed"
} else { } else {
for key, value := range patch { change, err := prepareCanvasAIPatch(queueRequest(ctx), tx, run.Project, run.Workspace, snapshot, step.NodeID, patch)
target[key] = value if err != nil {
} if !errors.Is(err, errAIInvalidPatch) && !errors.Is(err, errCanvasModel) && !errors.Is(err, errGraphCapacity) {
encoded, _ := json.Marshal(doc) return "", err
normalized, ok := normalizeCanvas(encoded) }
if !ok { status, code = "failed", "generation_output_too_large"
status = "failed"
code = "generation_output_too_large"
} else { } else {
snapshot.Document = normalized if err = s.saveCanvasAIChange(queueRequest(ctx), tx, run.Project, run.Workspace, run.Account, change); err != nil {
snapshot.Version++
if err = s.saveCanvas(queueRequest(ctx), tx, run.Project, run.Workspace, snapshot); err != nil {
return "", err
}
version = snapshot.Version
if err = appendAIEvent(ctx, tx, run.Project, run.Workspace, run.ID, "step.applied", response{"step_id": step.ID, "board_id": step.BoardID, "node_id": step.NodeID, "patch": patch, "canvas_version": snapshot.Version}); err != nil {
return "", err return "", err
} }
version = change.Snapshot.Version
appliedBoard = eventBoard
applied := response{"step_id": step.ID, "board_id": eventBoard, "node_id": step.NodeID, "patch": patch, "canvas_version": change.Snapshot.Version}
change.addTargetContext(applied, step)
appliedEvent = applied
} }
} }
} }
} }
// output 与 applied 是不同事件;换 owner 后的冲突附完整模型,客户端可定位当前显式应用目标。
if output != nil {
event := response{"step_id": step.ID, "board_id": eventBoard, "origin_board_id": step.BoardID, "canonical_root": step.CanonicalRoot, "target_incarnation": step.TargetIncarnation, "node_id": step.NodeID, "output": output}
if status == "conflict" && identityOK && step.CanonicalRoot != "" && eventBoard != step.BoardID {
model, e := loadCanvasModel(ctx, tx, run.Project, run.Workspace, step.CanonicalRoot)
if e != nil {
return "", e
}
event["model"], event["document_format_version"], event["canvas_version"] = model.view(nil), canvasModelFormat, model.Versions[eventBoard]
}
if err = appendAIEvent(ctx, tx, run.Project, run.Workspace, run.ID, "step.output", event); err != nil {
return "", err
}
}
if appliedEvent != nil {
if err = appendAIEvent(ctx, tx, run.Project, run.Workspace, run.ID, "step.applied", appliedEvent); err != nil {
return "", err
}
}
var outputJSON any var outputJSON any
if output != nil { if output != nil {
encoded, _ := json.Marshal(output) encoded, _ := json.Marshal(output)
outputJSON = encoded outputJSON = encoded
} }
_, err = tx.ExecContext(ctx, `UPDATE canvas_ai_steps SET status=$5,output=$6,error_code=NULLIF($7,''),applied_version=$8,completed_at=now() WHERE project=$1 AND workspace_id=$2 AND run_id=$3 AND id=$4`, run.Project, run.Workspace, run.ID, step.ID, status, outputJSON, code, version) _, err = tx.ExecContext(ctx, `UPDATE canvas_ai_steps SET status=$5,output=$6,error_code=NULLIF($7,''),applied_version=$8,applied_board_id=$9,completed_at=now() WHERE project=$1 AND workspace_id=$2 AND run_id=$3 AND id=$4`, run.Project, run.Workspace, run.ID, step.ID, status, outputJSON, code, version, appliedBoard)
if err != nil { if err != nil {
return "", err return "", err
} }
@@ -220,6 +261,9 @@ func (s *service) finishCanvasStepOutput(ctx context.Context, run canvasQueueRun
} }
return status, nil return status, nil
} }
// completeCanvasRun 从数据库步骤聚合实际终态而非信任内存 results;仍有活跃步骤则不提前结束 run。
// 仅当前租约可清空租约并写 run.completed,兼容部分成功、全冲突和取消。
func (s *service) completeCanvasRun(ctx context.Context, run canvasQueueRun, _ map[string]canvasStepResult) error { func (s *service) completeCanvasRun(ctx context.Context, run canvasQueueRun, _ map[string]canvasStepResult) error {
tx, err := s.db.BeginTx(ctx, nil) tx, err := s.db.BeginTx(ctx, nil)
if err != nil { if err != nil {
+67 -15
View File
@@ -1,3 +1,4 @@
// 用户取消 AI run:立即冻结数据库终态与回执,worker 心跳在随后一秒级检查中停止在途调用。
package platform package platform
import ( import (
@@ -7,6 +8,7 @@ import (
"net/http" "net/http"
) )
// cancelCanvasAIRun 接受旧空体或完整 v2 身份;重试先返回原回执,再决定是否需要取消 queued/running 步骤。
func (s *service) cancelCanvasAIRun(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) cancelCanvasAIRun(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodPost { if r.Method != http.MethodPost {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -22,29 +24,70 @@ func (s *service) cancelCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
reject(w, 413, "context_too_large") reject(w, 413, "context_too_large")
return nil return nil
} }
input := map[string]any{} var input struct {
if len(raw) > 0 && (json.Unmarshal(raw, &input) != nil || input == nil || len(input) > 0) { ProtocolVersion int `json:"protocol_version,omitempty"`
RequestID string `json:"request_id,omitempty"`
OperationID string `json:"operation_id,omitempty"`
}
if len(raw) > 0 && (json.Unmarshal(raw, &input) != nil || string(raw) == "null") {
reject(w, 400, "invalid_ai_request") reject(w, 400, "invalid_ai_request")
return nil return nil
} }
hash := payloadDigest(input) var fields map[string]any
if len(raw) > 0 {
if json.Unmarshal(raw, &fields) != nil || fields == nil {
reject(w, 400, "invalid_ai_request")
return nil
}
for key := range fields {
if key != "protocol_version" && key != "request_id" && key != "operation_id" {
reject(w, 400, "invalid_ai_request")
return nil
}
}
}
canonical := input.ProtocolVersion != 0 || input.RequestID != "" || input.OperationID != ""
if canonical && (input.ProtocolVersion != 2 || input.RequestID != key || !uuidSlugPattern.MatchString(input.OperationID) || !acceptsCanvasV2(r)) {
reject(w, 400, "invalid_ai_protocol")
return nil
}
if !canonical && len(fields) > 0 {
reject(w, 400, "invalid_ai_request")
return nil
}
hash := payloadDigest(map[string]any{})
if canonical {
hash = payloadDigest(input)
}
workspace, board := r.PathValue("workspace"), r.PathValue("material") workspace, board := r.PathValue("workspace"), r.PathValue("material")
tx, err := s.db.BeginTx(r.Context(), nil) tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil { if err != nil {
return err return err
} }
defer tx.Rollback() defer tx.Rollback()
_, role, err := lockMaterial(r.Context(), tx, project, workspace, board, account) _, role, err := lockCanvasAIRunRoute(r.Context(), tx, project, workspace, board, account)
if err != nil { if err != nil {
return err return err
} }
var receipt *canvasAIRequest
if canonical {
receipt = &canvasAIRequest{Key: key, Hash: hash, Action: "run.cancel", Board: board, Run: id, Operation: input.OperationID}
if done, e := beginCanvasAIRequest(w, r, tx, project, workspace, account, receipt); done || e != nil {
return e
}
}
rejectRequest := func(status int, code string) error {
return rejectCanvasAIRequest(w, r, tx, project, workspace, account, receipt, status, code)
}
if role == "viewer" { if role == "viewer" {
reject(w, 403, "forbidden") return rejectRequest(403, "forbidden")
return nil
} }
var status string var status string
var rawPlan json.RawMessage var rawPlan json.RawMessage
err = tx.QueryRowContext(r.Context(), `SELECT status,plan FROM canvas_ai_runs WHERE project=$1 AND workspace_id=$2 AND board_id=$3 AND id=$4 FOR UPDATE`, project, workspace, board, id).Scan(&status, &rawPlan) err = tx.QueryRowContext(r.Context(), `SELECT status,plan FROM canvas_ai_runs WHERE project=$1 AND workspace_id=$2 AND board_id=$3 AND id=$4 FOR UPDATE`, project, workspace, board, id).Scan(&status, &rawPlan)
if err == sql.ErrNoRows {
return rejectRequest(404, "not_found")
}
if err != nil { if err != nil {
return err return err
} }
@@ -66,16 +109,24 @@ func (s *service) cancelCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
if err = json.Unmarshal(rawPlan, &plan); err != nil { if err = json.Unmarshal(rawPlan, &plan); err != nil {
return err return err
} }
// 取消也要求所有步骤当前目标可编辑,目标移动后按新 owner 权限判断,不能借原 run 路径越权。
for _, step := range plan.Steps { for _, step := range plan.Steps {
_, role, err := lockMaterial(r.Context(), tx, project, workspace, step.BoardID, account) target, ok, e := resolveCanvasAITarget(r.Context(), tx, project, workspace, step)
if e != nil {
return e
}
if !ok {
target = step.BoardID
}
_, role, err := lockCanvasAIRunRoute(r.Context(), tx, project, workspace, target, account)
if err != nil { if err != nil {
return err return err
} }
if role == "viewer" { if role == "viewer" {
reject(w, 403, "forbidden") return rejectRequest(403, "forbidden")
return nil
} }
} }
// 已成功的步骤不回滚;只把仍活跃步骤设 cancelled,并为受影响边写 skipped 事件。
if status == "queued" || status == "running" { if status == "queued" || status == "running" {
_, err = tx.ExecContext(r.Context(), `UPDATE canvas_ai_runs SET status='cancelled',cancel_requested=true,completed_at=now() WHERE project=$1 AND workspace_id=$2 AND id=$3`, project, workspace, id) _, err = tx.ExecContext(r.Context(), `UPDATE canvas_ai_runs SET status='cancelled',cancel_requested=true,completed_at=now() WHERE project=$1 AND workspace_id=$2 AND id=$3`, project, workspace, id)
if err != nil { if err != nil {
@@ -119,10 +170,11 @@ func (s *service) cancelCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
return err return err
} }
} }
rows, err := tx.QueryContext(r.Context(), `SELECT id,board_id::text,node_id,status,applied_version FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND run_id=$3 ORDER BY ordinal`, project, workspace, id) rows, err := tx.QueryContext(r.Context(), `SELECT id,COALESCE(applied_board_id,board_id)::text,node_id,status,applied_version FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND run_id=$3 ORDER BY ordinal`, project, workspace, id)
if err != nil { if err != nil {
return err return err
} }
// 回执分别列出此前已经应用的版本与本次/既有取消步骤,避免把取消误解为撤销所有已生效结果。
applied, cancelledSteps := []any{}, []any{} applied, cancelledSteps := []any{}, []any{}
for rows.Next() { for rows.Next() {
var step, board, node, state string var step, board, node, state string
@@ -145,14 +197,14 @@ func (s *service) cancelCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
return err return err
} }
result := response{"run_id": id, "status": status, "applied": applied, "cancelled_step_ids": cancelledSteps, "worker_stop_grace_ms": 1000} result := response{"run_id": id, "status": status, "applied": applied, "cancelled_step_ids": cancelledSteps, "worker_stop_grace_ms": 1000}
if receipt != nil {
result["run_status"], result["status"] = status, "applied"
bindCanvasAIReceipt(result, receipt)
}
encoded, _ := json.Marshal(result) encoded, _ := json.Marshal(result)
_, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_ai_mutations(project,workspace_id,run_id,account_id,action,idempotency_key,payload_hash,response_body) VALUES($1,$2,$3,$4,'cancel',$5,$6,$7)`, project, workspace, id, account, key, hash, encoded) _, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_ai_mutations(project,workspace_id,run_id,account_id,action,idempotency_key,payload_hash,response_body) VALUES($1,$2,$3,$4,'cancel',$5,$6,$7)`, project, workspace, id, account, key, hash, encoded)
if err != nil { if err != nil {
return err return err
} }
if err = tx.Commit(); err != nil { return commitCanvasAIReceipt(w, r, tx, project, workspace, account, receipt, 200, "applied", result)
return err
}
reply(w, 200, result)
return nil
} }
+7 -1
View File
@@ -1,3 +1,4 @@
// 节点 AI 配置结构校验与目标内容指纹,供快照保存、计划冻结和异步写回共享。
package platform package platform
import ( import (
@@ -5,6 +6,7 @@ import (
"strings" "strings"
) )
// validCanvasAI 限定可生成节点类型及 AI 字段形状;这里只校验参数 JSON 预算,模型目录和参数支持另查。
func validCanvasAI(value any, kind string) bool { func validCanvasAI(value any, kind string) bool {
if !canvasChoice(kind, "text", "script", "plain-text", "image", "plain-image") { if !canvasChoice(kind, "text", "script", "plain-text", "image", "plain-image") {
return false return false
@@ -43,7 +45,11 @@ func validCanvasAI(value any, kind string) bool {
} }
// Fingerprints exclude geometry and visual styles so a result can be applied // Fingerprints exclude geometry and visual styles so a result can be applied
// after a concurrent drag. Content/configuration edits invalidate the result. // after a concurrent drag. The board is the immutable plan origin, not the
// current canonical owner; canonical target identity is checked separately.
// Content/configuration edits invalidate the result.
// canvasTargetFingerprint 绑定计划来源 board/node、内容与 AI 配置,故意忽略几何/样式以允许生成期间拖动。
// Canonical owner 迁移用稳定身份单独校验,不能把当前位置代入原计划 board 重新计算。
func canvasTargetFingerprint(board, node string, data map[string]any) string { func canvasTargetFingerprint(board, node string, data map[string]any) string {
target := map[string]any{"board_id": board, "node_id": node, "kind": data["kind"], "ai": data["ai"]} target := map[string]any{"board_id": board, "node_id": node, "kind": data["kind"], "ai": data["ai"]}
if canvasChoice(data["kind"], "image", "plain-image") { if canvasChoice(data["kind"], "image", "plain-image") {
+87 -53
View File
@@ -1,3 +1,4 @@
// 用户确认应用冲突生成输出:不重新生成,只在当前目标代数、位置和版本均确认后写入已存结果。
package platform package platform
import ( import (
@@ -7,6 +8,7 @@ import (
"unicode/utf8" "unicode/utf8"
) )
// applyCanvasAIOutput 要求 conflict、尚未应用且 run 未取消;v2 显式绑定目标画布/incarnation 和逻辑操作身份。
func (s *service) applyCanvasAIOutput(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) applyCanvasAIOutput(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodPost { if r.Method != http.MethodPost {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -22,8 +24,13 @@ func (s *service) applyCanvasAIOutput(w http.ResponseWriter, r *http.Request, pr
return nil return nil
} }
var input struct { var input struct {
NodeID string `json:"node_id"` ProtocolVersion int `json:"protocol_version,omitempty"`
OutputID string `json:"output_id"` RequestID string `json:"request_id,omitempty"`
OperationID string `json:"operation_id,omitempty"`
TargetIncarnation int64 `json:"target_incarnation,omitempty"`
TargetCanvasID string `json:"target_canvas_id,omitempty"`
NodeID string `json:"node_id"`
OutputID string `json:"output_id"`
} }
if !decode(w, r, &input) { if !decode(w, r, &input) {
return nil return nil
@@ -32,23 +39,43 @@ func (s *service) applyCanvasAIOutput(w http.ResponseWriter, r *http.Request, pr
reject(w, 400, "invalid_ai_request") reject(w, 400, "invalid_ai_request")
return nil return nil
} }
canonical := input.ProtocolVersion != 0 || input.RequestID != "" || input.OperationID != "" || input.TargetIncarnation != 0 || input.TargetCanvasID != ""
if canonical && (input.ProtocolVersion != 2 || input.RequestID != key || !uuidSlugPattern.MatchString(input.OperationID) || input.TargetIncarnation < 1 || !uuidSlugPattern.MatchString(input.TargetCanvasID) || !acceptsCanvasV2(r)) {
reject(w, 400, "invalid_ai_protocol")
return nil
}
hash := payloadDigest(input) hash := payloadDigest(input)
if canonical {
hash = payloadDigest(response{"input": input, "if_match": expected})
}
workspace, board := r.PathValue("workspace"), r.PathValue("material") workspace, board := r.PathValue("workspace"), r.PathValue("material")
tx, err := s.db.BeginTx(r.Context(), nil) tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil { if err != nil {
return err return err
} }
defer tx.Rollback() defer tx.Rollback()
_, role, err := lockMaterial(r.Context(), tx, project, workspace, board, account) _, role, err := lockCanvasAIRunRoute(r.Context(), tx, project, workspace, board, account)
if err != nil { if err != nil {
return err return err
} }
var receipt *canvasAIRequest
if canonical {
receipt = &canvasAIRequest{Key: key, Hash: hash, Action: "run.apply", Board: board, Run: id, Operation: input.OperationID}
if done, e := beginCanvasAIRequest(w, r, tx, project, workspace, account, receipt); done || e != nil {
return e
}
}
rejectRequest := func(status int, code string) error {
return rejectCanvasAIRequest(w, r, tx, project, workspace, account, receipt, status, code)
}
if role == "viewer" { if role == "viewer" {
reject(w, 403, "forbidden") return rejectRequest(403, "forbidden")
return nil
} }
var runStatus string var runStatus string
err = tx.QueryRowContext(r.Context(), `SELECT status FROM canvas_ai_runs WHERE project=$1 AND workspace_id=$2 AND board_id=$3 AND id=$4 FOR UPDATE`, project, workspace, board, id).Scan(&runStatus) err = tx.QueryRowContext(r.Context(), `SELECT status FROM canvas_ai_runs WHERE project=$1 AND workspace_id=$2 AND board_id=$3 AND id=$4 FOR UPDATE`, project, workspace, board, id).Scan(&runStatus)
if err == sql.ErrNoRows {
return rejectRequest(404, "not_found")
}
if err != nil { if err != nil {
return err return err
} }
@@ -71,32 +98,19 @@ func (s *service) applyCanvasAIOutput(w http.ResponseWriter, r *http.Request, pr
if err != sql.ErrNoRows { if err != sql.ErrNoRows {
return err return err
} }
// 输出必须属于该 run 并与请求 node 匹配,不能拿另一输出 ID 或已应用结果重复写入。
var stepID, targetBoard, node, status string var stepID, targetBoard, node, status string
var outputRaw, frozenRaw json.RawMessage var outputRaw, frozenRaw json.RawMessage
var applied sql.NullInt64 var applied sql.NullInt64
err = tx.QueryRowContext(r.Context(), `SELECT id,board_id::text,node_id,status,output,frozen_input,applied_version FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND run_id=$3 AND output->>'output_id'=$4 FOR UPDATE`, project, workspace, id, input.OutputID).Scan(&stepID, &targetBoard, &node, &status, &outputRaw, &frozenRaw, &applied) err = tx.QueryRowContext(r.Context(), `SELECT id,board_id::text,node_id,status,output,frozen_input,applied_version FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND run_id=$3 AND output->>'output_id'=$4 FOR UPDATE`, project, workspace, id, input.OutputID).Scan(&stepID, &targetBoard, &node, &status, &outputRaw, &frozenRaw, &applied)
if err == sql.ErrNoRows {
return rejectRequest(404, "not_found")
}
if err != nil { if err != nil {
return err return err
} }
if node != input.NodeID || status != "conflict" || applied.Valid || runStatus == "cancelled" { if node != input.NodeID || status != "conflict" || applied.Valid || runStatus == "cancelled" {
reject(w, 409, "output_not_applicable") return rejectRequest(409, "output_not_applicable")
return nil
}
_, role, err = lockMaterial(r.Context(), tx, project, workspace, targetBoard, account)
if err != nil {
return err
}
if role == "viewer" {
reject(w, 403, "forbidden")
return nil
}
snapshot, err := loadCanvas(r, tx, project, workspace, targetBoard)
if err != nil {
return err
}
if snapshot.Version != expected {
reject(w, 412, "version_conflict")
return nil
} }
var output struct { var output struct {
Kind string `json:"kind"` Kind string `json:"kind"`
@@ -111,32 +125,57 @@ func (s *service) applyCanvasAIOutput(w http.ResponseWriter, r *http.Request, pr
if err = json.Unmarshal(frozenRaw, &frozen); err != nil { if err = json.Unmarshal(frozenRaw, &frozen); err != nil {
return err return err
} }
if canonical && (frozen.TargetIncarnation != input.TargetIncarnation || frozen.CanonicalRoot == "") {
return rejectRequest(409, "target_changed")
}
// 生成后 owner 可能改变,使用权威身份重新解析;请求确认的 TargetCanvasID 必须仍是当前位置。
targetBoard, identityOK, err := resolveCanvasAITarget(r.Context(), tx, project, workspace, frozen)
if err != nil {
return err
}
if !identityOK {
return rejectRequest(409, "target_changed")
}
if canonical && targetBoard != input.TargetCanvasID {
return rejectRequest(409, "target_changed")
}
_, role, err = lockMaterial(r.Context(), tx, project, workspace, targetBoard, account)
if err != nil {
return err
}
if role == "viewer" {
return rejectRequest(403, "forbidden")
}
snapshot, err := loadCanvas(r, tx, project, workspace, targetBoard)
if err != nil {
return err
}
if snapshot.Version != expected {
return rejectRequest(412, "version_conflict")
}
// 显式应用允许覆盖已编辑的内容,但仍检查输出模态、字节/字符预算及图片当前可读性。
patch := response{} patch := response{}
switch output.Kind { switch output.Kind {
case "text": case "text":
if !canvasChoice(frozen.Kind, "text", "script", "plain-text") || !utf8.ValidString(output.Text) || utf8.RuneCountInString(output.Text) > 100000 { if !canvasChoice(frozen.Kind, "text", "script", "plain-text") || !utf8.ValidString(output.Text) || utf8.RuneCountInString(output.Text) > 100000 {
reject(w, 422, "model_incompatible") return rejectRequest(422, "model_incompatible")
return nil
} }
patch["text"] = output.Text patch["text"] = output.Text
case "image": case "image":
if !canvasChoice(frozen.Kind, "image", "plain-image") || !uuidSlugPattern.MatchString(output.AssetID) || output.Src != s.assetURL(project, workspace, output.AssetID) { if !canvasChoice(frozen.Kind, "image", "plain-image") || !uuidSlugPattern.MatchString(output.AssetID) || output.Src != s.assetURL(project, workspace, output.AssetID) {
reject(w, 422, "model_incompatible") return rejectRequest(422, "model_incompatible")
return nil
} }
readable, err := assetReadable(r, tx, project, workspace, output.AssetID, account) readable, err := assetReadable(r, tx, project, workspace, output.AssetID, account)
if err != nil { if err != nil {
return err return err
} }
if !readable { if !readable {
reject(w, 404, "not_found") return rejectRequest(404, "not_found")
return nil
} }
patch["src"] = output.Src patch["src"] = output.Src
patch["assetId"] = output.AssetID patch["assetId"] = output.AssetID
default: default:
reject(w, 422, "model_incompatible") return rejectRequest(422, "model_incompatible")
return nil
} }
var doc map[string]any var doc map[string]any
@@ -151,44 +190,39 @@ func (s *service) applyCanvasAIOutput(w http.ResponseWriter, r *http.Request, pr
} }
} }
if target == nil { if target == nil {
reject(w, 404, "not_found") return rejectRequest(404, "not_found")
return nil
} }
if target["kind"] != frozen.Kind { if target["kind"] != frozen.Kind {
reject(w, 409, "ownership_conflict") return rejectRequest(409, "ownership_conflict")
return nil
} }
for key, value := range patch { // 通过共享窄字段 patch 保存,原几何和未知元数据不被旧输出快照回滚;应用版本与事件/回执同事务提交。
target[key] = value change, err := prepareCanvasAIPatch(r, tx, project, workspace, snapshot, node, patch)
if err != nil {
return rejectRequest(413, "canvas_too_large")
} }
encoded, _ := json.Marshal(doc) snapshot = change.Snapshot
normalized, ok := normalizeCanvas(encoded) if err = s.saveCanvasAIChange(r, tx, project, workspace, account, change); err != nil {
if !ok {
reject(w, 413, "canvas_too_large")
return nil
}
snapshot.Document = normalized
snapshot.Version++
if err = s.saveCanvas(r, tx, project, workspace, snapshot); err != nil {
return err return err
} }
_, err = tx.ExecContext(r.Context(), `UPDATE canvas_ai_steps SET applied_version=$5 WHERE project=$1 AND workspace_id=$2 AND run_id=$3 AND id=$4`, project, workspace, id, stepID, snapshot.Version)
_, err = tx.ExecContext(r.Context(), `UPDATE canvas_ai_steps SET applied_version=$5,applied_board_id=$6 WHERE project=$1 AND workspace_id=$2 AND run_id=$3 AND id=$4`, project, workspace, id, stepID, snapshot.Version, targetBoard)
if err != nil { if err != nil {
return err return err
} }
result := response{"run_id": id, "step_id": stepID, "board_id": targetBoard, "node_id": node, "output_id": input.OutputID, "canvas_version": snapshot.Version, "patch": patch} result := response{"run_id": id, "step_id": stepID, "board_id": targetBoard, "node_id": node, "output_id": input.OutputID, "canvas_version": snapshot.Version, "patch": patch}
change.addTargetContext(result, frozen)
if receipt != nil {
result["status"] = "applied"
bindCanvasAIReceipt(result, receipt)
}
if err = appendAIEvent(r.Context(), tx, project, workspace, id, "step.applied", result); err != nil { if err = appendAIEvent(r.Context(), tx, project, workspace, id, "step.applied", result); err != nil {
return err return err
} }
encoded, _ = json.Marshal(result) encoded, _ := json.Marshal(result)
_, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_ai_mutations(project,workspace_id,run_id,account_id,action,idempotency_key,payload_hash,response_body) VALUES($1,$2,$3,$4,'apply',$5,$6,$7)`, project, workspace, id, account, key, hash, encoded) _, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_ai_mutations(project,workspace_id,run_id,account_id,action,idempotency_key,payload_hash,response_body) VALUES($1,$2,$3,$4,'apply',$5,$6,$7)`, project, workspace, id, account, key, hash, encoded)
if err != nil { if err != nil {
return err return err
} }
if err = tx.Commit(); err != nil {
return err
}
setVersion(w, snapshot.Version) setVersion(w, snapshot.Version)
reply(w, 200, result) return commitCanvasAIReceipt(w, r, tx, project, workspace, account, receipt, 200, "applied", result)
return nil
} }
+23 -1
View File
@@ -1,3 +1,4 @@
// 图片输入冻结与执行前装载:远程引用转为私有不可变资产,实际执行再次校验目标及资产权限。
package platform package platform
import ( import (
@@ -18,6 +19,7 @@ import (
"gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex" "gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex"
) )
// canvasPublicIP 排除本地/私有/链路/保留测试网和已列元数据地址,IPv4 映射先 Unmap 再检查。
func canvasPublicIP(ip netip.Addr) bool { func canvasPublicIP(ip netip.Addr) bool {
ip = ip.Unmap() ip = ip.Unmap()
if !ip.IsValid() || !ip.IsGlobalUnicast() || ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast() { if !ip.IsValid() || !ip.IsGlobalUnicast() || ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast() {
@@ -30,10 +32,15 @@ func canvasPublicIP(ip netip.Addr) bool {
} }
return true return true
} }
// canvasImageURL 仅允许短 HTTPS URL 且无用户信息,具体 DNS/IP 约束由 fetchCanvasImage 执行。
func canvasImageURL(raw string) bool { func canvasImageURL(raw string) bool {
u, err := url.Parse(raw) u, err := url.Parse(raw)
return err == nil && u.Scheme == "https" && u.Hostname() != "" && u.User == nil && len(raw) < 2048 return err == nil && u.Scheme == "https" && u.Hostname() != "" && u.User == nil && len(raw) < 2048
} }
// fetchCanvasImage 每次连接解析并校验完整 DNS 结果,再直连已验证字面 IP,避免二次解析重绑定。
// 重定向仍需 HTTPS 且每次重新验证目标,响应字节和请求时间都有上限。
func fetchCanvasImage(ctx context.Context, src string) ([]byte, error) { func fetchCanvasImage(ctx context.Context, src string) ([]byte, error) {
if !canvasImageURL(src) { if !canvasImageURL(src) {
return nil, errors.New("invalid_image_input") return nil, errors.New("invalid_image_input")
@@ -92,6 +99,8 @@ func fetchCanvasImage(ctx context.Context, src string) ([]byte, error) {
} }
return data, nil return data, nil
} }
// freezeCanvasImage 已托管图片只重查可读性并保存 assetId;data/远程图完整检查后写不可变资产及来源画布绑定。
func (s *service) freezeCanvasImage(ctx context.Context, tx *sql.Tx, project, workspace, board, account string, content map[string]any) (map[string]any, error) { func (s *service) freezeCanvasImage(ctx context.Context, tx *sql.Tx, project, workspace, board, account string, content map[string]any) (map[string]any, error) {
id, _ := content["assetId"].(string) id, _ := content["assetId"].(string)
src, _ := content["src"].(string) src, _ := content["src"].(string)
@@ -141,6 +150,9 @@ func (s *service) freezeCanvasImage(ctx context.Context, tx *sql.Tx, project, wo
} }
return map[string]any{"assetId": id}, nil return map[string]any{"assetId": id}, nil
} }
// hydrateCanvasTask 汇集自身冻结图、静态前驱和本轮前驱输出资产,去重后加载原图到私有 IPC task。
// 执行前重新解析 canonical owner/代数并核对编辑及资产权限,最多四图和二十 MiB。
func (s *service) hydrateCanvasTask(ctx context.Context, run canvasQueueRun, step canvasAIStepPlan, results map[string]canvasStepResult, task *codex.CanvasTask) error { func (s *service) hydrateCanvasTask(ctx context.Context, run canvasQueueRun, step canvasAIStepPlan, results map[string]canvasStepResult, task *codex.CanvasTask) error {
ids := []string{} ids := []string{}
if id, _ := step.FrozenContent["assetId"].(string); id != "" { if id, _ := step.FrozenContent["assetId"].(string); id != "" {
@@ -166,7 +178,17 @@ func (s *service) hydrateCanvasTask(ctx context.Context, run canvasQueueRun, ste
return err return err
} }
defer tx.Rollback() defer tx.Rollback()
_, role, err := lockMaterial(ctx, tx, run.Project, run.Workspace, step.BoardID, run.Account) if err = lockCanvasAIWorkspace(ctx, tx, run.Project, run.Workspace); err != nil {
return err
}
board, ok, err := resolveCanvasAITarget(ctx, tx, run.Project, run.Workspace, step)
if err != nil {
return err
}
if !ok {
return errors.New("target_removed")
}
_, role, err := lockMaterial(ctx, tx, run.Project, run.Workspace, board, run.Account)
if err != nil { if err != nil {
return err return err
} }
@@ -1,3 +1,4 @@
// 图片抓取网络约束回归:直接检查地址分类和 URL 格式,并实际拒绝回环目标,不访问公网图片。
package platform package platform
import ( import (
@@ -7,6 +8,7 @@ import (
"time" "time"
) )
// TestCanvasImageFetchRejectsPrivateAndMetadataNetworks 覆盖私有/映射 IPv4/元数据/保留网段,确认公网样本分类可接受及非 HTTPS/带凭据 URL 被拒。
func TestCanvasImageFetchRejectsPrivateAndMetadataNetworks(t *testing.T) { func TestCanvasImageFetchRejectsPrivateAndMetadataNetworks(t *testing.T) {
for _, raw := range []string{"127.0.0.1", "10.0.0.1", "169.254.169.254", "172.16.0.1", "192.168.1.1", "100.100.100.200", "168.63.129.16", "0.0.0.1", "198.18.0.1", "224.0.0.1", "255.255.255.255", "::1", "::ffff:127.0.0.1", "fe80::1", "fc00::1", "2001:db8::1"} { for _, raw := range []string{"127.0.0.1", "10.0.0.1", "169.254.169.254", "172.16.0.1", "192.168.1.1", "100.100.100.200", "168.63.129.16", "0.0.0.1", "198.18.0.1", "224.0.0.1", "255.255.255.255", "::1", "::ffff:127.0.0.1", "fe80::1", "fc00::1", "2001:db8::1"} {
if canvasPublicIP(netip.MustParseAddr(raw)) { if canvasPublicIP(netip.MustParseAddr(raw)) {
+6
View File
@@ -1,3 +1,4 @@
// AI 图片输出持久化与模型输入/输出模态能力检查。
package platform package platform
import ( import (
@@ -10,6 +11,8 @@ import (
"gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex" "gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex"
) )
// persistCanvasImage 完整解码 worker 图片并核对 MIME,以 outputID 作为幂等键存原图。
// 先绑定 run 来源素材,使冲突输出在用户显式应用前仍能按原 run 权限读取。
func (s *service) persistCanvasImage(ctx context.Context, tx *sql.Tx, run canvasQueueRun, outputID string, image *codex.CanvasImage) (response, error) { func (s *service) persistCanvasImage(ctx context.Context, tx *sql.Tx, run canvasQueueRun, outputID string, image *codex.CanvasImage) (response, error) {
if image == nil || len(image.Data) == 0 || len(image.Data) > assetLimit { if image == nil || len(image.Data) == 0 || len(image.Data) > assetLimit {
return nil, errors.New("invalid_image_output") return nil, errors.New("invalid_image_output")
@@ -32,6 +35,8 @@ func (s *service) persistCanvasImage(ctx context.Context, tx *sql.Tx, run canvas
} }
return response{"output_id": outputID, "kind": "image", "assetId": id, "src": s.assetURL(run.Project, run.Workspace, id), "mime_type": mime, "bytes": len(image.Data), "width": width, "height": height}, nil return response{"output_id": outputID, "kind": "image", "assetId": id, "src": s.assetURL(run.Project, run.Workspace, id), "mime_type": mime, "bytes": len(image.Data), "width": width, "height": height}, nil
} }
// canvasModelSupports 检查输出模态;支持图片输入并不意味着可生成图片。
func canvasModelSupports(model codex.CanvasModel, modality string) bool { func canvasModelSupports(model codex.CanvasModel, modality string) bool {
for _, value := range model.OutputModalities { for _, value := range model.OutputModalities {
if value == modality { if value == modality {
@@ -41,6 +46,7 @@ func canvasModelSupports(model codex.CanvasModel, modality string) bool {
return false return false
} }
// canvasModelAccepts 检查输入模态,准入阶段据此拒绝给纯文本输入模型喂图。
func canvasModelAccepts(model codex.CanvasModel, modality string) bool { func canvasModelAccepts(model codex.CanvasModel, modality string) bool {
for _, value := range model.InputModalities { for _, value := range model.InputModalities {
if value == modality { if value == modality {
@@ -1,3 +1,4 @@
// 旧快照 AI 生命周期数据库回归:需隔离 PLATFORM_TEST_DATABASE_URL,生成由 Unix 假 worker 固定,不调用真实模型。
package platform package platform
import ( import (
@@ -23,6 +24,7 @@ import (
"gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex" "gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex"
) )
// TestCanvasAIJobLifecycle 通过真实准入/认领/写回验证几何并发、内容冲突、取消、租约恢复、图片和传播失败分支。
func TestCanvasAIJobLifecycle(t *testing.T) { func TestCanvasAIJobLifecycle(t *testing.T) {
dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL") dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL")
if dsn == "" { if dsn == "" {
@@ -78,6 +80,7 @@ func TestCanvasAIJobLifecycle(t *testing.T) {
if err := png.Encode(&pngOutput, image.NewRGBA(image.Rect(0, 0, 3, 2))); err != nil { if err := png.Encode(&pngOutput, image.NewRGBA(image.Rect(0, 0, 3, 2))); err != nil {
t.Fatal(err) t.Fatal(err)
} }
// hooks 在 worker 已接收任务但尚未返回时注入并发变更;busyNext/failNext 分别模拟未执行忙碌和生成失败。
var imageInputs atomic.Int32 var imageInputs atomic.Int32
var busyNext atomic.Bool var busyNext atomic.Bool
var failNext atomic.Bool var failNext atomic.Bool
@@ -175,6 +178,7 @@ func TestCanvasAIJobLifecycle(t *testing.T) {
t.Errorf("concurrent fixture edit: %v", err) t.Errorf("concurrent fixture edit: %v", err)
} }
} }
// 同键准入只建一个任务,生成中拖动 x 应被保留,结果只更新文本并在最新版本上加一。
first := start(1, 1) first := start(1, 1)
retry := start(1, 1) retry := start(1, 1)
if first["run_id"] != retry["run_id"] || first["canvas_version"] != float64(2) { if first["run_id"] != retry["run_id"] || first["canvas_version"] != float64(2) {
@@ -193,6 +197,7 @@ func TestCanvasAIJobLifecycle(t *testing.T) {
t.Fatal("result overwrote geometry/style or failed to update text") t.Fatal("result overwrote geometry/style or failed to update text")
} }
firstPath := base + "/ai/runs/" + first["run_id"].(string) firstPath := base + "/ai/runs/" + first["run_id"].(string)
// 以小事件页回放整个运行,检查 seq 严格单调且最终 run.completed 可恢复。
after := int64(0) after := int64(0)
completed := false completed := false
for page := 0; page < 30; page++ { for page := 0; page < 30; page++ {
@@ -218,6 +223,7 @@ func TestCanvasAIJobLifecycle(t *testing.T) {
if !completed { if !completed {
t.Fatal("terminal event not replayable") t.Fatal("terminal event not replayable")
} }
// 正文并发编辑产生 conflict,输出仍可查询;旧协议显式应用失败后允许按当前版本再试。
second := start(4, 3) second := start(4, 3)
hooks <- func() { mutate("{nodes,0,data,text}", `"user edit"`) } hooks <- func() { mutate("{nodes,0,data,text}", `"user edit"`) }
execute(second["run_id"].(string)) execute(second["run_id"].(string))
@@ -244,6 +250,7 @@ func TestCanvasAIJobLifecycle(t *testing.T) {
if calls.Load() != 2 { if calls.Load() != 2 {
t.Fatal("cancelled queued run invoked worker") t.Fatal("cancelled queued run invoked worker")
} }
// 人工让运行租约过期,恢复流程必须标 execution_interrupted,不能再次调用未知是否执行的模型。
fourth := start(8, 7) fourth := start(8, 7)
run, err := s.claimCanvasRun(ctx) run, err := s.claimCanvasRun(ctx)
if err != nil || run == nil || run.ID != fourth["run_id"] { if err != nil || run == nil || run.ID != fourth["run_id"] {
@@ -262,6 +269,7 @@ func TestCanvasAIJobLifecycle(t *testing.T) {
if recovered["status"] != "failed" || recovered["error"] != "execution_interrupted" || calls.Load() != 2 { if recovered["status"] != "failed" || recovered["error"] != "execution_interrupted" || calls.Load() != 2 {
t.Fatal("uncertain execution was retried or misreported") t.Fatal("uncertain execution was retried or misreported")
} }
// 删除再创建同名节点不能使旧 running 步复活,迟到输出必须保持 cancelled。
fifth := start(9, 8) fifth := start(9, 8)
removedRun, err := s.claimCanvasRun(ctx) removedRun, err := s.claimCanvasRun(ctx)
if err != nil || removedRun == nil || removedRun.ID != fifth["run_id"] { if err != nil || removedRun == nil || removedRun.ID != fifth["run_id"] {
@@ -299,6 +307,7 @@ func TestCanvasAIJobLifecycle(t *testing.T) {
if len(active["runs"].([]any)) != 0 { if len(active["runs"].([]any)) != 0 {
t.Fatal("terminal jobs returned as active") t.Fatal("terminal jobs returned as active")
} }
// 图片输入先冻结为资产再装载,结果也存托管资产;节点原显示尺寸和可授权下载的原图都需保留。
imageDoc := call("GET", base, nil, 200, 0, "")["document"].(map[string]any) imageDoc := call("GET", base, nil, 200, 0, "")["document"].(map[string]any)
imageDoc["nodes"] = append(imageDoc["nodes"].([]any), response{"id": "image-node", "type": "plainImage", "position": response{"x": 40, "y": 50}, "width": 240, "height": 160, "data": response{"kind": "plain-image", "title": "Image", "text": "", "src": "data:image/png;base64," + base64.StdEncoding.EncodeToString(pngOutput.Bytes())}}) imageDoc["nodes"] = append(imageDoc["nodes"].([]any), response{"id": "image-node", "type": "plainImage", "position": response{"x": 40, "y": 50}, "width": 240, "height": 160, "data": response{"kind": "plain-image", "title": "Image", "text": "", "src": "data:image/png;base64," + base64.StdEncoding.EncodeToString(pngOutput.Bytes())}})
call("PATCH", base, response{"document": imageDoc}, 200, 12, "") call("PATCH", base, response{"document": imageDoc}, 200, 12, "")
@@ -336,6 +345,7 @@ func TestCanvasAIJobLifecycle(t *testing.T) {
t.Fatal("image inputs were not frozen/hydrated through authorized assets") t.Fatal("image inputs were not frozen/hydrated through authorized assets")
} }
// 首前驱成功后让下游收到 codex_busy,只回队下游;恢复不重复上游付费调用或版本推进。
chainDoc := call("GET", base, nil, 200, 0, "")["document"].(map[string]any) chainDoc := call("GET", base, nil, 200, 0, "")["document"].(map[string]any)
chainDoc["nodes"].([]any)[1].(map[string]any)["data"].(map[string]any)["ai"] = response{"enabled": true, "modelId": "fixture-model", "prompt": "Use upstream result", "parameters": response{}} chainDoc["nodes"].([]any)[1].(map[string]any)["data"].(map[string]any)["ai"] = response{"enabled": true, "modelId": "fixture-model", "prompt": "Use upstream result", "parameters": response{}}
call("PATCH", base, response{"document": chainDoc}, 200, 18, "") call("PATCH", base, response{"document": chainDoc}, 200, 18, "")
@@ -366,6 +376,7 @@ func TestCanvasAIJobLifecycle(t *testing.T) {
} }
// Cancellation after worker admission must reject an otherwise successful late output. // Cancellation after worker admission must reject an otherwise successful late output.
// 生成中通过真实取消接口结束 run,随后即使假 worker 返回成功也不能再写回。
cancelRunning := start(22, 13) cancelRunning := start(22, 13)
cancelRunningPath := base + "/ai/runs/" + cancelRunning["run_id"].(string) cancelRunningPath := base + "/ai/runs/" + cancelRunning["run_id"].(string)
hooks <- func() { hooks <- func() {
@@ -377,6 +388,7 @@ func TestCanvasAIJobLifecycle(t *testing.T) {
} }
// Permission is checked again inside the final write transaction. // Permission is checked again inside the final write transaction.
// 生成返回前删除成员权限,最终事务重查应拒绝输出应用;恢复权限仅为读取测试结果。
revoked := start(23, 15) revoked := start(23, 15)
hooks <- func() { hooks <- func() {
if _, err := db.ExecContext(ctx, `DELETE FROM workspace_members WHERE project=$1 AND workspace_id=$2 AND account_id=$3`, project, workspace, account); err != nil { if _, err := db.ExecContext(ctx, `DELETE FROM workspace_members WHERE project=$1 AND workspace_id=$2 AND account_id=$3`, project, workspace, account); err != nil {
@@ -393,6 +405,7 @@ func TestCanvasAIJobLifecycle(t *testing.T) {
} }
// A failed branch stops its dependents while its independent sibling finishes. // A failed branch stops its dependents while its independent sibling finishes.
// 一支失败只跳过依赖者,独立兄弟仍可成功,run 汇总为 partially_succeeded。
branchSnapshot := aiPlanFixture([][2]string{{"a", "b"}, {"a", "c"}, {"b", "d"}}, nil, "")["board"] branchSnapshot := aiPlanFixture([][2]string{{"a", "b"}, {"a", "c"}, {"b", "d"}}, nil, "")["board"]
var branchDoc any var branchDoc any
if err := json.Unmarshal(branchSnapshot.Document, &branchDoc); err != nil { if err := json.Unmarshal(branchSnapshot.Document, &branchDoc); err != nil {
@@ -412,6 +425,7 @@ func TestCanvasAIJobLifecycle(t *testing.T) {
t.Fatalf("partial failure lost independent branch: %+v %v", states, branchResult["status"]) t.Fatalf("partial failure lost independent branch: %+v %v", states, branchResult["status"])
} }
// 含回边的图可以存储,但执行准入必须识别环,既不调用 worker 也不推进配置版本。
cyclic := call("GET", base, nil, 200, 0, "") cyclic := call("GET", base, nil, 200, 0, "")
cyclicVersion := int64(cyclic["version"].(float64)) cyclicVersion := int64(cyclic["version"].(float64))
cyclicDoc := cyclic["document"].(map[string]any) cyclicDoc := cyclic["document"].(map[string]any)
@@ -1,3 +1,4 @@
// 旧快照语义的 AI 生命周期失效,与节点删除/种类变化或子图关系更新处于同一事务。
package platform package platform
import ( import (
@@ -9,6 +10,8 @@ import (
// Deletion or kind/ownership changes revoke active steps in the same snapshot // Deletion or kind/ownership changes revoke active steps in the same snapshot
// transaction. Recreating an identical node ID later cannot revive that step. // transaction. Recreating an identical node ID later cannot revive that step.
// invalidateCanvasAITargets 找出从本 board 消失或种类变化的节点,取消对应 queued/running 步骤并写事件。
// 仅视觉/正文编辑不在此取消,执行/写回时再由内容指纹检测冲突。
func invalidateCanvasAITargets(r *http.Request, tx *sql.Tx, project, workspace, board string, before, after json.RawMessage) error { func invalidateCanvasAITargets(r *http.Request, tx *sql.Tx, project, workspace, board string, before, after json.RawMessage) error {
old, next := canvasNodeData(before), canvasNodeData(after) old, next := canvasNodeData(before), canvasNodeData(after)
removed := []string{} removed := []string{}
@@ -71,6 +74,7 @@ func invalidateCanvasAITargets(r *http.Request, tx *sql.Tx, project, workspace,
return nil return nil
} }
// invalidateCanvasAISubtree 收集活跃后代并逐张模拟清空节点,使关系变更涉及的旧树任务失效;不删除实际文档。
func invalidateCanvasAISubtree(r *http.Request, tx *sql.Tx, project, workspace, child string) error { func invalidateCanvasAISubtree(r *http.Request, tx *sql.Tx, project, workspace, child string) error {
rows, err := tx.QueryContext(r.Context(), `WITH RECURSIVE descendants(id,depth) AS(SELECT $3::uuid,0 UNION ALL SELECT s.child_board_id,d.depth+1 FROM descendants d JOIN canvas_subgraphs s ON s.project=$1 AND s.workspace_id=$2 AND s.parent_board_id=d.id AND s.archived_at IS NULL WHERE d.depth<8) SELECT m.id::text,COALESCE(m.canvas_document,'{"nodes":[]}'::jsonb) FROM descendants d JOIN materials m ON m.project=$1 AND m.workspace_id=$2 AND m.id=d.id ORDER BY m.id`, project, workspace, child) rows, err := tx.QueryContext(r.Context(), `WITH RECURSIVE descendants(id,depth) AS(SELECT $3::uuid,0 UNION ALL SELECT s.child_board_id,d.depth+1 FROM descendants d JOIN canvas_subgraphs s ON s.project=$1 AND s.workspace_id=$2 AND s.parent_board_id=d.id AND s.archived_at IS NULL WHERE d.depth<8) SELECT m.id::text,COALESCE(m.canvas_document,'{"nodes":[]}'::jsonb) FROM descendants d JOIN materials m ON m.project=$1 AND m.workspace_id=$2 AND m.id=d.id ORDER BY m.id`, project, workspace, child)
if err != nil { if err != nil {
+4
View File
@@ -1,3 +1,4 @@
// AI run 列表使用创建时间/UUID 的复合游标,支持状态和活跃子图范围筛选。
package platform package platform
import ( import (
@@ -9,11 +10,13 @@ import (
"time" "time"
) )
// canvasRunCursor 用时间加 ID 处理同一时间创建的 run,不依赖不稳定的 OFFSET。
type canvasRunCursor struct { type canvasRunCursor struct {
Time time.Time `json:"created_at"` Time time.Time `json:"created_at"`
ID string `json:"id"` ID string `json:"id"`
} }
// listCanvasAIRuns 先查范围候选,再核对各 run 来源画布的可见性;返回列表不含冻结提示或原始输出文本。
func (s *service) listCanvasAIRuns(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) listCanvasAIRuns(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet { if r.Method != http.MethodGet {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -88,6 +91,7 @@ func (s *service) listCanvasAIRuns(w http.ResponseWriter, r *http.Request, proje
if err != nil { if err != nil {
return err return err
} }
// SQL 多取一条判断后页;权限过滤可能使公开本页少于 limit,游标仍按扫描到的候选末尾前进。
hasMore := len(candidates) > limit hasMore := len(candidates) > limit
if hasMore { if hasMore {
candidates = candidates[:limit] candidates = candidates[:limit]
+292
View File
@@ -0,0 +1,292 @@
// AI 与 canonical 模型适配:稳定身份跟随 owner,窄字段 patch 保留未知组件 envelope 和无关几何。
package platform
import (
"context"
"database/sql"
"encoding/json"
"errors"
"net/http"
)
var errAITargetChanged = errors.New("target_changed")
var errAIInvalidPatch = errors.New("invalid_ai_patch")
// The snapshot is an AI reader projection only. Canonical changes retain the
// original rows, including unknown envelopes, geometry and reference metadata.
// canvasAIChange 携带待保存快照及可选 canonical 前后模型,避免将兼容投影反写为权威模型。
type canvasAIChange struct {
Snapshot canvasSnapshot
Before *canvasModel
After *canvasModel
Incarnation int64
}
// Until a narrower read-set protocol exists, admission binds every active
// canvas in this canonical project. Archived versions are not graph inputs.
// Workspace locking keeps validation, plan freezing and admission atomic.
// validateCanvasAIVersions 暂要求 Expected 精确覆盖全部活跃 canonical 画布且当前 board 与 If-Match 一致。
// 归档版本不作为规划输入;完整 read-set 检查与冻结在同一工作区锁内。
func validateCanvasAIVersions(model canvasModel, board string, header int64, expected map[string]int64) string {
if len(expected) != len(model.Canvases) || expected[board] != header {
return "invalid_ai_versions"
}
for id := range model.Canvases {
version, ok := expected[id]
if !ok || version < 1 || version > 9007199254740991 {
return "invalid_ai_versions"
}
if version != model.Versions[id] {
return "version_conflict"
}
}
return ""
}
// prepareModelAIPatch 仅在同 owner 的可执行 v1 节点副本修改 ai/text/src/assetId,推进该画布版本并验证全模型。
func prepareModelAIPatch(before canvasModel, board, node string, patch response) (canvasModel, error) {
element := before.Elements[node]
if element == nil || element["structure"] != "node" || element["ownerCanvasId"] != board || modelInt(element["dataVersion"]) != 1 || !canvasChoice(element["componentId"], "text", "script", "plain-text", "image", "plain-image") {
return canvasModel{}, errAITargetChanged
}
after := cloneModel(before)
data := after.Elements[node]["data"].(map[string]any)
for key, value := range patch {
if !canvasChoice(key, "ai", "text", "src", "assetId") {
return canvasModel{}, errAIInvalidPatch
}
data[key] = value
}
if before.Versions[board] < 1 || before.Versions[board] >= 9007199254740991 {
return canvasModel{}, errModelConflict
}
after.Versions[board]++
if err := validateCanvasModel(after); err != nil {
return canvasModel{}, err
}
return after, nil
}
// prepareCanvasAIPatch 按是否迁入 canonical 分派:前者改权威模型再生成投影,后者改快照副本再 normalize。
func prepareCanvasAIPatch(r *http.Request, tx *sql.Tx, project, workspace string, snapshot canvasSnapshot, node string, patch response) (canvasAIChange, error) {
change := canvasAIChange{Snapshot: snapshot}
root, err := canonicalRoot(r.Context(), tx, project, workspace, snapshot.BoardID)
if err != nil {
return change, err
}
if root != "" {
before, err := loadCanvasModel(r.Context(), tx, project, workspace, root)
if err != nil {
return change, err
}
if before.Versions[snapshot.BoardID] != snapshot.Version {
return change, errModelConflict
}
after, err := prepareModelAIPatch(before, snapshot.BoardID, node, patch)
if err != nil {
return change, err
}
projection, err := projectCanvasModel(after)
if err != nil {
return change, err
}
change.Before, change.After = &before, &after
change.Incarnation = modelInt(before.Elements[node]["incarnation"])
change.Snapshot.Document, change.Snapshot.Version = projection[snapshot.BoardID], after.Versions[snapshot.BoardID]
return change, nil
}
var document map[string]any
if err = json.Unmarshal(snapshot.Document, &document); err != nil {
return change, err
}
target := canvasNodeData(snapshot.Document)[node]
if target == nil {
return change, errAITargetChanged
}
// The data lookup owns a separate decode. Update the staged document itself.
for _, raw := range document["nodes"].([]any) {
element := raw.(map[string]any)
if element["id"] != node {
continue
}
data := element["data"].(map[string]any)
for key, value := range patch {
if !canvasChoice(key, "ai", "text", "src", "assetId") {
return change, errAIInvalidPatch
}
data[key] = value
}
}
document["schema_version"] = float64(2)
encoded, err := json.Marshal(document)
if err != nil {
return change, err
}
normalized, ok := normalizeCanvas(encoded)
if !ok {
return change, errAIInvalidPatch
}
change.Snapshot.Document = normalized
change.Snapshot.Version++
return change, nil
}
// saveCanvasAIChange 根据 change 的模型形态选择持久化路径,复用调用方事务,不自行提交。
func (s *service) saveCanvasAIChange(r *http.Request, tx *sql.Tx, project, workspace, account string, change canvasAIChange) error {
if change.After == nil {
return s.saveCanvas(r, tx, project, workspace, change.Snapshot)
}
return s.saveCanvasModel(r, tx, project, workspace, account, *change.Before, *change.After, map[string]bool{change.Snapshot.BoardID: true})
}
// addCanonical 仅在 canonical 响应附格式、代数与当前 owner 局部模型,旧快照协议不增加这些字段。
func (change canvasAIChange) addCanonical(result response) {
if change.After == nil {
return
}
board := change.Snapshot.BoardID
result["document_format_version"], result["target_incarnation"] = canvasModelFormat, change.Incarnation
result["model"] = change.After.view(map[string]int64{board: change.Snapshot.Version})
}
// canvasAIIdentity 查当前 owner 下活跃且可执行的节点身份;旧图返回空根,非法目标返回零代数。
func canvasAIIdentity(ctx context.Context, tx *sql.Tx, project, workspace, board, node string) (string, int64, string, error) {
root, err := canonicalRoot(ctx, tx, project, workspace, board)
if err != nil || root == "" {
return root, 0, "", err
}
var incarnation, version int64
var kind string
err = tx.QueryRowContext(ctx, `SELECT incarnation,record->>'componentId',(record->>'dataVersion')::bigint FROM canvas_model_elements WHERE project=$1 AND workspace_id=$2 AND root_id=$3 AND element_id=$4 AND owner_canvas_id=$5 AND NOT deleted AND record->>'structure'='node'`, project, workspace, root, node, board).Scan(&incarnation, &kind, &version)
if err == sql.ErrNoRows {
return root, 0, "", nil
}
if err != nil {
return root, 0, "", err
}
if version != 1 || !canvasChoice(kind, "text", "script", "plain-text", "image", "plain-image") {
return root, 0, "", nil
}
return root, incarnation, kind, nil
}
// bindCanvasAIIdentities 在准入时给每步冻结根/代数,旧图仍保留 board-local 身份。
func bindCanvasAIIdentities(ctx context.Context, tx *sql.Tx, project, workspace string, plan *canvasAIPlan) error {
for i, step := range plan.Steps {
root, incarnation, kind, err := canvasAIIdentity(ctx, tx, project, workspace, step.BoardID, step.NodeID)
if err != nil {
return err
}
if root != "" && (incarnation < 1 || kind != step.Kind) {
return errAITargetChanged
}
plan.Steps[i].CanonicalRoot, plan.Steps[i].TargetIncarnation = root, incarnation
}
return nil
}
// Run URLs remain anchored at their admission board, even after that partition
// is archived. Canonical ownership grants are inherited from the same root.
// lockCanvasAIRunRoute 将 canonical 原 run 路径转到根级授权,原分区归档后仍可查询/取消该 run。
func lockCanvasAIRunRoute(ctx context.Context, tx *sql.Tx, project, workspace, board, account string) (string, string, error) {
root, err := canonicalRoot(ctx, tx, project, workspace, board)
if err != nil {
return "", "", err
}
if root != "" {
board = root
}
return lockMaterial(ctx, tx, project, workspace, board, account)
}
// lockCanvasAIWorkspace 只取得工作区行锁;具体目标权限必须在后续独立检查。
func lockCanvasAIWorkspace(ctx context.Context, tx *sql.Tx, project, workspace string) error {
var id string
return tx.QueryRowContext(ctx, `SELECT id::text FROM workspaces WHERE project=$1 AND id=$2 FOR UPDATE`, project, workspace).Scan(&id)
}
// Caller holds the workspace lock. Frozen identity is stable; owner is resolved
// afresh at execution, hydration and write time, never written into the plan.
// resolveCanvasAITarget 在调用方持锁时重新解析当前 owner,要求同根、同代、同种类且 owner 未归档。
// 原计划 BoardID 不被更新,避免破坏步骤身份、指纹和重放结果。
func resolveCanvasAITarget(ctx context.Context, tx *sql.Tx, project, workspace string, step canvasAIStepPlan) (string, bool, error) {
if step.CanonicalRoot == "" {
root, err := canonicalRoot(ctx, tx, project, workspace, step.BoardID)
return step.BoardID, err == nil && root == "" && step.TargetIncarnation == 0, err
}
var board, kind string
var incarnation, version int64
err := tx.QueryRowContext(ctx, `SELECT e.owner_canvas_id::text,e.incarnation,e.record->>'componentId',(e.record->>'dataVersion')::bigint FROM canvas_model_elements e JOIN canvas_model_canvases c ON c.project=e.project AND c.workspace_id=e.workspace_id AND c.canvas_id=e.owner_canvas_id AND c.root_id=e.root_id WHERE e.project=$1 AND e.workspace_id=$2 AND e.root_id=$3 AND e.element_id=$4 AND NOT e.deleted AND NOT c.archived AND e.record->>'structure'='node'`, project, workspace, step.CanonicalRoot, step.NodeID).Scan(&board, &incarnation, &kind, &version)
if err == sql.ErrNoRows {
return "", false, nil
}
if err != nil {
return "", false, err
}
return board, incarnation == step.TargetIncarnation && incarnation > 0 && kind == step.Kind && version == 1, nil
}
// canvasAIIdentityMatches 是只关心有效性的包装,仍沿用完整 owner/生命周期检查。
func canvasAIIdentityMatches(ctx context.Context, tx *sql.Tx, project, workspace string, step canvasAIStepPlan) (bool, error) {
_, ok, err := resolveCanvasAITarget(ctx, tx, project, workspace, step)
return ok, err
}
// addTargetContext 同时返回原来源与当前应用上下文;owner 改变时附完整模型供客户端恢复新位置。
func (change canvasAIChange) addTargetContext(result response, step canvasAIStepPlan) {
change.addCanonical(result)
if step.CanonicalRoot != "" {
result["origin_board_id"], result["canonical_root"] = step.BoardID, step.CanonicalRoot
if change.After != nil && change.Snapshot.BoardID != step.BoardID {
result["model"] = change.After.view(nil)
}
}
}
// Whole identity transitions cancel old jobs even when delete/restore happens
// in a single atomic batch and the compatibility projection looks identical.
// invalidateCanonicalAIIdentities 比较整代身份而非快照外观;删除/恢复同批或组件版本变化也取消旧任务。
// 纯 owner 移动不失效,后续执行/写回按稳定身份跟随新位置。
func invalidateCanonicalAIIdentities(r *http.Request, tx *sql.Tx, project, workspace string, before, after canvasModel) error {
removed := map[string][]any{}
for id, element := range before.Elements {
if element["structure"] != "node" {
continue
}
next := after.Elements[id]
if next != nil && modelInt(next["incarnation"]) == modelInt(element["incarnation"]) && next["componentId"] == element["componentId"] && modelInt(next["dataVersion"]) == modelInt(element["dataVersion"]) {
continue
}
rows, err := tx.QueryContext(r.Context(), `SELECT DISTINCT board_id::text FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND frozen_input->>'canonical_root'=$3 AND node_id=$4 AND frozen_input->>'target_incarnation'=$5::bigint::text AND status IN('queued','running')`, project, workspace, before.Root, id, modelInt(element["incarnation"]))
if err != nil {
return err
}
boards := []string{}
for rows.Next() {
var board string
if err = rows.Scan(&board); err != nil {
rows.Close()
return err
}
boards = append(boards, board)
}
err = rows.Err()
rows.Close()
if err != nil {
return err
}
for _, board := range boards {
removed[board] = append(removed[board], map[string]any{"id": id, "data": map[string]any{"kind": element["componentId"]}})
}
}
for _, board := range sortedKeys(removed) {
raw, err := json.Marshal(map[string]any{"nodes": removed[board]})
if err != nil {
return err
}
if err = invalidateCanvasAITargets(r, tx, project, workspace, board, raw, json.RawMessage(`{"nodes":[]}`)); err != nil {
return err
}
}
return nil
}
@@ -0,0 +1,552 @@
// Canonical AI 数据库集成回归:Unix 假 worker 只固定生成传输,权威模型、生命周期与回执均走真实事务。
package platform
import (
"bytes"
"context"
"crypto/rand"
"crypto/sha256"
"database/sql"
"encoding/base64"
"encoding/hex"
"encoding/json"
"image"
"image/png"
"net"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strconv"
"strings"
"sync/atomic"
"testing"
"gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex"
)
// TestCanonicalAIAdmissionAndLifecycle 需隔离 PLATFORM_TEST_DATABASE_URL,覆盖 owner 迁移、代数失效及 v2 确定拒绝恢复。
func TestCanonicalAIAdmissionAndLifecycle(t *testing.T) {
dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL")
if dsn == "" {
t.Skip("requires an isolated integration database")
}
db, err := sql.Open("pgx", dsn)
if err != nil {
t.Fatal(err)
}
defer db.Close()
ctx := context.Background()
var entropy [32]byte
_, _ = rand.Read(entropy[:])
project := "canonical-ai-" + hex.EncodeToString(entropy[:8])
token := base64.RawURLEncoding.EncodeToString(entropy[:])
digest := sha256.Sum256([]byte(token))
var account, workspace, root string
if err = db.QueryRowContext(ctx, `INSERT INTO project_accounts(project,id) VALUES($1,gen_random_uuid()) RETURNING id::text`, project).Scan(&account); err != nil {
t.Fatal(err)
}
defer func() {
for _, table := range []string{"canvas_ai_runs", "canvas_model_operations", "canvas_model_identity_map", "canvas_model_requests", "canvas_model_projects", "canvas_asset_bindings", "canvas_assets", "canvas_subgraphs", "workspaces", "project_accounts"} {
_, _ = db.ExecContext(ctx, "DELETE FROM "+table+" WHERE project=$1", project)
}
}()
if _, err = db.ExecContext(ctx, `INSERT INTO project_sessions(token_hash,project,account_id,expires_at) VALUES($1,$2,$3,now()+interval '1 hour')`, base64.RawURLEncoding.EncodeToString(digest[:]), project, account); err != nil {
t.Fatal(err)
}
if err = db.QueryRowContext(ctx, `INSERT INTO workspaces(project,name,owner_id) VALUES($1,'Canonical AI',$2) RETURNING id::text`, project, account).Scan(&workspace); err != nil {
t.Fatal(err)
}
if _, err = db.ExecContext(ctx, `INSERT INTO workspace_members(project,workspace_id,account_id,role) VALUES($1,$2,$3,'admin')`, project, workspace, account); err != nil {
t.Fatal(err)
}
if err = db.QueryRowContext(ctx, `INSERT INTO materials(project,workspace_id,kind,title,created_by,canvas_document) VALUES($1,$2,'board','Canonical AI',$3,$4) RETURNING id::text`, project, workspace, account, json.RawMessage(canvasFixture)).Scan(&root); err != nil {
t.Fatal(err)
}
temp, err := os.MkdirTemp("", "fc-canonical-ai-")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(temp)
socket := filepath.Join(temp, "worker.sock")
listener, err := net.Listen("unix", socket)
if err != nil {
t.Fatal(err)
}
var pngBytes bytes.Buffer
if err = png.Encode(&pngBytes, image.NewRGBA(image.Rect(0, 0, 3, 2))); err != nil {
t.Fatal(err)
}
// worker 入口执行一次 hook,可精确在模型返回前注入内容、身份或所有权变化。
hooks := make(chan func(), 1)
var executions atomic.Int32
worker := &http.Server{Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/canvas/models" {
reply(w, 200, response{"models": []any{codex.CanvasModel{ID: "text", Available: true, InputModalities: []string{"text", "image"}, OutputModalities: []string{"text"}, MaxInputBytes: 1 << 20, MaxExecutionMS: 90000}, codex.CanvasModel{ID: "image", Available: true, InputModalities: []string{"text", "image"}, OutputModalities: []string{"image"}, MaxInputBytes: 1 << 20, MaxExecutionMS: 180000}}})
return
}
if r.URL.Path != "/canvas/exec" {
reject(w, 404, "not_found")
return
}
var task codex.CanvasTask
if json.NewDecoder(r.Body).Decode(&task) != nil {
reject(w, 400, "invalid_request")
return
}
executions.Add(1)
select {
case hook := <-hooks:
hook()
default:
}
if task.OutputModality == "image" {
reply(w, 200, response{"output": codex.CanvasOutput{Kind: "image", Image: &codex.CanvasImage{MIME: "image/png", Data: pngBytes.Bytes()}}})
} else {
reply(w, 200, response{"result": "generated result"})
}
})}
go worker.Serve(listener)
defer worker.Close()
s := &service{db: db, origin: "https://api.example.com", canvasAI: codex.NewCanvasClient(socket)}
callbacks := map[string]string{project: "https://app.example.com/auth/callback"}
mux := http.NewServeMux()
prefix := "/projects/{project}/workspaces/{workspace}/materials/{material}/canvas"
mux.HandleFunc(prefix+"/model", s.protected(callbacks, s.getCanvasModel))
mux.HandleFunc(prefix+"/model/migrate", s.protected(callbacks, s.migrateCanonicalCanvas))
mux.HandleFunc(prefix+"/ai/runs", s.protected(callbacks, s.createCanvasAIRun))
mux.HandleFunc(prefix+"/ai/runs/{run}", s.protected(callbacks, s.getCanvasAIRun))
mux.HandleFunc(prefix+"/ai/runs/{run}/apply", s.protected(callbacks, s.applyCanvasAIOutput))
mux.HandleFunc(prefix+"/ai/runs/{run}/cancel", s.protected(callbacks, s.cancelCanvasAIRun))
mux.HandleFunc(prefix+"/ai/operations/{request}", s.protected(callbacks, s.getCanvasAIAdmission))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/assets/{asset}", s.protected(callbacks, s.getAsset))
base := func(board string) string {
return "/projects/" + project + "/workspaces/" + workspace + "/materials/" + board + "/canvas"
}
call := func(method, path string, input any, status int, version int64, key string) response {
t.Helper()
raw, _ := json.Marshal(input)
r := httptest.NewRequest(method, path, bytes.NewReader(raw))
r.Header.Set("Authorization", "Bearer "+token)
r.Header.Set("Accept", "application/vnd.foundry.canvas+json;version=2")
if version > 0 {
r.Header.Set("If-Match", `"`+strconv.FormatInt(version, 10)+`"`)
}
if key != "" {
r.Header.Set("Idempotency-Key", key)
}
w := httptest.NewRecorder()
mux.ServeHTTP(w, r)
if w.Code != status {
t.Fatalf("%s %s got %d %s want %d", method, path, w.Code, w.Body.String(), status)
}
result := response{}
if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil {
t.Fatal(err)
}
return result
}
read := func() canvasModel {
t.Helper()
tx, e := db.BeginTx(ctx, nil)
if e != nil {
t.Fatal(e)
}
defer tx.Rollback()
model, e := loadCanvasModel(ctx, tx, project, workspace, root)
if e != nil {
t.Fatal(e)
}
return model
}
// mutate 在持锁事务中改权威模型并同步投影,用于模拟其他客户端编辑,不绕过模型完整性校验。
mutate := func(edit func(*canvasModel)) {
t.Helper()
tx, e := db.BeginTx(ctx, nil)
if e != nil {
t.Fatal(e)
}
defer tx.Rollback()
if _, _, e = lockMaterial(ctx, tx, project, workspace, root, account); e != nil {
t.Fatal(e)
}
before, e := loadCanvasModel(ctx, tx, project, workspace, root)
if e != nil {
t.Fatal(e)
}
after := cloneModel(before)
edit(&after)
participants := map[string]bool{}
for id := range after.Canvases {
after.Versions[id] = before.Versions[id] + 1
participants[id] = true
}
for id := range before.Canvases {
if _, active := after.Canvases[id]; !active {
after.Versions[id] = before.Versions[id] + 1
participants[id] = true
}
}
if e = validateCanvasModel(after); e != nil {
t.Fatal(e)
}
if e = s.saveCanvasModel(queueRequest(ctx), tx, project, workspace, account, before, after, participants); e != nil {
t.Fatal(e)
}
if e = tx.Commit(); e != nil {
t.Fatal(e)
}
}
migrationKey := modelTestID(6000)
migration := call("POST", base(root)+"/model/migrate", response{"protocol_version": 2, "request_id": migrationKey, "expected_versions": map[string]int64{root: 1}}, 200, 0, migrationKey)
node := ""
for _, entry := range migration["identity_map"].([]any) {
mapping := entry.(map[string]any)
if mapping["sourceId"] == "a" {
node = mapping["elementId"].(string)
}
}
if node == "" {
t.Fatal("missing migrated target")
}
mutate(func(model *canvasModel) {
model.Elements[node]["geometry"].(map[string]any)["width"] = float64(9000)
model.Elements[node]["opaque"] = map[string]any{"kept": true}
model.Elements[node]["data"].(map[string]any)["extension"] = map[string]any{"constructor": map[string]any{"kept": true}}
model.Elements["future"] = modelTestNode("future", root)
model.Elements["future"]["componentId"] = "future-component"
model.Elements["future"]["dataVersion"] = float64(12)
})
next := 6100
// 每次创建不同 request/operation ID,Expected 取全部活跃画布版本,排除已归档 scope。
command := func(board, target, model string, incarnation int64) (response, string) {
next += 2
key := modelTestID(next)
return response{"protocol_version": 2, "request_id": key, "operation_id": modelTestID(next + 1), "target_incarnation": incarnation, "expected_versions": func() map[string]int64 {
model := read()
versions := map[string]int64{}
for id := range model.Canvases {
versions[id] = model.Versions[id]
}
return versions
}(), "node_id": target, "model_id": model, "prompt": "Generate", "parameters": response{}, "propagate": false}, key
}
start := func(board, target, model string, incarnation int64) response {
// 准入原响应可按相同键重放和查询;改 If-Match 或换键复用已准入逻辑操作必须拒绝。
input, key := command(board, target, model, incarnation)
return call("POST", base(board)+"/ai/runs", input, 202, read().Versions[board], key)
}
execute := func(id string) {
t.Helper()
run, e := s.claimCanvasRun(ctx)
if e != nil || run == nil || run.ID != id {
t.Fatalf("claim %v %v", run, e)
}
s.executeCanvasRun(ctx, *run)
}
input, key := command(root, node, "text", 1)
sourceVersion := read().Versions[root]
admitted := call("POST", base(root)+"/ai/runs", input, 202, sourceVersion, key)
if admitted["admission"] != "accepted" || admitted["target_incarnation"] != float64(1) || admitted["model"] == nil {
t.Fatal("canonical admission lost identity/base")
}
retry := call("POST", base(root)+"/ai/runs", input, 202, sourceVersion, key)
if !modelEqual(admitted, retry) {
t.Fatal("admission retry changed result")
}
call("POST", base(root)+"/ai/runs", input, 409, sourceVersion+1, key)
queried := call("GET", base(root)+"/ai/operations/"+key, nil, 200, 0, "")
if !modelEqual(admitted, queried) {
t.Fatal("lost admission response not recoverable")
}
unknown := call("GET", base(root)+"/ai/operations/"+modelTestID(6099), nil, 404, 0, "")
if unknown["status"] != "unknown" || unknown["terminal"] == true {
t.Fatal("404 pretended zero execution")
}
duplicate := response{}
for k, v := range input {
duplicate[k] = v
}
duplicateKey := modelTestID(6098)
duplicate["request_id"] = duplicateKey
call("POST", base(root)+"/ai/runs", duplicate, 409, read().Versions[root], duplicateKey)
mutate(func(model *canvasModel) { model.Elements[node]["geometry"].(map[string]any)["x"] = float64(33) })
execute(admitted["run_id"].(string))
saved := read()
data := saved.Elements[node]["data"].(map[string]any)
if data["text"] != "generated result" || saved.Elements[node]["geometry"].(map[string]any)["x"] != float64(33) || saved.Elements[node]["geometry"].(map[string]any)["width"] != float64(9000) || saved.Elements["future"] == nil || saved.Elements[node]["opaque"] == nil || data["extension"] == nil {
t.Fatal("AI lost canonical fields, geometry or future records")
}
// A content conflict retains its output; explicit application is still a narrow canonical write.
// 内容冲突保留输出,显式应用仍是窄字段写;同键重放保留原模型/版本且可查询回执。
conflictRun := start(root, node, "text", 1)
hooks <- func() {
mutate(func(model *canvasModel) { model.Elements[node]["data"].(map[string]any)["text"] = "user edit" })
}
execute(conflictRun["run_id"].(string))
conflictPath := base(root) + "/ai/runs/" + conflictRun["run_id"].(string)
conflict := call("GET", conflictPath, nil, 200, 0, "")
if conflict["status"] != "conflict" {
t.Fatal("changed content was overwritten")
}
outputID := conflict["outputs"].([]any)[0].(map[string]any)["output"].(map[string]any)["output_id"].(string)
applyKey := modelTestID(6200)
expected := read().Versions[root]
applyInput := response{"protocol_version": 2, "request_id": applyKey, "operation_id": modelTestID(6199), "target_incarnation": 1, "target_canvas_id": root, "node_id": node, "output_id": outputID}
applied := call("POST", conflictPath+"/apply", applyInput, 200, expected, applyKey)
again := call("POST", conflictPath+"/apply", applyInput, 200, expected, applyKey)
if !modelEqual(applied, again) || applied["model"] == nil || read().Elements[node]["geometry"].(map[string]any)["width"] != float64(9000) {
t.Fatal("explicit canonical application changed geometry or receipt")
}
applyReceipt := call("GET", base(root)+"/ai/operations/"+applyKey, nil, 200, 0, "")
if !modelEqual(applied, applyReceipt) || applied["action"] != "run.apply" || applied["status"] != "applied" {
t.Fatal("explicit apply receipt is not recoverable")
}
call("POST", conflictPath+"/apply", applyInput, 409, expected+1, applyKey)
// Keep one unapplied old output, then replace the target incarnation atomically.
// 保存旧输出并让另一运行开始后升级 incarnation,旧完成回调与旧输出显式应用都不能冒领新一代。
stale := start(root, node, "text", 1)
hooks <- func() {
mutate(func(model *canvasModel) { model.Elements[node]["data"].(map[string]any)["text"] = "keep this" })
}
execute(stale["run_id"].(string))
stalePath := base(root) + "/ai/runs/" + stale["run_id"].(string)
staleResult := call("GET", stalePath, nil, 200, 0, "")
staleOutput := staleResult["outputs"].([]any)[0].(map[string]any)["output"].(map[string]any)["output_id"].(string)
old := start(root, node, "text", 1)
run, e := s.claimCanvasRun(ctx)
if e != nil || run == nil || run.ID != old["run_id"] {
t.Fatalf("claim stale %v", e)
}
if ok, e := s.startCanvasStep(ctx, *run, run.Plan.Steps[0]); e != nil || !ok {
t.Fatalf("start stale %v", e)
}
mutate(func(model *canvasModel) {
model.Elements[node]["incarnation"] = float64(2)
model.Tombstones[node] = 1
model.TombstoneOwners[node] = root
})
state, e := s.finishCanvasStep(ctx, *run, run.Plan.Steps[0], "late output", "", true)
if e != nil || state != "cancelled" {
t.Fatalf("restored target accepted old callback %s %v", state, e)
}
if e = s.completeCanvasRun(ctx, *run, nil); e != nil {
t.Fatal(e)
}
if read().Elements[node]["data"].(map[string]any)["text"] != "keep this" {
t.Fatal("restore was overwritten")
}
staleApplyKey := modelTestID(6201)
staleApply := call("POST", stalePath+"/apply", response{"protocol_version": 2, "request_id": staleApplyKey, "operation_id": modelTestID(6205), "target_incarnation": 1, "target_canvas_id": root, "node_id": node, "output_id": staleOutput}, 409, read().Versions[root], staleApplyKey)
if staleApply["status"] != "not-applied" || staleApply["terminal"] != true || !modelEqual(staleApply, call("GET", base(root)+"/ai/operations/"+staleApplyKey, nil, 200, 0, "")) {
t.Fatal("stale apply has no queryable zero-effect receipt")
}
bad, badKey := command(root, node, "text", 1)
call("POST", base(root)+"/ai/runs", bad, 409, read().Versions[root], badKey)
restored := start(root, node, "text", 2)
cancelPath := base(root) + "/ai/runs/" + restored["run_id"].(string) + "/cancel"
cancelKey := modelTestID(6202)
cancelInput := response{"protocol_version": 2, "request_id": cancelKey, "operation_id": modelTestID(6203)}
cancelled := call("POST", cancelPath, cancelInput, 200, 0, cancelKey)
cancelAgain := call("POST", cancelPath, cancelInput, 200, 0, cancelKey)
cancelReceipt := call("GET", base(root)+"/ai/operations/"+cancelKey, nil, 200, 0, "")
if cancelled["status"] != "applied" || cancelled["run_status"] != "cancelled" || !modelEqual(cancelled, cancelAgain) || !modelEqual(cancelled, cancelReceipt) {
t.Fatal("cancel receipt changed on retry/query")
}
duplicateCancelKey := modelTestID(6204)
call("POST", cancelPath, response{"protocol_version": 2, "request_id": duplicateCancelKey, "operation_id": modelTestID(6203)}, 409, 0, duplicateCancelKey)
if executions.Load() != 3 {
t.Fatal("duplicate/cancelled/old execution called the model")
}
// Image output resolves a managed resource while retaining the element envelope.
// canonical 大几何与未知字段不受 legacy 限制回滚,图片输出成为可按权限下载的托管资产。
imageID := modelTestID(6300)
mutate(func(model *canvasModel) {
record := modelTestNode(imageID, root)
record["componentId"] = "plain-image"
record["data"].(map[string]any)["src"] = "data:image/png;base64," + base64.StdEncoding.EncodeToString(pngBytes.Bytes())
record["geometry"].(map[string]any)["width"] = float64(10000)
model.Elements[imageID] = record
})
imageRun := start(root, imageID, "image", 1)
execute(imageRun["run_id"].(string))
imageRecord := read().Elements[imageID]
imageData := imageRecord["data"].(map[string]any)
if imageRecord["geometry"].(map[string]any)["width"] != float64(10000) || imageData["assetId"] == nil || !strings.HasPrefix(modelString(imageData["src"]), s.assetURL(project, workspace, "")) {
t.Fatal("image result lost geometry or resource identity")
}
request := httptest.NewRequest("GET", modelString(imageData["src"]), nil)
request.Header.Set("Authorization", "Bearer "+token)
download := httptest.NewRecorder()
mux.ServeHTTP(download, request)
if download.Code != 200 || !bytes.Equal(download.Body.Bytes(), pngBytes.Bytes()) {
t.Fatal("canonical generated asset is unreadable")
}
moved := start(root, imageID, "image", 1)
moving, e := s.claimCanvasRun(ctx)
if e != nil || moving == nil || moving.ID != moved["run_id"] {
t.Fatalf("claim move %v", e)
}
if ok, e := s.startCanvasStep(ctx, *moving, moving.Plan.Steps[0]); e != nil || !ok {
t.Fatalf("start move %v", e)
}
// 运行中把目标换 owner,新 owner 准入仍应识别 node_busy;原任务成功只推进当前位置版本。
child, frame := modelTestID(6301), modelTestID(6302)
mutate(func(model *canvasModel) {
entry := modelTestNode(frame, root)
entry["componentId"] = "frame"
model.Elements[frame] = entry
model.Canvases[child] = modelCanvas{ID: child, Parent: &modelParent{CanvasID: root, EntryElementID: frame}}
model.Elements[imageID]["ownerCanvasId"] = child
})
busyInput, busyKey := command(child, imageID, "image", 1)
busy := call("POST", base(child)+"/ai/runs", busyInput, 409, read().Versions[child], busyKey)
if busy["error"] != "node_busy" {
t.Fatal("owner move admitted a duplicate paid task")
}
beforeMovedOutput := read()
state, e = s.finishCanvasStepOutput(ctx, *moving, moving.Plan.Steps[0], codex.CanvasOutput{Kind: "image", Image: &codex.CanvasImage{MIME: "image/png", Data: pngBytes.Bytes()}}, "", true)
if e != nil || state != "succeeded" {
t.Fatalf("owner-only move rejected output %s %v", state, e)
}
afterMovedOutput := read()
if afterMovedOutput.Elements[imageID]["ownerCanvasId"] != child || afterMovedOutput.Versions[root] != beforeMovedOutput.Versions[root] || afterMovedOutput.Versions[child] != beforeMovedOutput.Versions[child]+1 || afterMovedOutput.Elements[imageID]["geometry"].(map[string]any)["width"] != float64(10000) {
t.Fatal("relocated result rewrote ownership, geometry or the origin version")
}
movedStatus := call("GET", base(root)+"/ai/runs/"+moving.ID, nil, 200, 0, "")
foundRelocation := false
for _, value := range movedStatus["events"].([]any) {
event := value.(map[string]any)
if event["type"] == "step.applied" {
foundRelocation = event["board_id"] == child && event["origin_board_id"] == root && event["canonical_root"] == root && event["model"].(map[string]any)["complete"] == true
}
}
if !foundRelocation || movedStatus["applied_versions"].(map[string]any)[child] != float64(afterMovedOutput.Versions[child]) {
t.Fatal("moved output lost current-owner version or canonical context")
}
if e = s.completeCanvasRun(ctx, *moving, nil); e != nil {
t.Fatal(e)
}
// 即使目标版本当前,祖先 read-set 陈旧也必须零效果拒绝;环境变化后原拒绝键不能重算。
staleInput, staleKey := command(child, imageID, "image", 1)
staleVersions := staleInput["expected_versions"].(map[string]int64)
staleVersions[root]-- // The target version is current; its ancestor context is not.
beforeRejected := read()
denied := call("POST", base(child)+"/ai/runs", staleInput, 412, read().Versions[child], staleKey)
if denied["status"] != "not-applied" || denied["terminal"] != true || denied["action"] != "run.start" || !modelEqual(beforeRejected, read()) {
t.Fatal("rejection was not a zero-effect receipt")
}
if queried := call("GET", base(child)+"/ai/operations/"+staleKey, nil, 200, 0, ""); !modelEqual(denied, queried) {
t.Fatal("negative admission receipt lost")
}
// A later context change cannot turn an old rejected key into a paid execution.
mutate(func(model *canvasModel) { model.Elements[imageID]["geometry"].(map[string]any)["x"] = float64(123) })
if retried := call("POST", base(child)+"/ai/runs", staleInput, 412, beforeRejected.Versions[child], staleKey); !modelEqual(denied, retried) {
t.Fatal("rejected request was reevaluated")
}
missingRunKey := modelTestID(6400)
missingCancel := call("POST", base(child)+"/ai/runs/"+modelTestID(6401)+"/cancel", response{"protocol_version": 2, "request_id": missingRunKey, "operation_id": modelTestID(6402)}, 404, 0, missingRunKey)
if missingCancel["status"] != "not-applied" || missingCancel["terminal"] != true {
t.Fatal("missing run cancel has no stable rejection")
}
if queried := call("GET", base(child)+"/ai/operations/"+missingRunKey, nil, 200, 0, ""); !modelEqual(missingCancel, queried) {
t.Fatal("negative cancel receipt lost")
}
missingInput, missingKey := command(child, imageID, "image", 1)
delete(missingInput, "expected_versions")
call("POST", base(child)+"/ai/runs", missingInput, 400, read().Versions[child], missingKey)
// An explicit replan can reuse a logical operation after its known zero-effect rejection.
// 已知零效果允许显式新键重计划并复用逻辑操作;完成后再取消不得假装撤销成功结果。
replanned := response{}
for key, value := range staleInput {
replanned[key] = value
}
replanKey := modelTestID(6405)
replanned["request_id"], replanned["expected_versions"] = replanKey, read().Versions
childRun := call("POST", base(child)+"/ai/runs", replanned, 202, read().Versions[child], replanKey)
execute(childRun["run_id"].(string))
beforeLateCancel := read()
lateKey := modelTestID(6406)
lateCancel := call("POST", base(child)+"/ai/runs/"+childRun["run_id"].(string)+"/cancel", response{"protocol_version": 2, "request_id": lateKey, "operation_id": modelTestID(6407)}, 200, 0, lateKey)
if lateCancel["run_status"] != "succeeded" || !modelEqual(beforeLateCancel, read()) {
t.Fatal("late cancellation pretended to undo a completed result")
}
if read().Elements[imageID]["ownerCanvasId"] != child {
t.Fatal("child result moved its target back")
}
// 排队期间换 owner 并归档原分区,run 的原 URL 仍可读取/取消,执行写入当前根 owner。
queuedMove := start(child, imageID, "image", 1)
mutate(func(model *canvasModel) {
model.Elements[imageID]["ownerCanvasId"] = root
delete(model.Canvases, child)
})
execute(queuedMove["run_id"].(string))
archivedRoute := base(child) + "/ai/runs/" + queuedMove["run_id"].(string)
archivedResult := call("GET", archivedRoute, nil, 200, 0, "")
if archivedResult["status"] != "succeeded" || read().Elements[imageID]["ownerCanvasId"] != root {
t.Fatal("queued move or archived admission route stopped the run")
}
lateArchiveKey := modelTestID(6500)
if result := call("POST", archivedRoute+"/cancel", response{"protocol_version": 2, "request_id": lateArchiveKey, "operation_id": modelTestID(6501)}, 200, 0, lateArchiveKey); result["run_status"] != "succeeded" {
t.Fatal("archived route lost cancellation identity")
}
// Content changes still conflict after a move; explicit application targets the current owner.
// 换 owner 同时改正文仍产生冲突;用户显式应用须确认当前 owner,不能写回冻结来源画布。
movedConflict := start(root, node, "text", 2)
hooks <- func() {
mutate(func(model *canvasModel) {
model.Canvases[child] = modelCanvas{ID: child, Parent: &modelParent{CanvasID: root, EntryElementID: frame}}
model.Elements[node]["ownerCanvasId"] = child
model.Elements[node]["data"].(map[string]any)["text"] = "keep moved edit"
})
}
execute(movedConflict["run_id"].(string))
movedConflictPath := base(root) + "/ai/runs/" + movedConflict["run_id"].(string)
conflictMovedResult := call("GET", movedConflictPath, nil, 200, 0, "")
if conflictMovedResult["status"] != "conflict" || read().Elements[node]["data"].(map[string]any)["text"] != "keep moved edit" {
t.Fatal("move allowed a content conflict overwrite")
}
movedOutput := conflictMovedResult["outputs"].([]any)[0].(map[string]any)["output"].(map[string]any)["output_id"].(string)
movedApplyKey := modelTestID(6502)
movedApplied := call("POST", movedConflictPath+"/apply", response{"protocol_version": 2, "request_id": movedApplyKey, "operation_id": modelTestID(6503), "node_id": node, "output_id": movedOutput, "target_incarnation": 2, "target_canvas_id": child}, 200, read().Versions[child], movedApplyKey)
if movedApplied["board_id"] != child || movedApplied["origin_board_id"] != root || read().Elements[node]["ownerCanvasId"] != child {
t.Fatal("explicit application wrote to the frozen owner")
}
// 删除已移动目标并记录墓碑,应使原任务在调用 worker 之前取消。
doomed := start(child, node, "text", 2)
mutate(func(model *canvasModel) {
record := model.Elements[node]
model.DeadRecords[node] = record
model.Tombstones[node] = 2
model.TombstoneOwners[node] = child
delete(model.Elements, node)
for id, element := range model.Elements {
if element["structure"] == "connection" && (element["source"].(map[string]any)["elementId"] == node || element["target"].(map[string]any)["elementId"] == node) {
model.DeadRecords[id] = element
model.Tombstones[id] = modelInt(element["incarnation"])
model.TombstoneOwners[id] = modelString(element["ownerCanvasId"])
delete(model.Elements, id)
}
}
})
execute(doomed["run_id"].(string))
if result := call("GET", base(child)+"/ai/runs/"+doomed["run_id"].(string), nil, 200, 0, ""); result["status"] != "cancelled" {
t.Fatal("deleting a moved target failed to revoke its old job")
}
// 换 owner 后把账户降为 viewer,执行前必须重新检查编辑资格且不增加模型调用次数。
revoked := start(root, imageID, "image", 1)
mutate(func(model *canvasModel) { model.Elements[imageID]["ownerCanvasId"] = child })
beforeRevoked := executions.Load()
if _, e = db.ExecContext(ctx, `UPDATE workspace_members SET role='viewer' WHERE project=$1 AND workspace_id=$2 AND account_id=$3`, project, workspace, account); e != nil {
t.Fatal(e)
}
execute(revoked["run_id"].(string))
if result := call("GET", base(root)+"/ai/runs/"+revoked["run_id"].(string), nil, 200, 0, ""); result["status"] != "failed" || executions.Load() != beforeRevoked {
t.Fatal("moved target executed after write permission was revoked")
}
}
+102
View File
@@ -0,0 +1,102 @@
// AI canonical 适配的纯回归:验证窄字段更新、未知组件保留和准入 read-set 版本,不运行真实生成。
package platform
import (
"encoding/json"
"testing"
)
// TestCanonicalAIPatchPreservesOpaqueModelAndGeometry 检查大尺寸几何/未知 envelope 保留、输入不变,拒绝改 geometry、未知 dataVersion 和错误 owner。
func TestCanonicalAIPatchPreservesOpaqueModelAndGeometry(t *testing.T) {
before := modelTestDocument()
before.Elements["a"]["geometry"].(map[string]any)["width"] = float64(9000)
before.Elements["a"]["extension"] = map[string]any{"kept": true}
before.Elements["a"]["data"].(map[string]any)["opaque"] = map[string]any{"constructor": map[string]any{"kept": true}}
before.Elements["future"] = modelTestNode("future", modelRootID)
before.Elements["future"]["dataVersion"] = float64(12)
original := cloneModel(before)
after, err := prepareModelAIPatch(before, modelRootID, "a", response{"text": "generated"})
if err != nil {
t.Fatal(err)
}
if !modelEqual(before, original) {
t.Fatal("AI staging changed its source")
}
if after.Elements["a"]["data"].(map[string]any)["text"] != "generated" || after.Versions[modelRootID] != 2 {
t.Fatal("AI text/version missing")
}
if !modelEqual(after.Elements["a"]["geometry"], before.Elements["a"]["geometry"]) || !modelEqual(after.Elements["a"]["extension"], before.Elements["a"]["extension"]) || !modelEqual(after.Elements["future"], before.Elements["future"]) {
t.Fatal("AI staging replaced unrelated fields")
}
if _, err = prepareModelAIPatch(before, modelRootID, "a", response{"geometry": map[string]any{}}); err != errAIInvalidPatch {
t.Fatalf("geometry patch was accepted: %v", err)
}
if _, err = prepareModelAIPatch(before, modelRootID, "future", response{"text": "lost"}); err != errAITargetChanged {
t.Fatalf("future schema was interpreted: %v", err)
}
if _, err = prepareModelAIPatch(before, modelChildID, "a", response{"text": "wrong owner"}); err != errAITargetChanged {
t.Fatalf("wrong owner was accepted: %v", err)
}
}
// TestCanonicalAIProjectionDoesNotExecuteFutureConnections 未来版本连接仍可保存在模型中,但不能被旧 AI 投影误当作可执行连线。
func TestCanonicalAIProjectionDoesNotExecuteFutureConnections(t *testing.T) {
model := modelTestDocument()
model.Elements["b"] = modelTestNode("b", modelRootID)
model.Elements["future-edge"] = map[string]any{"id": "future-edge", "incarnation": float64(1), "structure": "connection", "componentId": "connection", "dataVersion": float64(9), "ownerCanvasId": modelRootID, "source": map[string]any{"elementId": "a"}, "target": map[string]any{"elementId": "b"}, "path": nil, "data": map[string]any{}}
if err := validateCanvasModel(model); err != nil {
t.Fatal(err)
}
projection, err := projectCanvasModel(model)
if err != nil {
t.Fatal(err)
}
var document map[string]any
if err = json.Unmarshal(projection[modelRootID], &document); err != nil {
t.Fatal(err)
}
if len(document["edges"].([]any)) != 0 || model.Elements["future-edge"] == nil {
t.Fatal("future connection was executed or removed")
}
}
// TestCanonicalAIAdmissionVersions 验证 Expected 精确覆盖活跃画布而排除归档版本,缺项/错头与陈旧版本使用不同错误码。
// 该用例仅测版本函数,构造模型并不满足完整树校验。
func TestCanonicalAIAdmissionVersions(t *testing.T) {
model := modelTestDocument()
model.Canvases[modelChildID] = modelCanvas{ID: modelChildID}
model.Versions[modelChildID] = 3
// Include an archived version: it must not become an executable read dependency.
model.Versions["archived"] = 8
valid := map[string]int64{}
for id := range model.Canvases {
valid[id] = model.Versions[id]
}
if code := validateCanvasAIVersions(model, modelRootID, valid[modelRootID], valid); code != "" {
t.Fatal(code)
}
for _, test := range []struct {
name string
versions map[string]int64
header int64
want string
}{
{"missing", nil, 1, "invalid_ai_versions"},
{"changed-header", valid, 99, "invalid_ai_versions"},
{"incomplete", map[string]int64{modelRootID: 1}, 1, "invalid_ai_versions"},
} {
t.Run(test.name, func(t *testing.T) {
if got := validateCanvasAIVersions(model, modelRootID, test.header, test.versions); got != test.want {
t.Fatalf("got %q want %q", got, test.want)
}
})
}
stale := map[string]int64{}
for id, version := range valid {
stale[id] = version
}
stale[modelChildID]++
if code := validateCanvasAIVersions(model, modelRootID, valid[modelRootID], stale); code != "version_conflict" {
t.Fatal(code)
}
}
+5
View File
@@ -1,3 +1,4 @@
// 画布可用模型目录与保存时配置验证,模型能力来源是私有 worker 过滤后的目录。
package platform package platform
import ( import (
@@ -9,6 +10,7 @@ import (
"gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex" "gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex"
) )
// canvasAIModels 要求 board 可读;worker 不可用时返回空目录及原因,不把基础能力发现变成请求失败。
func (s *service) canvasAIModels(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) canvasAIModels(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet { if r.Method != http.MethodGet {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -47,6 +49,9 @@ func (s *service) canvasAIModels(w http.ResponseWriter, r *http.Request, project
reply(w, 200, response{"models": models, "image_generation": capability}) reply(w, 200, response{"models": models, "image_generation": capability})
return nil return nil
} }
// validateCanvasAIModels 无 AI 配置则不访问 worker;存在配置时验证模型可用且参数对象为空。
// 禁用配置可不填模型 ID,但填入 ID 仍需有效;失败已经写响应,调用者应退出并回滚。
func (s *service) validateCanvasAIModels(w http.ResponseWriter, r *http.Request, raw json.RawMessage) bool { func (s *service) validateCanvasAIModels(w http.ResponseWriter, r *http.Request, raw json.RawMessage) bool {
data := canvasNodeData(raw) data := canvasNodeData(raw)
configured := []map[string]any{} configured := []map[string]any{}
+30 -12
View File
@@ -1,3 +1,4 @@
// AI 执行计划的纯规划器:解析真实端点、选择传播范围、冻结静态内容并按依赖拓扑排序。
package platform package platform
import ( import (
@@ -7,6 +8,7 @@ import (
"strings" "strings"
) )
// canvasAIStaticInput 保存不由本轮生成的输入内容及其逻辑边身份,后续编辑不会改变已经冻结的输入。
type canvasAIStaticInput struct { type canvasAIStaticInput struct {
EdgeID string `json:"logical_edge_id"` EdgeID string `json:"logical_edge_id"`
BoardID string `json:"board_id"` BoardID string `json:"board_id"`
@@ -14,33 +16,43 @@ type canvasAIStaticInput struct {
Kind string `json:"kind"` Kind string `json:"kind"`
Content map[string]any `json:"content"` Content map[string]any `json:"content"`
} }
// canvasAIStepPlan 固定来源、配置、内容指纹与依赖;canonical 根/incarnation 由准入阶段另行绑定。
type canvasAIStepPlan struct { type canvasAIStepPlan struct {
StaticInputs []canvasAIStaticInput `json:"static_inputs"` CanonicalRoot string `json:"canonical_root,omitempty"`
MaxExecutionMS int `json:"max_execution_ms"` TargetIncarnation int64 `json:"target_incarnation,omitempty"`
ID string `json:"step_id"` StaticInputs []canvasAIStaticInput `json:"static_inputs"`
BoardID string `json:"board_id"` MaxExecutionMS int `json:"max_execution_ms"`
NodeID string `json:"node_id"` ID string `json:"step_id"`
Kind string `json:"kind"` BoardID string `json:"board_id"`
ModelID string `json:"model_id"` NodeID string `json:"node_id"`
Config map[string]any `json:"config"` Kind string `json:"kind"`
FrozenContent map[string]any `json:"frozen_content"` ModelID string `json:"model_id"`
Fingerprint string `json:"target_fingerprint"` Config map[string]any `json:"config"`
Status string `json:"status"` FrozenContent map[string]any `json:"frozen_content"`
Dependencies []string `json:"dependencies"` Fingerprint string `json:"target_fingerprint"`
Status string `json:"status"`
Dependencies []string `json:"dependencies"`
} }
// canvasAIEdgePlan 的 ID 由拥有者画布/边 ID 组成,端点是解析后的真实步骤复合 ID。
type canvasAIEdgePlan struct { type canvasAIEdgePlan struct {
ID string `json:"logical_edge_id"` ID string `json:"logical_edge_id"`
Source string `json:"source_step_id"` Source string `json:"source_step_id"`
Target string `json:"target_step_id"` Target string `json:"target_step_id"`
} }
// canvasAIPlan 是可持久化的确定执行输入,Versions 标明规划时读取的所有快照版本。
type canvasAIPlan struct { type canvasAIPlan struct {
Steps []canvasAIStepPlan `json:"steps"` Steps []canvasAIStepPlan `json:"steps"`
Edges []canvasAIEdgePlan `json:"edges"` Edges []canvasAIEdgePlan `json:"edges"`
Versions map[string]int64 `json:"frozen_versions"` Versions map[string]int64 `json:"frozen_versions"`
} }
// canvasNodeKey 在旧画布局部 ID 域内组合唯一键,canonical 元素仍保留原计划来源作为步骤身份。
func canvasNodeKey(board, node string) string { return board + "/" + node } func canvasNodeKey(board, node string) string { return board + "/" + node }
// buildCanvasAIPlan 只操作传入快照,不访问数据库;最多选择 64 步,拓扑最长路径不得超过 32。
func buildCanvasAIPlan(snapshots map[string]canvasSnapshot, board, node string, propagate bool) (canvasAIPlan, error) { func buildCanvasAIPlan(snapshots map[string]canvasSnapshot, board, node string, propagate bool) (canvasAIPlan, error) {
plan := canvasAIPlan{Steps: []canvasAIStepPlan{}, Edges: []canvasAIEdgePlan{}, Versions: map[string]int64{}} plan := canvasAIPlan{Steps: []canvasAIStepPlan{}, Edges: []canvasAIEdgePlan{}, Versions: map[string]int64{}}
data := map[string]map[string]any{} data := map[string]map[string]any{}
@@ -51,6 +63,7 @@ func buildCanvasAIPlan(snapshots map[string]canvasSnapshot, board, node string,
} }
} }
var resolve func(string, string, string, string, int) (string, error) var resolve func(string, string, string, string, int) (string, error)
// frame 的连接必须经方向匹配端口下钻到真实节点,图标等不可执行节点不能成为输入/目标。
resolve = func(board, node, handle, direction string, depth int) (string, error) { resolve = func(board, node, handle, direction string, depth int) (string, error) {
if depth > 8 { if depth > 8 {
return "", errors.New("graph_limit_exceeded") return "", errors.New("graph_limit_exceeded")
@@ -117,6 +130,7 @@ func buildCanvasAIPlan(snapshots map[string]canvasSnapshot, board, node string,
for key := range outgoing { for key := range outgoing {
sort.Slice(outgoing[key], func(i, j int) bool { return outgoing[key][i].ID < outgoing[key][j].ID }) sort.Slice(outgoing[key], func(i, j int) bool { return outgoing[key][i].ID < outgoing[key][j].ID })
} }
// 根由显式请求执行;下游未启用 AI 或没有模型则记录 skipped 并停止从该节点继续传播。
selected := map[string]bool{} selected := map[string]bool{}
skipped := map[string]bool{} skipped := map[string]bool{}
queue := []string{root} queue := []string{root}
@@ -147,6 +161,7 @@ func buildCanvasAIPlan(snapshots map[string]canvasSnapshot, board, node string,
} }
} }
// Kahn's algorithm waits for every participating predecessor at a diamond. // Kahn's algorithm waits for every participating predecessor at a diamond.
// Kahn 入度等待所有参与前驱,菱形汇合只能在两支都处理完后出队,不能按首次访问就执行。
indegree := map[string]int{} indegree := map[string]int{}
incoming := map[string][]string{} incoming := map[string][]string{}
depths := map[string]int{} depths := map[string]int{}
@@ -175,6 +190,7 @@ func buildCanvasAIPlan(snapshots map[string]canvasSnapshot, board, node string,
content := canvasFrozenContent(d) content := canvasFrozenContent(d)
static := []canvasAIStaticInput{} static := []canvasAIStaticInput{}
sort.Slice(allIncoming[id], func(i, j int) bool { return allIncoming[id][i].ID < allIncoming[id][j].ID }) sort.Slice(allIncoming[id], func(i, j int) bool { return allIncoming[id][i].ID < allIncoming[id][j].ID })
// 本轮将生成的有效前驱作为动态依赖,其余入边内容冻结为静态输入,包括传播关闭时的前驱。
for _, edge := range allIncoming[id] { for _, edge := range allIncoming[id] {
if propagate && selected[edge.Source] && !skipped[edge.Source] { if propagate && selected[edge.Source] && !skipped[edge.Source] {
continue continue
@@ -207,6 +223,7 @@ func buildCanvasAIPlan(snapshots map[string]canvasSnapshot, board, node string,
} }
} }
} }
// 有入度永远无法归零的已选节点表示执行环,拒绝整个计划而不是执行可排序前缀。
if len(plan.Steps) != len(selected) { if len(plan.Steps) != len(selected) {
return plan, errors.New("execution_cycle") return plan, errors.New("execution_cycle")
} }
@@ -214,6 +231,7 @@ func buildCanvasAIPlan(snapshots map[string]canvasSnapshot, board, node string,
return plan, nil return plan, nil
} }
// canvasFrozenContent 只捕获语义输入:图片为引用身份,文本为正文,不含位置和纯展示样式。
func canvasFrozenContent(data map[string]any) map[string]any { func canvasFrozenContent(data map[string]any) map[string]any {
if canvasChoice(data["kind"], "image", "plain-image") { if canvasChoice(data["kind"], "image", "plain-image") {
return map[string]any{"src": data["src"], "assetId": data["assetId"]} return map[string]any{"src": data["src"], "assetId": data["assetId"]}
+10
View File
@@ -1,3 +1,4 @@
// AI 规划纯算法回归,覆盖传播范围、拓扑汇合、内容冻结与嵌套端口解析,不调用真实模型。
package platform package platform
import ( import (
@@ -6,6 +7,7 @@ import (
"testing" "testing"
) )
// aiPlanFixture 从边对建立节点与执行开关,可指定一个未配置 AI 的中间节点来验证传播停止。
func aiPlanFixture(edges [][2]string, disabled map[string]bool, unconfigured string) map[string]canvasSnapshot { func aiPlanFixture(edges [][2]string, disabled map[string]bool, unconfigured string) map[string]canvasSnapshot {
ids := map[string]bool{"a": true} ids := map[string]bool{"a": true}
for _, e := range edges { for _, e := range edges {
@@ -28,6 +30,8 @@ func aiPlanFixture(edges [][2]string, disabled map[string]bool, unconfigured str
raw, _ := json.Marshal(map[string]any{"schema_version": 2, "nodes": nodes, "edges": values, "viewport": map[string]any{"x": 0, "y": 0, "zoom": 1}}) raw, _ := json.Marshal(map[string]any{"schema_version": 2, "nodes": nodes, "edges": values, "viewport": map[string]any{"x": 0, "y": 0, "zoom": 1}})
return map[string]canvasSnapshot{"board": {BoardID: "board", Version: 4, Document: raw}} return map[string]canvasSnapshot{"board": {BoardID: "board", Version: 4, Document: raw}}
} }
// TestAIPlanDiamondAndPropagationBoundaries 验证菱形末端只执行一次且等待两前驱,关闭传播/禁用边/无配置可截断遍历,环必须拒绝。
func TestAIPlanDiamondAndPropagationBoundaries(t *testing.T) { func TestAIPlanDiamondAndPropagationBoundaries(t *testing.T) {
graph := aiPlanFixture([][2]string{{"a", "b"}, {"a", "c"}, {"b", "d"}, {"c", "d"}}, nil, "") graph := aiPlanFixture([][2]string{{"a", "b"}, {"a", "c"}, {"b", "d"}, {"c", "d"}}, nil, "")
plan, err := buildCanvasAIPlan(graph, "board", "a", true) plan, err := buildCanvasAIPlan(graph, "board", "a", true)
@@ -59,6 +63,9 @@ func TestAIPlanDiamondAndPropagationBoundaries(t *testing.T) {
t.Fatal("cycle accepted") t.Fatal("cycle accepted")
} }
} }
// TestAITargetFingerprintIgnoresVisualEdits 检查标题/样式不改指纹,正文或计划来源 board 改变则改指纹;JSON 键顺序不影响摘要。
// 同时覆盖超长提示和图标不允许 AI 配置,不把该用例视为 canonical owner 移动验证。
func TestAITargetFingerprintIgnoresVisualEdits(t *testing.T) { func TestAITargetFingerprintIgnoresVisualEdits(t *testing.T) {
data := map[string]any{"kind": "text", "text": "original", "title": "Title", "rotation": 0, "ai": map[string]any{"modelId": "fixture", "prompt": "prompt", "enabled": true}} data := map[string]any{"kind": "text", "text": "original", "title": "Title", "rotation": 0, "ai": map[string]any{"modelId": "fixture", "prompt": "prompt", "enabled": true}}
original := canvasTargetFingerprint("board", "node", data) original := canvasTargetFingerprint("board", "node", data)
@@ -90,6 +97,7 @@ func TestAITargetFingerprintIgnoresVisualEdits(t *testing.T) {
} }
} }
// TestAIPlanFreezesAdditionalStaticInputs 从 x→a→b 的 a 启动,x 只作为冻结静态来源,不倒向执行;关闭传播仍保留输入。
func TestAIPlanFreezesAdditionalStaticInputs(t *testing.T) { func TestAIPlanFreezesAdditionalStaticInputs(t *testing.T) {
graph := aiPlanFixture([][2]string{{"x", "a"}, {"a", "b"}}, nil, "") graph := aiPlanFixture([][2]string{{"x", "a"}, {"a", "b"}}, nil, "")
plan, err := buildCanvasAIPlan(graph, "board", "a", true) plan, err := buildCanvasAIPlan(graph, "board", "a", true)
@@ -111,6 +119,8 @@ func TestAIPlanFreezesAdditionalStaticInputs(t *testing.T) {
t.Fatal("static input not supplied to model") t.Fatal("static input not supplied to model")
} }
} }
// TestAIPlanLeavesChildThroughNestedPortChain 解析两层 frame port 到同一真实 deep 节点,边可有两条但目标步骤不重复,祖先版本也冻结。
func TestAIPlanLeavesChildThroughNestedPortChain(t *testing.T) { func TestAIPlanLeavesChildThroughNestedPortChain(t *testing.T) {
raw := memberFixture(t) raw := memberFixture(t)
child := "11111111-1111-4111-8111-111111111111" child := "11111111-1111-4111-8111-111111111111"
+65 -7
View File
@@ -1,3 +1,4 @@
// AI 运行详情、事件增量和准入回执查询;所有结果读取都重新检查当前资源权限。
package platform package platform
import ( import (
@@ -7,6 +8,7 @@ import (
"strconv" "strconv"
) )
// publicAIPlan 只公开计划结构、依赖及来源身份,静态输入标记 frozen_snapshot,不暴露冻结正文/图片。
func publicAIPlan(plan canvasAIPlan) response { func publicAIPlan(plan canvasAIPlan) response {
steps := []any{} steps := []any{}
for _, step := range plan.Steps { for _, step := range plan.Steps {
@@ -14,10 +16,12 @@ func publicAIPlan(plan canvasAIPlan) response {
for _, source := range step.StaticInputs { for _, source := range step.StaticInputs {
static = append(static, response{"logical_edge_id": source.EdgeID, "board_id": source.BoardID, "node_id": source.NodeID, "kind": source.Kind, "source": "frozen_snapshot"}) static = append(static, response{"logical_edge_id": source.EdgeID, "board_id": source.BoardID, "node_id": source.NodeID, "kind": source.Kind, "source": "frozen_snapshot"})
} }
steps = append(steps, response{"step_id": step.ID, "board_id": step.BoardID, "node_id": step.NodeID, "kind": step.Kind, "model_id": step.ModelID, "max_execution_ms": step.MaxExecutionMS, "status": step.Status, "dependencies": step.Dependencies, "static_inputs": static}) steps = append(steps, response{"step_id": step.ID, "board_id": step.BoardID, "node_id": step.NodeID, "target_incarnation": step.TargetIncarnation, "canonical_root": step.CanonicalRoot, "kind": step.Kind, "model_id": step.ModelID, "max_execution_ms": step.MaxExecutionMS, "status": step.Status, "dependencies": step.Dependencies, "static_inputs": static})
} }
return response{"steps": steps, "edges": plan.Edges, "frozen_versions": plan.Versions} return response{"steps": steps, "edges": plan.Edges, "frozen_versions": plan.Versions}
} }
// getCanvasAIRun 按 after_seq 增量返回事件,查询步骤前按 canonical 稳定身份解析当前目标并检查权限。
func (s *service) getCanvasAIRun(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) getCanvasAIRun(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet { if r.Method != http.MethodGet {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -51,7 +55,7 @@ func (s *service) getCanvasAIRun(w http.ResponseWriter, r *http.Request, project
return err return err
} }
defer tx.Rollback() defer tx.Rollback()
if _, _, err = lockMaterial(r.Context(), tx, project, workspace, board, account); err != nil { if _, _, err = lockCanvasAIRunRoute(r.Context(), tx, project, workspace, board, account); err != nil {
return err return err
} }
var status string var status string
@@ -66,16 +70,25 @@ func (s *service) getCanvasAIRun(w http.ResponseWriter, r *http.Request, project
if err = json.Unmarshal(rawPlan, &plan); err != nil { if err = json.Unmarshal(rawPlan, &plan); err != nil {
return err return err
} }
// 目标可能已换 owner;解析失败退回计划来源做路由授权,避免查询绕过撤权或归档约束。
checked := map[string]bool{board: true} checked := map[string]bool{board: true}
for _, step := range plan.Steps { for _, step := range plan.Steps {
if !checked[step.BoardID] { target, ok, e := resolveCanvasAITarget(r.Context(), tx, project, workspace, step)
if _, _, err = lockMaterial(r.Context(), tx, project, workspace, step.BoardID, account); err != nil { if e != nil {
return err return e
}
if !ok {
target = step.BoardID
}
if !checked[target] {
if _, _, e = lockCanvasAIRunRoute(r.Context(), tx, project, workspace, target, account); e != nil {
return e
} }
checked[step.BoardID] = true checked[target] = true
} }
} }
rows, err := tx.QueryContext(r.Context(), `SELECT id,board_id::text,node_id,status,error_code,applied_version,CASE WHEN output IS NULL THEN NULL ELSE output-'text' END FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND run_id=$3 ORDER BY ordinal`, project, workspace, id) // 步骤输出剔除 text,仅返回元信息和可应用版本;AppliedBoard 反映实际写回位置而非原计划位置。
rows, err := tx.QueryContext(r.Context(), `SELECT id,COALESCE(applied_board_id,board_id)::text,node_id,status,error_code,applied_version,CASE WHEN output IS NULL THEN NULL ELSE output-'text' END FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND run_id=$3 ORDER BY ordinal`, project, workspace, id)
if err != nil { if err != nil {
return err return err
} }
@@ -127,6 +140,7 @@ func (s *service) getCanvasAIRun(w http.ResponseWriter, r *http.Request, project
rows.Close() rows.Close()
return err return err
} }
// 事件页既限条数又限累计 data 字节;至少保留首事件,next_seq 仅推进到真正返回的最后事件。
if size+len(data) > 800<<10 && len(events) > 0 { if size+len(data) > 800<<10 && len(events) > 0 {
break break
} }
@@ -158,3 +172,47 @@ func (s *service) getCanvasAIRun(w http.ResponseWriter, r *http.Request, project
reply(w, 200, result) reply(w, 200, result)
return nil return nil
} }
// Resolve admission by the original client key, before the caller knows a run ID.
// Absence is unknown, not a terminal proof that an earlier invocation had no effect.
// getCanvasAIAdmission 用原客户端键恢复准入结果,先查 v2 请求表,再兼容旧 run 的 create_response。
// 没有记录只说明 unknown,不构成确定零效果证明,客户端应保留原键继续恢复。
func (s *service) getCanvasAIAdmission(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet {
reject(w, 405, "method_not_allowed")
return nil
}
key := r.PathValue("request")
if !uuidSlugPattern.MatchString(key) {
reject(w, 400, "invalid_request_id")
return nil
}
workspace, board := r.PathValue("workspace"), r.PathValue("material")
tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil {
return err
}
defer tx.Rollback()
if _, _, err = lockCanvasAIRunRoute(r.Context(), tx, project, workspace, board, account); err != nil {
return err
}
var body json.RawMessage
err = tx.QueryRowContext(r.Context(), `SELECT response_body FROM canvas_ai_requests WHERE project=$1 AND workspace_id=$2 AND board_id=$3 AND account_id=$4 AND request_id=$5`, project, workspace, board, account, key).Scan(&body)
if err == nil {
reply(w, 200, body)
return nil
}
if err != sql.ErrNoRows {
return err
}
err = tx.QueryRowContext(r.Context(), `SELECT create_response FROM canvas_ai_runs WHERE project=$1 AND workspace_id=$2 AND board_id=$3 AND account_id=$4 AND idempotency_key=$5`, project, workspace, board, account, key).Scan(&body)
if err == sql.ErrNoRows {
reply(w, 404, response{"protocol_version": 2, "request_id": key, "status": "unknown", "error": "ai_admission_unknown"})
return nil
}
if err != nil {
return err
}
reply(w, 200, body)
return nil
}
+16
View File
@@ -1,3 +1,4 @@
// 按执行相关边懒读取画布树,避免为一次 AI 操作扫描无关或无权限的子画布。
package platform package platform
import ( import (
@@ -8,6 +9,7 @@ import (
"strings" "strings"
) )
// canvasAIReader 通过注入 Load/Parent 解耦数据库,缓存快照、解码文档和已知父关系,并记录实际用到的边。
type canvasAIReader struct { type canvasAIReader struct {
Load func(string) (canvasSnapshot, error) Load func(string) (canvasSnapshot, error)
Parent func(string) (subgraphRelation, error) Parent func(string) (subgraphRelation, error)
@@ -18,6 +20,7 @@ type canvasAIReader struct {
used map[string]map[string]bool used map[string]map[string]bool
} }
// snapshot 每个 board 只加载/解码一次,返回同一捕获快照供本次计划复用。
func (reader *canvasAIReader) snapshot(board string) (canvasSnapshot, map[string]any, error) { func (reader *canvasAIReader) snapshot(board string) (canvasSnapshot, map[string]any, error) {
if snapshot, ok := reader.snapshots[board]; ok { if snapshot, ok := reader.snapshots[board]; ok {
return snapshot, reader.documents[board], nil return snapshot, reader.documents[board], nil
@@ -34,6 +37,8 @@ func (reader *canvasAIReader) snapshot(board string) (canvasSnapshot, map[string
reader.documents[board] = doc reader.documents[board] = doc
return snapshot, doc, nil return snapshot, doc, nil
} }
// parent 将无父行归一为空关系并缓存 parentKnown,避免根画布被反复查询。
func (reader *canvasAIReader) parent(board string) (subgraphRelation, error) { func (reader *canvasAIReader) parent(board string) (subgraphRelation, error) {
if reader.parentKnown[board] { if reader.parentKnown[board] {
return reader.parents[board], nil return reader.parents[board], nil
@@ -50,6 +55,8 @@ func (reader *canvasAIReader) parent(board string) (subgraphRelation, error) {
reader.parents[board] = relation reader.parents[board] = relation
return relation, nil return relation, nil
} }
// node 返回已加载画布中的节点 data,缺失节点按所有权冲突处理,不凭同名跨画布寻找。
func (reader *canvasAIReader) node(board, node string) (map[string]any, error) { func (reader *canvasAIReader) node(board, node string) (map[string]any, error) {
_, doc, err := reader.snapshot(board) _, doc, err := reader.snapshot(board)
if err != nil { if err != nil {
@@ -63,6 +70,8 @@ func (reader *canvasAIReader) node(board, node string) (map[string]any, error) {
} }
return nil, errGraphOwnership return nil, errGraphOwnership
} }
// resolve 按方向递归解开 frame port,并验证数据库父关系与文档 subgraph 相符,最多跨八层。
func (reader *canvasAIReader) resolve(board, node, handle, direction string, depth int) (string, error) { func (reader *canvasAIReader) resolve(board, node, handle, direction string, depth int) (string, error) {
if depth > 8 { if depth > 8 {
return "", errGraphCapacity return "", errGraphCapacity
@@ -98,6 +107,7 @@ func (reader *canvasAIReader) resolve(board, node, handle, direction string, dep
// Follow only real edges and the port chains exposing this node. Empty or // Follow only real edges and the port chains exposing this node. Empty or
// unrelated child boards are never traversed merely because their frame exists. // unrelated child boards are never traversed merely because their frame exists.
// edges 从真实节点沿其祖先暴露端口查入/出边;execution.enabled=false 的边不参与,结果按逻辑边 ID 去重排序。
func (reader *canvasAIReader) edges(board, node string, outgoing bool) ([]canvasAIEdgePlan, error) { func (reader *canvasAIReader) edges(board, node string, outgoing bool) ([]canvasAIEdgePlan, error) {
type exposure struct { type exposure struct {
Board, Node, Handle string Board, Node, Handle string
@@ -161,6 +171,7 @@ func (reader *canvasAIReader) edges(board, node string, outgoing bool) ([]canvas
logical := canvasAIEdgePlan{ID: canvasNodeKey(current.Board, id), Source: source, Target: target} logical := canvasAIEdgePlan{ID: canvasNodeKey(current.Board, id), Source: source, Target: target}
found[logical.ID] = logical found[logical.ID] = logical
} }
// 向上只跟踪暴露当前节点/handle 的端口,不因看见其他 frame 就遍历其孩子。
relation, err := reader.parent(current.Board) relation, err := reader.parent(current.Board)
if err != nil { if err != nil {
return nil, err return nil, err
@@ -194,6 +205,8 @@ func (reader *canvasAIReader) edges(board, node string, outgoing bool) ([]canvas
sort.Slice(result, func(i, j int) bool { return result[i].ID < result[j].ID }) sort.Slice(result, func(i, j int) bool { return result[i].ID < result[j].ID })
return result, nil return result, nil
} }
// plan 每次重置缓存,收集根及可传播节点和其静态前驱,再把实际使用边交给纯拓扑规划器。
func (reader *canvasAIReader) plan(board, node string, propagate bool) (canvasAIPlan, error) { func (reader *canvasAIReader) plan(board, node string, propagate bool) (canvasAIPlan, error) {
reader.snapshots = map[string]canvasSnapshot{} reader.snapshots = map[string]canvasSnapshot{}
reader.documents = map[string]map[string]any{} reader.documents = map[string]map[string]any{}
@@ -235,6 +248,7 @@ func (reader *canvasAIReader) plan(board, node string, propagate bool) (canvasAI
} }
} }
} }
// 保留已读节点数据但裁去无关边,避免纯规划阶段解析未加载或无权限的邻接子图。
filtered := map[string]canvasSnapshot{} filtered := map[string]canvasSnapshot{}
for id, snapshot := range reader.snapshots { for id, snapshot := range reader.snapshots {
doc := reader.documents[id] doc := reader.documents[id]
@@ -255,6 +269,8 @@ func (reader *canvasAIReader) plan(board, node string, propagate bool) (canvasAI
} }
return buildCanvasAIPlan(filtered, board, node, propagate) return buildCanvasAIPlan(filtered, board, node, propagate)
} }
// loadCanvasAIPlan 注入事务内权限检查与持锁快照读取;每个实际读取画布都要求编辑权限。
func loadCanvasAIPlan(r *http.Request, tx *sql.Tx, project, workspace, account string, parent canvasSnapshot, node string, propagate bool) (canvasAIPlan, error) { func loadCanvasAIPlan(r *http.Request, tx *sql.Tx, project, workspace, account string, parent canvasSnapshot, node string, propagate bool) (canvasAIPlan, error) {
reader := canvasAIReader{Load: func(board string) (canvasSnapshot, error) { reader := canvasAIReader{Load: func(board string) (canvasSnapshot, error) {
_, role, err := lockMaterial(r.Context(), tx, project, workspace, board, account) _, role, err := lockMaterial(r.Context(), tx, project, workspace, board, account)
@@ -1,3 +1,4 @@
// 懒读取回归通过注入快照计数 Load,证明范围选择没有隐式扫描无关子树。
package platform package platform
import ( import (
@@ -7,6 +8,7 @@ import (
"testing" "testing"
) )
// readerFromSnapshots 从快照 subgraph 字段建立测试父关系,并给实际 Load 调用计数,不预填 reader 缓存。
func readerFromSnapshots(snapshots map[string]canvasSnapshot, loads map[string]int) *canvasAIReader { func readerFromSnapshots(snapshots map[string]canvasSnapshot, loads map[string]int) *canvasAIReader {
parents := map[string]subgraphRelation{} parents := map[string]subgraphRelation{}
for board, snapshot := range snapshots { for board, snapshot := range snapshots {
@@ -32,6 +34,8 @@ func readerFromSnapshots(snapshots map[string]canvasSnapshot, loads map[string]i
return subgraphRelation{}, sql.ErrNoRows return subgraphRelation{}, sql.ErrNoRows
}} }}
} }
// TestAIReaderDoesNotLoadUnrelatedSubgraphs 在含 499 个无关 frame 的根上运行,传播开/关都只能加载根一次。
func TestAIReaderDoesNotLoadUnrelatedSubgraphs(t *testing.T) { func TestAIReaderDoesNotLoadUnrelatedSubgraphs(t *testing.T) {
nodes := []any{map[string]any{"id": "a", "type": "material", "position": map[string]any{"x": 0, "y": 0}, "data": map[string]any{"kind": "text", "title": "A", "text": "input", "ai": map[string]any{"enabled": true, "modelId": "fixture", "prompt": "transform", "parameters": map[string]any{}}}}} nodes := []any{map[string]any{"id": "a", "type": "material", "position": map[string]any{"x": 0, "y": 0}, "data": map[string]any{"kind": "text", "title": "A", "text": "input", "ai": map[string]any{"enabled": true, "modelId": "fixture", "prompt": "transform", "parameters": map[string]any{}}}}}
for i := 0; i < 499; i++ { for i := 0; i < 499; i++ {
@@ -50,6 +54,8 @@ func TestAIReaderDoesNotLoadUnrelatedSubgraphs(t *testing.T) {
} }
} }
} }
// TestAIReaderResolvesChildOutputAndFrozenPredecessor 从孩子 b 跨父端口传播到 outside,冻结 a 输入,同时不加载空兄弟子图。
func TestAIReaderResolvesChildOutputAndFrozenPredecessor(t *testing.T) { func TestAIReaderResolvesChildOutputAndFrozenPredecessor(t *testing.T) {
raw := memberFixture(t) raw := memberFixture(t)
child := "11111111-1111-4111-8111-111111111111" child := "11111111-1111-4111-8111-111111111111"
+7
View File
@@ -1,3 +1,4 @@
// 可选真实模型回归:只有明确配置专用 worker socket 与隔离数据库才运行,会调用实际文本和图片生成。
package platform package platform
import ( import (
@@ -23,6 +24,8 @@ import (
// Opt in only on the confirmed remote runner with its dedicated CLI worker. // Opt in only on the confirmed remote runner with its dedicated CLI worker.
// Normal CI never invokes a paid/real model as a side effect of unit tests. // Normal CI never invokes a paid/real model as a side effect of unit tests.
// TestCanvasAIRealWorker 选择配对文本/图片模型,走准入、认领、生成写回和授权下载,最后完整解码生成图片。
// 环境变量只是测试开关,执行前仍须确认专用远程 runner 和真实模型调用授权。
func TestCanvasAIRealWorker(t *testing.T) { func TestCanvasAIRealWorker(t *testing.T) {
socket, dsn := os.Getenv("FOUNDRY_REAL_CODEX_SOCKET"), os.Getenv("PLATFORM_TEST_DATABASE_URL") socket, dsn := os.Getenv("FOUNDRY_REAL_CODEX_SOCKET"), os.Getenv("PLATFORM_TEST_DATABASE_URL")
if socket == "" || dsn == "" { if socket == "" || dsn == "" {
@@ -34,6 +37,7 @@ func TestCanvasAIRealWorker(t *testing.T) {
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
// 先选显式已验证图片输出条目,再按去掉 Image 后缀的标签寻找对应文本模型,缺能力直接失败。
var imageModel, textModel codex.CanvasModel var imageModel, textModel codex.CanvasModel
for _, model := range models { for _, model := range models {
if model.Available && canvasModelSupports(model, "image") { if model.Available && canvasModelSupports(model, "image") {
@@ -119,6 +123,7 @@ func TestCanvasAIRealWorker(t *testing.T) {
} }
return result return result
} }
// 手动认领指定 run,避免后台轮询干扰;数据库必须隔离,否则最早队列任务可能不是本用例。
execute := func(id string) { execute := func(id string) {
t.Helper() t.Helper()
run, err := s.claimCanvasRun(ctx) run, err := s.claimCanvasRun(ctx)
@@ -132,6 +137,7 @@ func TestCanvasAIRealWorker(t *testing.T) {
t.Fatalf("real worker run %s: %s", result["status"], encoded) t.Fatalf("real worker run %s: %s", result["status"], encoded)
} }
} }
// 文本用例只检查标记包含及原几何保留,不把模型自然语言差异当作精确输出契约。
textRun := call("POST", base+"/ai/runs", response{"node_id": "a", "model_id": textModel.ID, "prompt": "Return exactly the text CANVAS_V2_OK", "parameters": response{}, "propagate": false}, 202, 1, "20000000-0000-4000-8000-000000000001") textRun := call("POST", base+"/ai/runs", response{"node_id": "a", "model_id": textModel.ID, "prompt": "Return exactly the text CANVAS_V2_OK", "parameters": response{}, "propagate": false}, 202, 1, "20000000-0000-4000-8000-000000000001")
execute(textRun["run_id"].(string)) execute(textRun["run_id"].(string))
textSaved := call("GET", base, nil, 200, 0, "") textSaved := call("GET", base, nil, 200, 0, "")
@@ -146,6 +152,7 @@ func TestCanvasAIRealWorker(t *testing.T) {
} }
doc["nodes"] = append(doc["nodes"].([]any), response{"id": "real-image", "type": "plainImage", "position": response{"x": 40, "y": 50}, "width": 240, "height": 160, "data": response{"kind": "plain-image", "title": "Real image", "text": "", "src": "data:image/png;base64," + base64.StdEncoding.EncodeToString(input.Bytes())}}) doc["nodes"] = append(doc["nodes"].([]any), response{"id": "real-image", "type": "plainImage", "position": response{"x": 40, "y": 50}, "width": 240, "height": 160, "data": response{"kind": "plain-image", "title": "Real image", "text": "", "src": "data:image/png;base64," + base64.StdEncoding.EncodeToString(input.Bytes())}})
call("PATCH", base, response{"document": doc}, 200, 3, "") call("PATCH", base, response{"document": doc}, 200, 3, "")
// 图片结果必须成为托管资产,保留节点显示尺寸;实际原图尺寸/格式由下载后的完整解码验证。
imageRun := call("POST", base+"/ai/runs", response{"node_id": "real-image", "model_id": imageModel.ID, "prompt": "Generate one image: a solid blue circle centered on a white square background, no text.", "parameters": response{}, "propagate": false}, 202, 4, "20000000-0000-4000-8000-000000000002") imageRun := call("POST", base+"/ai/runs", response{"node_id": "real-image", "model_id": imageModel.ID, "prompt": "Generate one image: a solid blue circle centered on a white square background, no text.", "parameters": response{}, "propagate": false}, 202, 4, "20000000-0000-4000-8000-000000000002")
execute(imageRun["run_id"].(string)) execute(imageRun["run_id"].(string))
saved := call("GET", base, nil, 200, 0, "") saved := call("GET", base, nil, 200, 0, "")
+94
View File
@@ -0,0 +1,94 @@
// AI 变更回执协议:在工作区锁内以 savepoint 隔离副作用,确定拒绝也冻结同一请求身份。
package platform
import (
"database/sql"
"encoding/json"
"net/http"
)
// canvasAIRequest 绑定请求键、逻辑操作、动作、来源画布和可选 run,Hash 固定原始有效载荷。
type canvasAIRequest struct {
Key, Hash, Action, Board, Run, Operation string
}
// The workspace lock is acquired by the caller before this savepoint. Rejected
// requests roll back every staged effect and retain that lock while recording
// their zero-effect receipt, so a response can never race a second invocation.
// beginCanvasAIRequest 先重放同请求或拒绝身份复用,再查已应用逻辑操作,最后建立副作用 savepoint。
// 调用方必须先取得工作区锁;返回 true 表示已响应,nil request 兼容旧协议且不建立 savepoint。
func beginCanvasAIRequest(w http.ResponseWriter, r *http.Request, tx *sql.Tx, project, workspace, account string, request *canvasAIRequest) (bool, error) {
if request == nil {
return false, nil
}
var board, run, action, hash string
var status int
var body json.RawMessage
err := tx.QueryRowContext(r.Context(), `SELECT board_id::text,COALESCE(run_id::text,''),action,payload_hash,response_status,response_body FROM canvas_ai_requests WHERE project=$1 AND workspace_id=$2 AND account_id=$3 AND request_id=$4`, project, workspace, account, request.Key).Scan(&board, &run, &action, &hash, &status, &body)
if err == nil {
if board != request.Board || run != request.Run || action != request.Action || hash != request.Hash {
reject(w, 409, "idempotency_conflict")
return true, nil
}
reply(w, status, body)
return true, nil
}
if err != sql.ErrNoRows {
return false, err
}
var completed bool
err = tx.QueryRowContext(r.Context(), `SELECT EXISTS(SELECT 1 FROM canvas_ai_requests WHERE project=$1 AND workspace_id=$2 AND account_id=$3 AND operation_id=$4 AND outcome='applied')`, project, workspace, account, request.Operation).Scan(&completed)
if err != nil {
return false, err
}
if completed {
reject(w, 409, "operation_identity_conflict")
return true, nil
}
_, err = tx.ExecContext(r.Context(), `SAVEPOINT canvas_ai_effects`)
return false, err
}
// bindCanvasAIReceipt 将协议/请求/操作/动作身份写入公开回执,旧协议 nil request 不改响应。
func bindCanvasAIReceipt(body response, request *canvasAIRequest) {
if request == nil {
return
}
body["protocol_version"], body["request_id"], body["operation_id"], body["action"] = 2, request.Key, request.Operation, request.Action
if request.Run != "" {
body["run_id"] = request.Run
}
}
// commitCanvasAIReceipt 把冻结结果与业务副作用一起提交;数据库提交成功后才确认给客户端。
func commitCanvasAIReceipt(w http.ResponseWriter, r *http.Request, tx *sql.Tx, project, workspace, account string, request *canvasAIRequest, status int, outcome string, body response) error {
if request != nil {
bindCanvasAIReceipt(body, request)
raw, err := json.Marshal(body)
if err != nil {
return err
}
_, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_ai_requests(project,workspace_id,account_id,request_id,board_id,run_id,action,operation_id,payload_hash,outcome,response_status,response_body) VALUES($1,$2,$3,$4,$5,NULLIF($6,'')::uuid,$7,$8,$9,$10,$11,$12)`, project, workspace, account, request.Key, request.Board, request.Run, request.Action, request.Operation, request.Hash, outcome, status, raw)
if err != nil {
return err
}
}
if err := tx.Commit(); err != nil {
return err
}
reply(w, status, body)
return nil
}
// rejectCanvasAIRequest 回滚 savepoint 后的全部副作用,再保留工作区锁写 terminal not-applied 回执。
// 旧协议没有回执时只响应拒绝,由外层 defer 回滚整个事务。
func rejectCanvasAIRequest(w http.ResponseWriter, r *http.Request, tx *sql.Tx, project, workspace, account string, request *canvasAIRequest, status int, code string) error {
if request == nil {
reject(w, status, code)
return nil
}
if _, err := tx.ExecContext(r.Context(), `ROLLBACK TO SAVEPOINT canvas_ai_effects`); err != nil {
return err
}
return commitCanvasAIReceipt(w, r, tx, project, workspace, account, request, status, "not-applied", response{"status": "not-applied", "terminal": true, "error": code})
}
+4
View File
@@ -1,3 +1,4 @@
// 仅 worker 明确未开始执行的忙碌准入可持久回队;已完成步骤结果保留供恢复后继续。
package platform package platform
import ( import (
@@ -6,6 +7,7 @@ import (
"encoding/json" "encoding/json"
) )
// canvasRunResults 读取非 queued 终态与文本/资产输出;遇仍 running 步骤拒绝恢复,避免重复调用未定执行。
func (s *service) canvasRunResults(ctx context.Context, run canvasQueueRun) (map[string]canvasStepResult, error) { func (s *service) canvasRunResults(ctx context.Context, run canvasQueueRun) (map[string]canvasStepResult, error) {
rows, err := s.db.QueryContext(ctx, `SELECT id,status,output FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND run_id=$3 ORDER BY ordinal`, run.Project, run.Workspace, run.ID) rows, err := s.db.QueryContext(ctx, `SELECT id,status,output FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND run_id=$3 ORDER BY ordinal`, run.Project, run.Workspace, run.ID)
if err != nil { if err != nil {
@@ -41,6 +43,8 @@ func (s *service) canvasRunResults(ctx context.Context, run canvasQueueRun) (map
// A 429 codex_busy response proves the worker did not invoke the CLI. Only this // A 429 codex_busy response proves the worker did not invoke the CLI. Only this
// admission failure can return a step to the persistent queue for safe retry. // admission failure can return a step to the persistent queue for safe retry.
// requeueCanvasStep 核对当前 run 租约和取消位,将唯一 running 步退回 queued,并把 run 延迟五秒可认领。
// 返回 true 表示已提交回队,外层必须结束当前执行;旧结果和逻辑身份不会重建。
func (s *service) requeueCanvasStep(ctx context.Context, run canvasQueueRun, step canvasAIStepPlan) (bool, error) { func (s *service) requeueCanvasStep(ctx context.Context, run canvasQueueRun, step canvasAIStepPlan) (bool, error) {
tx, err := s.db.BeginTx(ctx, nil) tx, err := s.db.BeginTx(ctx, nil)
if err != nil { if err != nil {
+113 -59
View File
@@ -1,3 +1,4 @@
// AI run 准入入口:冻结依赖和输入、验证模型及队列预算,再原子保存配置、run、steps、事件和回执。
package platform package platform
import ( import (
@@ -15,6 +16,7 @@ import (
"gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex" "gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex"
) )
// appendAIEvent 用单条 SQL 原子递增 run.last_seq 并插入事件,序号与业务状态一起提交。
func appendAIEvent(rctx context.Context, tx *sql.Tx, project, workspace, run, kind string, data any) error { func appendAIEvent(rctx context.Context, tx *sql.Tx, project, workspace, run, kind string, data any) error {
raw, err := json.Marshal(data) raw, err := json.Marshal(data)
if err != nil { if err != nil {
@@ -23,6 +25,8 @@ func appendAIEvent(rctx context.Context, tx *sql.Tx, project, workspace, run, ki
_, err = tx.ExecContext(rctx, `WITH next AS (UPDATE canvas_ai_runs SET last_seq=last_seq+1 WHERE project=$1 AND workspace_id=$2 AND id=$3 RETURNING last_seq) INSERT INTO canvas_ai_events(project,workspace_id,run_id,seq,type,data) SELECT $1,$2,$3,last_seq,$4,$5 FROM next`, project, workspace, run, kind, raw) _, err = tx.ExecContext(rctx, `WITH next AS (UPDATE canvas_ai_runs SET last_seq=last_seq+1 WHERE project=$1 AND workspace_id=$2 AND id=$3 RETURNING last_seq) INSERT INTO canvas_ai_events(project,workspace_id,run_id,seq,type,data) SELECT $1,$2,$3,last_seq,$4,$5 FROM next`, project, workspace, run, kind, raw)
return err return err
} }
// createCanvasAIRun 接受旧快照协议或 canonical v2;先按原请求身份恢复结果,后续确定拒绝可冻结零效果回执。
func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodPost { if r.Method != http.MethodPost {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -47,11 +51,16 @@ func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
return nil return nil
} }
var input struct { var input struct {
NodeID string `json:"node_id"` ProtocolVersion int `json:"protocol_version,omitempty"`
ModelID string `json:"model_id"` OperationID string `json:"operation_id,omitempty"`
Prompt string `json:"prompt"` RequestID string `json:"request_id,omitempty"`
Parameters map[string]any `json:"parameters"` TargetIncarnation int64 `json:"target_incarnation,omitempty"`
Propagate bool `json:"propagate"` ExpectedVersions map[string]int64 `json:"expected_versions,omitempty"`
NodeID string `json:"node_id"`
ModelID string `json:"model_id"`
Prompt string `json:"prompt"`
Parameters map[string]any `json:"parameters"`
Propagate bool `json:"propagate"`
} }
decoder := json.NewDecoder(bytes.NewReader(raw)) decoder := json.NewDecoder(bytes.NewReader(raw))
decoder.DisallowUnknownFields() decoder.DisallowUnknownFields()
@@ -59,6 +68,10 @@ func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
reject(w, 400, "invalid_ai_request") reject(w, 400, "invalid_ai_request")
return nil return nil
} }
if input.OperationID != "" && !uuidSlugPattern.MatchString(input.OperationID) {
reject(w, 400, "invalid_ai_request")
return nil
}
if input.Parameters == nil { if input.Parameters == nil {
input.Parameters = map[string]any{} input.Parameters = map[string]any{}
} }
@@ -67,7 +80,12 @@ func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
reject(w, 413, "context_too_large") reject(w, 413, "context_too_large")
return nil return nil
} }
// v2 的 If-Match 也是不可变请求的一部分,不能只换版本头重用原始准入键。
hash := payloadDigest(input) hash := payloadDigest(input)
if input.ProtocolVersion != 0 {
// The version header is part of the immutable canonical admission request.
hash = payloadDigest(response{"input": input, "if_match": expected})
}
workspace, board := r.PathValue("workspace"), r.PathValue("material") workspace, board := r.PathValue("workspace"), r.PathValue("material")
tx, err := s.db.BeginTx(r.Context(), nil) tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil { if err != nil {
@@ -78,13 +96,22 @@ func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
if err != nil { if err != nil {
return err return err
} }
// 只有完整 v2 请求身份才建立副作用 savepoint;旧请求沿用原 run.create_response 幂等路径。
var receipt *canvasAIRequest
if input.ProtocolVersion == 2 && input.RequestID == key && uuidSlugPattern.MatchString(input.OperationID) && input.TargetIncarnation > 0 {
receipt = &canvasAIRequest{Key: key, Hash: hash, Action: "run.start", Board: board, Operation: input.OperationID}
if done, e := beginCanvasAIRequest(w, r, tx, project, workspace, account, receipt); done || e != nil {
return e
}
}
rejectRequest := func(status int, code string) error {
return rejectCanvasAIRequest(w, r, tx, project, workspace, account, receipt, status, code)
}
if kind != "board" { if kind != "board" {
reject(w, 400, "invalid_material") return rejectRequest(400, "invalid_material")
return nil
} }
if role == "viewer" { if role == "viewer" {
reject(w, 403, "forbidden") return rejectRequest(403, "forbidden")
return nil
} }
var previousHash string var previousHash string
var previous json.RawMessage var previous json.RawMessage
@@ -105,13 +132,22 @@ func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
if err != sql.ErrNoRows { if err != sql.ErrNoRows {
return err return err
} }
if input.OperationID != "" {
var admitted bool
if err = tx.QueryRowContext(r.Context(), `SELECT EXISTS(SELECT 1 FROM canvas_ai_runs WHERE project=$1 AND workspace_id=$2 AND account_id=$3 AND logical_operation_id=$4)`, project, workspace, account, input.OperationID).Scan(&admitted); err != nil {
return err
}
if admitted {
reject(w, 409, "operation_identity_conflict")
return nil
}
}
parent, err := loadCanvas(r, tx, project, workspace, board) parent, err := loadCanvas(r, tx, project, workspace, board)
if err != nil { if err != nil {
return err return err
} }
if parent.Version != expected { if parent.Version != expected {
reject(w, 412, "version_conflict") return rejectRequest(412, "version_conflict")
return nil
} }
var doc map[string]any var doc map[string]any
_ = json.Unmarshal(parent.Document, &doc) _ = json.Unmarshal(parent.Document, &doc)
@@ -123,49 +159,70 @@ func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
} }
} }
if target == nil { if target == nil {
reject(w, 404, "not_found") return rejectRequest(404, "not_found")
return nil
} }
if !canvasChoice(target["kind"], "text", "script", "plain-text", "image", "plain-image") { if !canvasChoice(target["kind"], "text", "script", "plain-text", "image", "plain-image") {
reject(w, 422, "model_incompatible") return rejectRequest(422, "model_incompatible")
return nil
} }
target["ai"] = map[string]any{"enabled": true, "modelId": input.ModelID, "prompt": input.Prompt, "parameters": input.Parameters, "propagate": input.Propagate} // canonical 目标必须显式提供当前 incarnation,旧树请求不能夹带 canonical 字段越过迁移屏障。
doc["schema_version"] = 2 root, incarnation, _, err := canvasAIIdentity(r.Context(), tx, project, workspace, board, input.NodeID)
encoded, _ := json.Marshal(doc) if err != nil {
normalized, ok := normalizeCanvas(encoded) return err
if !ok { }
reject(w, 400, "invalid_ai_request") if root != "" {
return nil if input.ProtocolVersion != 2 || input.RequestID != key || !uuidSlugPattern.MatchString(input.OperationID) || input.TargetIncarnation < 1 {
return rejectRequest(400, "invalid_ai_protocol")
}
if input.TargetIncarnation != incarnation {
return rejectRequest(409, "target_changed")
}
} else if input.ProtocolVersion != 0 || input.RequestID != "" || input.TargetIncarnation != 0 || input.OperationID != "" || input.ExpectedVersions != nil {
return rejectRequest(409, "canonical_migration_required")
}
// 先在内存准备目标 AI 配置;所有规划与预算检查通过后才随 run 一起落库,拒绝不能泄漏配置更新。
change, err := prepareCanvasAIPatch(r, tx, project, workspace, parent, input.NodeID, response{"ai": map[string]any{"enabled": true, "modelId": input.ModelID, "prompt": input.Prompt, "parameters": input.Parameters, "propagate": input.Propagate}})
if err != nil {
return rejectRequest(400, "invalid_ai_request")
}
if change.Before != nil {
if code := validateCanvasAIVersions(*change.Before, board, expected, input.ExpectedVersions); code != "" {
status := http.StatusBadRequest
if code == "version_conflict" {
status = http.StatusPreconditionFailed
}
return rejectRequest(status, code)
}
} }
ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second) ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
defer cancel() defer cancel()
models, err := s.canvasAI.Models(ctx) models, err := s.canvasAI.Models(ctx)
if err != nil { if err != nil {
reject(w, 503, "codex_unavailable") return rejectRequest(503, "codex_unavailable")
return nil
} }
catalogue := map[string]codex.CanvasModel{} catalogue := map[string]codex.CanvasModel{}
for _, model := range models { for _, model := range models {
catalogue[model.ID] = model catalogue[model.ID] = model
} }
parent.Document = normalized parent = change.Snapshot
parent.Version++
plan, err := loadCanvasAIPlan(r, tx, project, workspace, account, parent, input.NodeID, input.Propagate) plan, err := loadCanvasAIPlan(r, tx, project, workspace, account, parent, input.NodeID, input.Propagate)
if err != nil { if err != nil {
if err.Error() == "execution_cycle" { if err.Error() == "execution_cycle" {
reject(w, 409, "execution_cycle") return rejectRequest(409, "execution_cycle")
} else { } else {
reject(w, 413, "graph_limit_exceeded") return rejectRequest(413, "graph_limit_exceeded")
} }
return nil
} }
if err = bindCanvasAIIdentities(r.Context(), tx, project, workspace, &plan); err != nil {
return err
}
// 规划结果绑定稳定目标身份后,再验证每步输出模态和所有静态/动态图片来源是否被所选模型支持。
stepKinds := map[string]string{} stepKinds := map[string]string{}
for _, step := range plan.Steps { for _, step := range plan.Steps {
stepKinds[step.ID] = step.Kind stepKinds[step.ID] = step.Kind
} }
freezeCtx, stopFreeze := context.WithTimeout(r.Context(), 10*time.Second) freezeCtx, stopFreeze := context.WithTimeout(r.Context(), 10*time.Second)
defer stopFreeze() defer stopFreeze()
// 同一来源图片只冻结一次,十秒总上下文限制外部抓取;入队后不再依赖可变化远程 URL。
frozenImages := map[string]map[string]any{} frozenImages := map[string]map[string]any{}
for index, step := range plan.Steps { for index, step := range plan.Steps {
if step.Status == "skipped" { if step.Status == "skipped" {
@@ -173,16 +230,14 @@ func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
} }
model, exists := catalogue[step.ModelID] model, exists := catalogue[step.ModelID]
if !exists || !model.Available { if !exists || !model.Available {
reject(w, 422, "model_unavailable") return rejectRequest(422, "model_unavailable")
return nil
} }
modality := "text" modality := "text"
if canvasChoice(step.Kind, "image", "plain-image") { if canvasChoice(step.Kind, "image", "plain-image") {
modality = "image" modality = "image"
} }
if !canvasModelSupports(model, modality) { if !canvasModelSupports(model, modality) {
reject(w, 422, "model_incompatible") return rejectRequest(422, "model_incompatible")
return nil
} }
imageSources := map[string]bool{} imageSources := map[string]bool{}
if canvasChoice(step.Kind, "image", "plain-image") { if canvasChoice(step.Kind, "image", "plain-image") {
@@ -199,12 +254,10 @@ func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
} }
} }
if len(imageSources) > 0 && !canvasModelAccepts(model, "image") { if len(imageSources) > 0 && !canvasModelAccepts(model, "image") {
reject(w, 422, "model_incompatible") return rejectRequest(422, "model_incompatible")
return nil
} }
if len(imageSources) > 4 { if len(imageSources) > 4 {
reject(w, 413, "context_too_large") return rejectRequest(413, "context_too_large")
return nil
} }
plan.Steps[index].MaxExecutionMS = model.MaxExecutionMS plan.Steps[index].MaxExecutionMS = model.MaxExecutionMS
if canvasChoice(step.Kind, "image", "plain-image") { if canvasChoice(step.Kind, "image", "plain-image") {
@@ -215,8 +268,7 @@ func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
frozenImages[step.ID] = content frozenImages[step.ID] = content
} }
if e != nil { if e != nil {
reject(w, 422, "model_incompatible") return rejectRequest(422, "model_incompatible")
return nil
} }
plan.Steps[index].FrozenContent = content plan.Steps[index].FrozenContent = content
} }
@@ -233,38 +285,39 @@ func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
frozenImages[key] = content frozenImages[key] = content
} }
if e != nil { if e != nil {
reject(w, 422, "model_incompatible") return rejectRequest(422, "model_incompatible")
return nil
} }
plan.Steps[index].StaticInputs[staticIndex].Content = content plan.Steps[index].StaticInputs[staticIndex].Content = content
} }
if _, e := assembleCanvasTask(plan, plan.Steps[index], nil); e != nil { if _, e := assembleCanvasTask(plan, plan.Steps[index], nil); e != nil {
reject(w, 413, "context_too_large") return rejectRequest(413, "context_too_large")
return nil
} }
parameters, _ := step.Config["parameters"].(map[string]any) parameters, _ := step.Config["parameters"].(map[string]any)
if len(parameters) > 0 { if len(parameters) > 0 {
reject(w, 400, "invalid_ai_request") return rejectRequest(400, "invalid_ai_request")
return nil
} }
prompt, _ := step.Config["prompt"].(string) prompt, _ := step.Config["prompt"].(string)
text, _ := step.FrozenContent["text"].(string) text, _ := step.FrozenContent["text"].(string)
if len(prompt)+len(text) > model.MaxInputBytes { if len(prompt)+len(text) > model.MaxInputBytes {
reject(w, 413, "context_too_large") return rejectRequest(413, "context_too_large")
return nil
} }
// canonical 忙碌检查按根/稳定 ID/incarnation,owner 移动不能绕过同一目标的在途任务约束。
var busy bool var busy bool
err = tx.QueryRowContext(r.Context(), `SELECT EXISTS(SELECT 1 FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND board_id=$3 AND node_id=$4 AND status IN('queued','running'))`, project, workspace, step.BoardID, step.NodeID).Scan(&busy) if step.CanonicalRoot != "" {
err = tx.QueryRowContext(r.Context(), `SELECT EXISTS(SELECT 1 FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND frozen_input->>'canonical_root'=$3 AND node_id=$4 AND frozen_input->>'target_incarnation'=$5::bigint::text AND status IN('queued','running'))`, project, workspace, step.CanonicalRoot, step.NodeID, step.TargetIncarnation).Scan(&busy)
} else {
err = tx.QueryRowContext(r.Context(), `SELECT EXISTS(SELECT 1 FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND board_id=$3 AND node_id=$4 AND status IN('queued','running'))`, project, workspace, step.BoardID, step.NodeID).Scan(&busy)
}
if err != nil { if err != nil {
return err return err
} }
if busy { if busy {
reject(w, 409, "node_busy") return rejectRequest(409, "node_busy")
return nil
} }
} }
// A project-scoped advisory lock makes the queue limit atomic across workspaces. // A project-scoped advisory lock makes the queue limit atomic across workspaces.
// 项目级事务锁跨工作区串行化队列计数与插入,防止多个工作区同时越过 128 活跃 run 上限。
_, err = tx.ExecContext(r.Context(), `SELECT pg_advisory_xact_lock(hashtextextended($1,0))`, project+"/canvas-ai-queue") _, err = tx.ExecContext(r.Context(), `SELECT pg_advisory_xact_lock(hashtextextended($1,0))`, project+"/canvas-ai-queue")
if err != nil { if err != nil {
return err return err
@@ -276,8 +329,7 @@ func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
} }
if queued >= 128 { if queued >= 128 {
w.Header().Set("Retry-After", "5") w.Header().Set("Retry-After", "5")
reject(w, 429, "queue_full") return rejectRequest(429, "queue_full")
return nil
} }
var id string var id string
err = tx.QueryRowContext(r.Context(), `SELECT gen_random_uuid()::text`).Scan(&id) err = tx.QueryRowContext(r.Context(), `SELECT gen_random_uuid()::text`).Scan(&id)
@@ -287,17 +339,23 @@ func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
planJSON, _ := json.Marshal(plan) planJSON, _ := json.Marshal(plan)
poll := "/projects/" + url.PathEscape(project) + "/workspaces/" + workspace + "/materials/" + board + "/canvas/ai/runs/" + id poll := "/projects/" + url.PathEscape(project) + "/workspaces/" + workspace + "/materials/" + board + "/canvas/ai/runs/" + id
result := response{"run_id": id, "status": "queued", "poll_url": poll, "plan": publicAIPlan(plan), "canvas_version": parent.Version} result := response{"run_id": id, "status": "queued", "poll_url": poll, "plan": publicAIPlan(plan), "canvas_version": parent.Version}
if root != "" {
result["protocol_version"], result["request_id"], result["admission"], result["operation_id"] = 2, key, "accepted", input.OperationID
change.addCanonical(result)
}
bindCanvasAIReceipt(result, receipt)
resultJSON, _ := json.Marshal(result) resultJSON, _ := json.Marshal(result)
_, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_ai_runs(project,workspace_id,board_id,id,account_id,idempotency_key,payload_hash,status,plan,create_response) VALUES($1,$2,$3,$4,$5,$6,$7,'queued',$8,$9)`, project, workspace, board, id, account, key, hash, planJSON, resultJSON) _, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_ai_runs(project,workspace_id,board_id,id,account_id,idempotency_key,payload_hash,status,plan,create_response,logical_operation_id) VALUES($1,$2,$3,$4,$5,$6,$7,'queued',$8,$9,NULLIF($10,'')::uuid)`, project, workspace, board, id, account, key, hash, planJSON, resultJSON, input.OperationID)
if err != nil { if err != nil {
return err return err
} }
if err = s.saveCanvas(r, tx, project, workspace, parent); err != nil { if err = s.saveCanvasAIChange(r, tx, project, workspace, account, change); err != nil {
return err return err
} }
if err = appendAIEvent(r.Context(), tx, project, workspace, id, "run.queued", response{"status": "queued"}); err != nil { if err = appendAIEvent(r.Context(), tx, project, workspace, id, "run.queued", response{"status": "queued"}); err != nil {
return err return err
} }
// 拓扑顺序作为 ordinal 持久化;skipped 步也保存状态和初始事件,使查询能解释未执行原因。
for ordinal, step := range plan.Steps { for ordinal, step := range plan.Steps {
frozen, _ := json.Marshal(step) frozen, _ := json.Marshal(step)
_, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_ai_steps(project,workspace_id,run_id,id,board_id,node_id,ordinal,status,model_id,frozen_input,target_fingerprint) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)`, project, workspace, id, step.ID, step.BoardID, step.NodeID, ordinal, step.Status, step.ModelID, frozen, step.Fingerprint) _, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_ai_steps(project,workspace_id,run_id,id,board_id,node_id,ordinal,status,model_id,frozen_input,target_fingerprint) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)`, project, workspace, id, step.ID, step.BoardID, step.NodeID, ordinal, step.Status, step.ModelID, frozen, step.Fingerprint)
@@ -308,10 +366,6 @@ func (s *service) createCanvasAIRun(w http.ResponseWriter, r *http.Request, proj
return err return err
} }
} }
if err = tx.Commit(); err != nil {
return err
}
setVersion(w, parent.Version) setVersion(w, parent.Version)
reply(w, 202, result) return commitCanvasAIReceipt(w, r, tx, project, workspace, account, receipt, 202, "applied", result)
return nil
} }
+23
View File
@@ -1,3 +1,4 @@
// 持久 AI 队列:跨 Core 实例串行认领、租约恢复、按冻结拓扑执行,并把结果交事务写回器。
package platform package platform
import ( import (
@@ -12,15 +13,20 @@ import (
"gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex" "gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex"
) )
// canvasQueueRun 保存本轮认领租约,后续状态写入必须匹配 Lease,旧执行者不能冒充新认领者。
type canvasQueueRun struct { type canvasQueueRun struct {
Project, Workspace, Board, ID, Account, Lease string Project, Workspace, Board, ID, Account, Lease string
Plan canvasAIPlan Plan canvasAIPlan
} }
// canvasStepResult 在调度进程内保存终态及可传给后继的文本/资产 ID,Output 承载 worker 的结构化生成结果。
type canvasStepResult struct { type canvasStepResult struct {
Status, Text, AssetID string Status, Text, AssetID string
Output codex.CanvasOutput Output codex.CanvasOutput
} }
// runCanvasQueue 每秒尝试取得专用连接的 session advisory lock,持锁期间最多执行一个完整 run。
// 此锁与事务锁不同,需在同一连接显式释放,再将连接归还池。
func (s *service) runCanvasQueue(ctx context.Context) { func (s *service) runCanvasQueue(ctx context.Context) {
ticker := time.NewTicker(time.Second) ticker := time.NewTicker(time.Second)
defer ticker.Stop() defer ticker.Stop()
@@ -48,6 +54,8 @@ func (s *service) runCanvasQueue(ctx context.Context) {
conn.Close() conn.Close()
} }
} }
// claimCanvasRun 先恢复过期租约,再用 SKIP LOCKED 选最早可用 run,原子设 running、租约并记录事件。
func (s *service) claimCanvasRun(ctx context.Context) (*canvasQueueRun, error) { func (s *service) claimCanvasRun(ctx context.Context) (*canvasQueueRun, error) {
if err := s.recoverCanvasRuns(ctx); err != nil { if err := s.recoverCanvasRuns(ctx); err != nil {
return nil, err return nil, err
@@ -81,6 +89,9 @@ func (s *service) claimCanvasRun(ctx context.Context) (*canvasQueueRun, error) {
} }
return &run, nil return &run, nil
} }
// recoverCanvasRuns 对已过期 running 租约逐个加锁重查,运行中步骤失败、未开始步骤跳过,不自动重付费执行。
// 已有成功步骤则 run 标为 partially_succeeded,否则 failed,并补齐终态事件。
func (s *service) recoverCanvasRuns(ctx context.Context) error { func (s *service) recoverCanvasRuns(ctx context.Context) error {
rows, err := s.db.QueryContext(ctx, `SELECT project,workspace_id::text,id::text FROM canvas_ai_runs WHERE status='running' AND lease_until<now()`) rows, err := s.db.QueryContext(ctx, `SELECT project,workspace_id::text,id::text FROM canvas_ai_runs WHERE status='running' AND lease_until<now()`)
if err != nil { if err != nil {
@@ -188,6 +199,8 @@ func (s *service) recoverCanvasRuns(ctx context.Context) error {
} }
return nil return nil
} }
// executeCanvasRun 复用持久终态结果,按计划拓扑顺序逐步执行;前驱非成功则跳过依赖步骤。
func (s *service) executeCanvasRun(ctx context.Context, run canvasQueueRun) { func (s *service) executeCanvasRun(ctx context.Context, run canvasQueueRun) {
results, err := s.canvasRunResults(ctx, run) results, err := s.canvasRunResults(ctx, run)
if err != nil { if err != nil {
@@ -224,6 +237,7 @@ func (s *service) executeCanvasRun(ctx context.Context, run canvasQueueRun) {
results[step.ID] = canvasStepResult{Status: status} results[step.ID] = canvasStepResult{Status: status}
continue continue
} }
// 先从冻结引用装入图片并重查权限,再将步骤从 queued 改为 running,之后才调用真实生成。
if err = s.hydrateCanvasTask(ctx, run, step, results, &task); err != nil { if err = s.hydrateCanvasTask(ctx, run, step, results, &task); err != nil {
code := "model_incompatible" code := "model_incompatible"
if err.Error() == "context_too_large" { if err.Error() == "context_too_large" {
@@ -245,6 +259,7 @@ func (s *service) executeCanvasRun(ctx context.Context, run canvasQueueRun) {
continue continue
} }
generated, generationErr := s.generateCanvasStep(ctx, run, step, task) generated, generationErr := s.generateCanvasStep(ctx, run, step, task)
// 只有明确未进入 CLI 的忙碌结果可安全回队;网络超时/中断不证明没有执行,不能盲重试。
if generationErr != nil && generationErr.Error() == "codex_busy" { if generationErr != nil && generationErr.Error() == "codex_busy" {
requeued, e := s.requeueCanvasStep(ctx, run, step) requeued, e := s.requeueCanvasStep(ctx, run, step)
if e != nil || requeued { if e != nil || requeued {
@@ -270,6 +285,7 @@ func (s *service) executeCanvasRun(ctx context.Context, run canvasQueueRun) {
code = "generation_failed" code = "generation_failed"
} }
} }
// 输出格式与文本预算检查后再持锁写回;返回状态决定后继能否消费本次输出。
status, err := s.finishCanvasStepOutput(ctx, run, step, generated, code, true) status, err := s.finishCanvasStepOutput(ctx, run, step, generated, code, true)
if err != nil { if err != nil {
return return
@@ -284,6 +300,8 @@ func (s *service) executeCanvasRun(ctx context.Context, run canvasQueueRun) {
} }
_ = s.completeCanvasRun(ctx, run, results) _ = s.completeCanvasRun(ctx, run, results)
} }
// assembleCanvasTask 按计划边顺序合并成功上游结果、静态输入和当前冻结内容,整体 JSON 与最终前缀提示都检查预算。
func assembleCanvasTask(plan canvasAIPlan, step canvasAIStepPlan, results map[string]canvasStepResult) (codex.CanvasTask, error) { func assembleCanvasTask(plan canvasAIPlan, step canvasAIStepPlan, results map[string]canvasStepResult) (codex.CanvasTask, error) {
incoming := []any{} incoming := []any{}
for _, edge := range plan.Edges { for _, edge := range plan.Edges {
@@ -318,6 +336,8 @@ func assembleCanvasTask(plan canvasAIPlan, step canvasAIStepPlan, results map[st
} }
return task, nil return task, nil
} }
// generateCanvasStep 限制模型调用时长,每秒心跳续租并确认 run/step 仍活跃;撤销或丢租约时取消 IPC。
func (s *service) generateCanvasStep(ctx context.Context, run canvasQueueRun, step canvasAIStepPlan, task codex.CanvasTask) (codex.CanvasOutput, error) { func (s *service) generateCanvasStep(ctx context.Context, run canvasQueueRun, step canvasAIStepPlan, task codex.CanvasTask) (codex.CanvasOutput, error) {
duration := 90 * time.Second duration := 90 * time.Second
if step.MaxExecutionMS > 0 && step.MaxExecutionMS <= 180000 { if step.MaxExecutionMS > 0 && step.MaxExecutionMS <= 180000 {
@@ -325,6 +345,7 @@ func (s *service) generateCanvasStep(ctx context.Context, run canvasQueueRun, st
} }
callCtx, cancel := context.WithTimeout(ctx, duration) callCtx, cancel := context.WithTimeout(ctx, duration)
defer cancel() defer cancel()
// 缓冲一项保证主循环因取消提前返回后,调用 goroutine 仍能发送收尾结果而不永久阻塞。
done := make(chan canvasStepResult, 1) done := make(chan canvasStepResult, 1)
go func() { go func() {
output, err := s.canvasAI.GenerateOutput(callCtx, task) output, err := s.canvasAI.GenerateOutput(callCtx, task)
@@ -356,4 +377,6 @@ func (s *service) generateCanvasStep(ctx context.Context, run canvasQueueRun, st
} }
} }
} }
// queueRequest 为共用 HTTP 风格数据库辅助函数创建仅含 context 的请求,不用于公开路由解析。
func queueRequest(ctx context.Context) *http.Request { return (&http.Request{}).WithContext(ctx) } func queueRequest(ctx context.Context) *http.Request { return (&http.Request{}).WithContext(ctx) }
@@ -1,3 +1,4 @@
// 调度器任务组装纯回归,不启动队列、数据库或真实 CLI。
package platform package platform
import ( import (
@@ -5,6 +6,7 @@ import (
"testing" "testing"
) )
// TestCanvasTaskUsesStableIncomingEdgeOrderAndFrozenContent 验证冻结正文与两条有序前驱输出进入提示,组装后超过上下文字节限额必须报错。
func TestCanvasTaskUsesStableIncomingEdgeOrderAndFrozenContent(t *testing.T) { func TestCanvasTaskUsesStableIncomingEdgeOrderAndFrozenContent(t *testing.T) {
step := canvasAIStepPlan{ID: "board/d", ModelID: "fixture", Config: map[string]any{"prompt": "summarize", "parameters": map[string]any{}}, FrozenContent: map[string]any{"text": "original"}} step := canvasAIStepPlan{ID: "board/d", ModelID: "fixture", Config: map[string]any{"prompt": "summarize", "parameters": map[string]any{}}, FrozenContent: map[string]any{"text": "original"}}
plan := canvasAIPlan{Edges: []canvasAIEdgePlan{{ID: "edge-a", Source: "board/b", Target: step.ID}, {ID: "edge-b", Source: "board/c", Target: step.ID}}} plan := canvasAIPlan{Edges: []canvasAIEdgePlan{{ID: "edge-a", Source: "board/b", Target: step.ID}, {ID: "edge-b", Source: "board/c", Target: step.ID}}}
+9 -4
View File
@@ -1,3 +1,4 @@
// 画布能力发现:公布静态协议支持与运行时模型可用性,供无界面客户端选择可用命令。
package platform package platform
import ( import (
@@ -6,6 +7,7 @@ import (
"time" "time"
) )
// canvasCapabilities 先验证 board 可读,再释放工作区锁探测 worker,避免外部调用延长数据库锁。
func (s *service) canvasCapabilities(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) canvasCapabilities(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet { if r.Method != http.MethodGet {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -27,6 +29,7 @@ func (s *service) canvasCapabilities(w http.ResponseWriter, r *http.Request, pro
if err = tx.Rollback(); err != nil { if err = tx.Rollback(); err != nil {
return err return err
} }
// 模型探测最多五秒;失败仍返回能力契约,但将 AI 标为不可用并给出稳定原因。
ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second) ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
defer cancel() defer cancel()
models, modelErr := s.canvasAI.Models(ctx) models, modelErr := s.canvasAI.Models(ctx)
@@ -39,17 +42,19 @@ func (s *service) canvasCapabilities(w http.ResponseWriter, r *http.Request, pro
} }
} }
} }
ai := response{"available": textAvailable || imageAvailable, "text": textAvailable, "image": imageAvailable} ai := response{"canonical_target_identity": true, "owner_relocation": true, "admission_protocol_version": 2, "admission_receipt_query": true, "mutation_protocol_version": 2, "terminal_rejection_receipts": true, "available": textAvailable || imageAvailable, "text": textAvailable, "image": imageAvailable}
if modelErr != nil { if modelErr != nil {
ai["unavailable_reason"] = "codex_unavailable" ai["unavailable_reason"] = "codex_unavailable"
} }
// 协议版本、规模预算和回执期限应与服务实现同步;available 单独反映当前 AI 后端状态。
reply(w, 200, response{ reply(w, 200, response{
"contract_version": "canvas-v2-2026-11-06", "contract_version": "canvas-headless-2026-11-07",
"canonical_model": response{"document_format_version": canvasModelFormat, "protocol_version": canvasModelProtocol, "explicit_migration": true, "stable_element_ids": true, "atomic_multi_canvas": true, "logical_operation_dedup": true, "legacy_snapshot_writes": false},
"supported_schema_versions": []int{1, 2}, "supported_schema_versions": []int{1, 2},
"edge_features": response{"appearance": true, "markers": true, "bezier_chain": true, "animation_configuration": true, "execution_events": true}, "edge_features": response{"appearance": true, "markers": true, "bezier_chain": true, "animation_configuration": true, "execution_events": true},
"subgraphs": response{"create": true, "migrate": true, "undo": true, "members": true, "dissolve": true, "connections": true}, "subgraphs": response{"create": true, "migrate": true, "undo": true, "members": true, "dissolve": true, "connections": true, "member_positions": true},
"ai": ai, "ai": ai,
"assets": response{"previews": true, "preview_max_edge": 1024, "originals_preserved": true}, "assets": response{"client_resource_ids": true, "receipt_protocol_version": 2, "previews": true, "preview_max_edge": 1024, "originals_preserved": true},
"limits": response{"max_depth": 8, "max_nodes": 500, "max_edges": 2000, "max_frame_ports": 4000, "max_curve_knots": 64, "max_snapshot_bytes": canvasLimit, "max_active_tasks": 128, "max_run_steps": 64, "max_execution_depth": 32, "max_input_images": 4, "max_input_image_bytes": 20 << 20, "max_coordinate": 1000000}, "limits": response{"max_depth": 8, "max_nodes": 500, "max_edges": 2000, "max_frame_ports": 4000, "max_curve_knots": 64, "max_snapshot_bytes": canvasLimit, "max_active_tasks": 128, "max_run_steps": 64, "max_execution_depth": 32, "max_input_images": 4, "max_input_image_bytes": 20 << 20, "max_coordinate": 1000000},
"retention": response{"idempotency_min_seconds": 86400, "undo_receipt_seconds": 604800}, "retention": response{"idempotency_min_seconds": 86400, "undo_receipt_seconds": 604800},
}) })
+15
View File
@@ -1,3 +1,4 @@
// 跨子图连线事务:从真实端点向共同祖先暴露端口,并在祖先画布上保存唯一逻辑边。
package platform package platform
import ( import (
@@ -11,11 +12,14 @@ import (
) )
// Endpoints name real nodes, never transient projected copies or client-created ports. // Endpoints name real nodes, never transient projected copies or client-created ports.
// canvasConnectionEndpoint 引用真实所有者画布中的节点,公开请求不能把投影副本或临时端口当真实节点。
type canvasConnectionEndpoint struct { type canvasConnectionEndpoint struct {
Board string `json:"board_id"` Board string `json:"board_id"`
Node string `json:"node_id"` Node string `json:"node_id"`
Handle string `json:"handle"` Handle string `json:"handle"`
} }
// canvasConnectionInput 包含两端真实位置、边配置与完整参与画布版本表。
type canvasConnectionInput struct { type canvasConnectionInput struct {
Source canvasConnectionEndpoint `json:"source"` Source canvasConnectionEndpoint `json:"source"`
Target canvasConnectionEndpoint `json:"target"` Target canvasConnectionEndpoint `json:"target"`
@@ -27,6 +31,7 @@ type canvasConnectionInput struct {
} }
// Paths run from a leaf board upwards to (but excluding) the coordinator. // Paths run from a leaf board upwards to (but excluding) the coordinator.
// connectionPath 从叶画布向协调者向上追溯,不含协调者本身;循环、过深、归档或断链都视为所有权冲突。
func connectionPath(r *http.Request, tx *sql.Tx, project, workspace, coordinator, board string) ([]subgraphRelation, error) { func connectionPath(r *http.Request, tx *sql.Tx, project, workspace, coordinator, board string) ([]subgraphRelation, error) {
path := []subgraphRelation{} path := []subgraphRelation{}
seen := map[string]bool{} seen := map[string]bool{}
@@ -51,6 +56,7 @@ func connectionPath(r *http.Request, tx *sql.Tx, project, workspace, coordinator
return path, nil return path, nil
} }
// connectionNode 查找已校验节点数组中的对象,返回引用以便后续原地追加端口。
func connectionNode(doc map[string]any, id string) map[string]any { func connectionNode(doc map[string]any, id string) map[string]any {
for _, value := range doc["nodes"].([]any) { for _, value := range doc["nodes"].([]any) {
node := value.(map[string]any) node := value.(map[string]any)
@@ -63,6 +69,7 @@ func connectionNode(doc map[string]any, id string) map[string]any {
// Reuse ports by logical endpoint, including legacy ports with non-derived IDs. // Reuse ports by logical endpoint, including legacy ports with non-derived IDs.
// A derived ID collision must never retarget an existing port. // A derived ID collision must never retarget an existing port.
// connectionPort 先按逻辑端点复用旧端口,否则由方向/节点/handle 派生 ID;同 ID 异目标不能覆盖。
func connectionPort(data map[string]any, node, handle, direction string) (string, bool, error) { func connectionPort(data map[string]any, node, handle, direction string) (string, bool, error) {
ports, _ := data["ports"].([]any) ports, _ := data["ports"].([]any)
sum := sha256.Sum256([]byte(direction + "/" + node + "/" + handle)) sum := sha256.Sum256([]byte(direction + "/" + node + "/" + handle))
@@ -85,6 +92,7 @@ func connectionPort(data map[string]any, node, handle, direction string) (string
return id, true, nil return id, true, nil
} }
// exposeConnectionEndpoint 逐层把真实端点转成父 frame 的 port 端点,返回祖先映射及实际新增端口清单。
func exposeConnectionEndpoint(endpoint canvasConnectionEndpoint, direction string, path []subgraphRelation, documents map[string]map[string]any) (canvasConnectionEndpoint, []any, error) { func exposeConnectionEndpoint(endpoint canvasConnectionEndpoint, direction string, path []subgraphRelation, documents map[string]map[string]any) (canvasConnectionEndpoint, []any, error) {
node := connectionNode(documents[endpoint.Board], endpoint.Node) node := connectionNode(documents[endpoint.Board], endpoint.Node)
if node == nil { if node == nil {
@@ -117,6 +125,7 @@ func exposeConnectionEndpoint(endpoint canvasConnectionEndpoint, direction strin
return endpoint, created, nil return endpoint, created, nil
} }
// createCanvasConnection 校验 v2、幂等键与编辑权限后收集参与者;所有快照校验通过才开始持久化。
func (s *service) createCanvasConnection(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) createCanvasConnection(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodPost { if r.Method != http.MethodPost {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -176,6 +185,7 @@ func (s *service) createCanvasConnection(w http.ResponseWriter, r *http.Request,
reject(w, 403, "forbidden") reject(w, 403, "forbidden")
return nil return nil
} }
// 在已授权且持锁后先重放相同请求回执,避免重试因版本已推进而误判冲突。
action, hash := "create_connection", payloadDigest(input) action, hash := "create_connection", payloadDigest(input)
done, err := transactionRetry(w, r, tx, project, account, coordinator, action, key, hash) done, err := transactionRetry(w, r, tx, project, account, coordinator, action, key, hash)
if err != nil || done { if err != nil || done {
@@ -211,6 +221,7 @@ func (s *service) createCanvasConnection(w http.ResponseWriter, r *http.Request,
} }
} }
// Require the lowest common ancestor, so the logical edge has one owner. // Require the lowest common ancestor, so the logical edge has one owner.
// 两侧路径在协调者以下不得还有共同子画布,否则协调者不是最低共同祖先,边会放错所有者。
left := map[string]bool{} left := map[string]bool{}
for _, relation := range paths[0] { for _, relation := range paths[0] {
left[relation.Child] = true left[relation.Child] = true
@@ -225,6 +236,7 @@ func (s *service) createCanvasConnection(w http.ResponseWriter, r *http.Request,
for id := range participants { for id := range participants {
ids = append(ids, id) ids = append(ids, id)
} }
// 稳定排序参与者,生成可重复的版本要求、快照与事务记录。
sort.Strings(ids) sort.Strings(ids)
before := []canvasSnapshot{} before := []canvasSnapshot{}
snapshots := map[string]canvasSnapshot{} snapshots := map[string]canvasSnapshot{}
@@ -250,6 +262,7 @@ func (s *service) createCanvasConnection(w http.ResponseWriter, r *http.Request,
} }
documents[id] = doc documents[id] = doc
} }
// 版本表必须恰好覆盖所有参与者,缺漏返回 required_board_ids,陈旧版本返回 412。
if len(input.Expected) != len(ids) { if len(input.Expected) != len(ids) {
reply(w, 428, response{"error": "version_required", "details": response{"required_board_ids": ids}}) reply(w, 428, response{"error": "version_required", "details": response{"required_board_ids": ids}})
return nil return nil
@@ -293,6 +306,7 @@ func (s *service) createCanvasConnection(w http.ResponseWriter, r *http.Request,
mapped = append(mapped, exposed) mapped = append(mapped, exposed)
created = append(created, ports...) created = append(created, ports...)
} }
// 保存的是映射后祖先端点,但回执同时保留原始 source/target,供调用方恢复逻辑身份。
edge := map[string]any{"id": input.Edge.ID, "source": mapped[0].Node, "sourceHandle": mapped[0].Handle, "target": mapped[1].Node, "targetHandle": mapped[1].Handle} edge := map[string]any{"id": input.Edge.ID, "source": mapped[0].Node, "sourceHandle": mapped[0].Handle, "target": mapped[1].Node, "targetHandle": mapped[1].Handle}
if input.Edge.Data != nil { if input.Edge.Data != nil {
edge["data"] = input.Edge.Data edge["data"] = input.Edge.Data
@@ -336,6 +350,7 @@ func (s *service) createCanvasConnection(w http.ResponseWriter, r *http.Request,
} }
result := response{"transaction_id": id, "parent": snapshots[coordinator], "snapshots": updated, "connection": response{"board_id": coordinator, "edge": edge, "source": input.Source, "target": input.Target}, "created_ports": created, "undo_receipt": response{"transaction_id": id, "valid_for_seconds": 604800, "expires_at": expiry}} result := response{"transaction_id": id, "parent": snapshots[coordinator], "snapshots": updated, "connection": response{"board_id": coordinator, "edge": edge, "source": input.Source, "target": input.Target}, "created_ports": created, "undo_receipt": response{"transaction_id": id, "valid_for_seconds": 604800, "expires_at": expiry}}
encoded, _ := json.Marshal(result) encoded, _ := json.Marshal(result)
// before 快照和 after_versions 支持七天撤销;响应体与幂等摘要一同入库,提交后才对外确认。
prior, _ := json.Marshal(before) prior, _ := json.Marshal(before)
after, _ := json.Marshal(versions) after, _ := json.Marshal(versions)
_, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_transactions(project,workspace_id,board_id,id,account_id,action,idempotency_key,payload_hash,response_status,response_body,before_state,after_versions) VALUES($1,$2,$3,$4,$5,$6,$7,$8,201,$9,$10,$11)`, project, workspace, coordinator, id, account, action, key, hash, encoded, prior, after) _, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_transactions(project,workspace_id,board_id,id,account_id,action,idempotency_key,payload_hash,response_status,response_body,before_state,after_versions) VALUES($1,$2,$3,$4,$5,$6,$7,$8,201,$9,$10,$11)`, project, workspace, coordinator, id, account, action, key, hash, encoded, prior, after)
@@ -1,3 +1,4 @@
// 跨画布连线数据库回归需要 PLATFORM_TEST_DATABASE_URL 指向隔离且已迁移测试库;未配置则跳过。
package platform package platform
import ( import (
@@ -17,6 +18,7 @@ import (
"testing" "testing"
) )
// TestCanvasConnectionTransactions 在隔离 PostgreSQL 中走完整 HTTP 连线/撤销/重试链路,并验证拒绝请求与容量失败没有部分持久化。
func TestCanvasConnectionTransactions(t *testing.T) { func TestCanvasConnectionTransactions(t *testing.T) {
dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL") dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL")
if dsn == "" { if dsn == "" {
@@ -69,6 +71,7 @@ func TestCanvasConnectionTransactions(t *testing.T) {
Register(mux, db, map[string]string{project: "https://app.example.com/auth/callback"}, "https://api.example.com", nil) Register(mux, db, map[string]string{project: "https://app.example.com/auth/callback"}, "https://api.example.com", nil)
base := "/projects/" + project + "/workspaces/" + workspace + "/materials/" base := "/projects/" + project + "/workspaces/" + workspace + "/materials/"
path := func(board string) string { return base + board + "/canvas" } path := func(board string) string { return base + board + "/canvas" }
// do 只组请求,call 再验证状态/解码;全部请求显式协商 v2,避免旧客户端丢失端口数据。
do := func(method, url, token string, body any, version int64, key string) *httptest.ResponseRecorder { do := func(method, url, token string, body any, version int64, key string) *httptest.ResponseRecorder {
raw, _ := json.Marshal(body) raw, _ := json.Marshal(body)
r := httptest.NewRequest(method, url, bytes.NewReader(raw)) r := httptest.NewRequest(method, url, bytes.NewReader(raw))
@@ -97,6 +100,7 @@ func TestCanvasConnectionTransactions(t *testing.T) {
return out return out
} }
key := func(n int) string { return fmt.Sprintf("a0000000-0000-4000-8000-%012d", n) } key := func(n int) string { return fmt.Sprintf("a0000000-0000-4000-8000-%012d", n) }
// 每次从真实 GET 读取参与者当前版本,构造恰好覆盖端口链的 expected_versions。
versions := func(ids ...string) map[string]int64 { versions := func(ids ...string) map[string]int64 {
t.Helper() t.Helper()
out := map[string]int64{} out := map[string]int64{}
@@ -128,6 +132,7 @@ func TestCanvasConnectionTransactions(t *testing.T) {
command := func(source, node, target, targetNode, id string, ids ...string) response { command := func(source, node, target, targetNode, id string, ids ...string) response {
return response{"source": response{"board_id": source, "node_id": node, "handle": "right"}, "target": response{"board_id": target, "node_id": targetNode, "handle": "left"}, "edge": response{"id": id, "data": response{"appearance": response{"color": "#123456", "width": 2}, "path": response{"type": "bezier-chain", "knots": []any{response{"id": "k", "position": response{"x": 200, "y": 300}, "in": response{"x": -20, "y": 0}, "out": response{"x": 20, "y": 0}, "mode": "symmetric"}}}}}, "expected_versions": versions(ids...)} return response{"source": response{"board_id": source, "node_id": node, "handle": "right"}, "target": response{"board_id": target, "node_id": targetNode, "handle": "left"}, "edge": response{"id": id, "data": response{"appearance": response{"color": "#123456", "width": 2}, "path": response{"type": "bezier-chain", "knots": []any{response{"id": "k", "position": response{"x": 200, "y": 300}, "in": response{"x": -20, "y": 0}, "out": response{"x": 20, "y": 0}, "mode": "symmetric"}}}}}, "expected_versions": versions(ids...)}
} }
// 从嵌套叶节点连到根节点,需要中间与根两个端口;叶文档本身不得被投影逻辑改写。
firstBody := command(leaf, "deep", root, "a", "external", root, left, leaf) firstBody := command(leaf, "deep", root, "a", "external", root, left, leaf)
beforeLeaf := call("GET", path(leaf), tokens[0], nil, 200, 0, "")["document"] beforeLeaf := call("GET", path(leaf), tokens[0], nil, 200, 0, "")["document"]
first := call("POST", path(root)+"/connections", tokens[0], firstBody, 201, 0, key(4)) first := call("POST", path(root)+"/connections", tokens[0], firstBody, 201, 0, key(4))
@@ -152,6 +157,7 @@ func TestCanvasConnectionTransactions(t *testing.T) {
if len(parent["document"].(map[string]any)["edges"].([]any)) != 2 { if len(parent["document"].(map[string]any)["edges"].([]any)) != 2 {
t.Fatal("existing edge lost") t.Fatal("existing edge lost")
} }
// 撤销还原所有参与快照并移除新端口;再次执行应恢复同一稳定逻辑端点映射。
undo := call("POST", path(root)+"/transactions/"+first["transaction_id"].(string)+"/undo", tokens[0], response{"expected_versions": versions(root, left, leaf)}, 200, 0, key(5)) undo := call("POST", path(root)+"/transactions/"+first["transaction_id"].(string)+"/undo", tokens[0], response{"expected_versions": versions(root, left, leaf)}, 200, 0, key(5))
if len(undo["snapshots"].([]any)) != 3 { if len(undo["snapshots"].([]any)) != 3 {
t.Fatal("undo did not restore complete chain") t.Fatal("undo did not restore complete chain")
@@ -181,6 +187,7 @@ func TestCanvasConnectionTransactions(t *testing.T) {
t.Fatal("input chain reused output ports") t.Fatal("input chain reused output ports")
} }
// Missing/stale participant versions, bad endpoints and permission failures are atomic. // Missing/stale participant versions, bad endpoints and permission failures are atomic.
// 收集拒绝前版本,随后缺版本、旧版本、非法端点及权限失败都必须保持整个向量不变。
stable := versions(root, left, leaf) stable := versions(root, left, leaf)
missing := command(leaf, "deep", root, "a", "missing", root, left) missing := command(leaf, "deep", root, "a", "missing", root, left)
required := call("POST", path(root)+"/connections", tokens[0], missing, 428, 0, key(10)) required := call("POST", path(root)+"/connections", tokens[0], missing, 428, 0, key(10))
@@ -203,6 +210,7 @@ func TestCanvasConnectionTransactions(t *testing.T) {
t.Fatal("rejected transaction partially changed versions") t.Fatal("rejected transaction partially changed versions")
} }
// The actual nested mapping is resolvable by the same reader used by AI propagation. // The actual nested mapping is resolvable by the same reader used by AI propagation.
// 将真实保存的快照交给 AI reader,确认连接生成的端口链可解析回真实叶节点。
graph := map[string]canvasSnapshot{} graph := map[string]canvasSnapshot{}
for _, board := range []string{root, left, leaf} { for _, board := range []string{root, left, leaf} {
read := call("GET", path(board), tokens[0], nil, 200, 0, "") read := call("GET", path(board), tokens[0], nil, 200, 0, "")
@@ -257,6 +265,7 @@ func TestCanvasConnectionTransactions(t *testing.T) {
t.Fatal("capabilities omitted connection transaction") t.Fatal("capabilities omitted connection transaction")
} }
// Four simultaneous retries create exactly one edge/receipt and advance versions once. // Four simultaneous retries create exactly one edge/receipt and advance versions once.
// 四个同键请求同时放行,必须共用回执并让每个参与画布恰好递增一次。
concurrent := command(left, "l2", root, "a", "concurrent", root, left) concurrent := command(left, "l2", root, "a", "concurrent", root, left)
prior := versions(root, left) prior := versions(root, left)
start := make(chan struct{}) start := make(chan struct{})
@@ -285,6 +294,7 @@ func TestCanvasConnectionTransactions(t *testing.T) {
} }
} }
// A full coordinator rejects the entire operation, including new leaf ports. // A full coordinator rejects the entire operation, including new leaf ports.
// 填满协调者边数再建新端口链,最终容量拒绝必须回滚叶端口、版本和事务记录。
snapshot := call("GET", path(root), tokens[0], nil, 200, 0, "") snapshot := call("GET", path(root), tokens[0], nil, 200, 0, "")
doc := snapshot["document"].(map[string]any) doc := snapshot["document"].(map[string]any)
edges := []any{} edges := []any{}
@@ -1,3 +1,4 @@
// 画布与资产纯函数回归;测试说明对应实际断言,不依赖浏览器或真实模型。
package platform package platform
import ( import (
@@ -6,6 +7,7 @@ import (
"testing" "testing"
) )
// TestConnectionPortReuseCollisionAndCapacity 验证按逻辑端点复用历史 ID,输入输出分离,派生 ID 冲突不可换绑,容量耗尽也不部分改写端口表。
func TestConnectionPortReuseCollisionAndCapacity(t *testing.T) { func TestConnectionPortReuseCollisionAndCapacity(t *testing.T) {
data := map[string]any{"ports": []any{map[string]any{"id": "custom-stable", "nodeId": "n", "handle": "left", "direction": "input"}}} data := map[string]any{"ports": []any{map[string]any{"id": "custom-stable", "nodeId": "n", "handle": "left", "direction": "input"}}}
id, created, err := connectionPort(data, "n", "left", "input") id, created, err := connectionPort(data, "n", "left", "input")
@@ -30,6 +32,7 @@ func TestConnectionPortReuseCollisionAndCapacity(t *testing.T) {
} }
} }
// TestConnectionExposureBuildsNestedDirectionChain 构造 leaf→middle→root 两层边界,检查逐层端口映射、同方向复用、反方向独立创建及叶节点文档不变。
func TestConnectionExposureBuildsNestedDirectionChain(t *testing.T) { func TestConnectionExposureBuildsNestedDirectionChain(t *testing.T) {
frame := func(child string) map[string]any { frame := func(child string) map[string]any {
return map[string]any{"id": "frame", "data": map[string]any{"kind": "frame", "subgraph": map[string]any{"boardId": child}, "ports": []any{}}} return map[string]any{"id": "frame", "data": map[string]any{"kind": "frame", "subgraph": map[string]any{"boardId": child}, "ports": []any{}}}
@@ -0,0 +1,87 @@
// 可选端到端回归:在获授权远程环境使用真实 Endoleap Node runtime 对接 Foundry HTTP 和隔离数据库。
package platform
import (
"context"
"crypto/rand"
"crypto/sha256"
"database/sql"
"encoding/base64"
"encoding/hex"
"encoding/json"
"net/http/httptest"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"time"
)
// Runs the real Endoleap runtime against authenticated Foundry HTTP and PostgreSQL.
// This opt-in is enabled by the existing remote schema runner, never local builds.
// TestHeadlessClientHTTPIntegration 需 FOUNDRY_HEADLESS_SOURCE 指向客户端源码;缺省跳过,显式开启却无隔离数据库则失败。
func TestHeadlessClientHTTPIntegration(t *testing.T) {
source, dsn := os.Getenv("FOUNDRY_HEADLESS_SOURCE"), os.Getenv("PLATFORM_TEST_DATABASE_URL")
if source == "" {
t.Skip("requires remote headless checkout")
}
if dsn == "" {
t.Fatal("headless integration requires isolated PostgreSQL")
}
db, err := sql.Open("pgx", dsn)
if err != nil {
t.Fatal(err)
}
defer db.Close()
ctx := context.Background()
var entropy [12]byte
_, _ = rand.Read(entropy[:])
project := "headless-" + hex.EncodeToString(entropy[:])
defer func() {
for _, table := range []string{"canvas_ai_runs", "canvas_model_operations", "canvas_model_identity_map", "canvas_model_requests", "canvas_model_projects", "canvas_asset_bindings", "canvas_assets", "canvas_subgraphs", "workspaces", "project_accounts"} {
_, _ = db.ExecContext(ctx, "DELETE FROM "+table+" WHERE project=$1", project)
}
}()
var account, workspace, root string
if err = db.QueryRowContext(ctx, `INSERT INTO project_accounts(project,id) VALUES($1,gen_random_uuid()) RETURNING id::text`, project).Scan(&account); err != nil {
t.Fatal(err)
}
var tokenBytes [32]byte
_, _ = rand.Read(tokenBytes[:])
token := base64.RawURLEncoding.EncodeToString(tokenBytes[:])
hash := sha256.Sum256([]byte(token))
if _, err = db.ExecContext(ctx, `INSERT INTO project_sessions(token_hash,project,account_id,expires_at) VALUES($1,$2,$3,now()+interval '1 hour')`, base64.RawURLEncoding.EncodeToString(hash[:]), project, account); err != nil {
t.Fatal(err)
}
if err = db.QueryRowContext(ctx, `INSERT INTO workspaces(project,name,owner_id) VALUES($1,'Headless integration',$2) RETURNING id::text`, project, account).Scan(&workspace); err != nil {
t.Fatal(err)
}
if _, err = db.ExecContext(ctx, `INSERT INTO workspace_members(project,workspace_id,account_id,role) VALUES($1,$2,$3,'admin')`, project, workspace, account); err != nil {
t.Fatal(err)
}
legacy := json.RawMessage(`{"schema_version":1,"nodes":[` + modelLegacyFrame + `,{"id":"a","type":"plainText","position":{"x":150,"y":260},"width":240,"height":72,"data":{"kind":"plain-text","title":"a","text":"preserved","frameId":"f"}}],"edges":[],"viewport":{"x":0,"y":0,"zoom":1}}`)
if err = db.QueryRowContext(ctx, `INSERT INTO materials(project,workspace_id,kind,title,created_by,canvas_document) VALUES($1,$2,'board','Root',$3,$4) RETURNING id::text`, project, workspace, account, legacy).Scan(&root); err != nil {
t.Fatal(err)
}
mux := headlessWorkerRoutes(t, db, map[string]string{project: "https://app.example.com/auth/callback"}, project, account)
server := httptest.NewServer(mux)
defer server.Close()
// 子进程最多两分钟,环境传递临时项目/账户/会话;所有输出先替换 token 再报告。
commandContext, cancel := context.WithTimeout(ctx, 2*time.Minute)
defer cancel()
command := exec.CommandContext(commandContext, "node", filepath.Join(source, "tests/headless/foundry.integration.mjs"))
command.Env = append(os.Environ(), "FOUNDRY_HTTP_URL="+server.URL, "FOUNDRY_TEST_PROJECT="+project, "FOUNDRY_TEST_ACCOUNT="+account, "FOUNDRY_TEST_WORKSPACE="+workspace, "FOUNDRY_TEST_ROOT="+root, "FOUNDRY_TEST_TOKEN="+token, "FOUNDRY_TEST_AI_WORKER=1")
output, err := command.CombinedOutput()
// The fixture token is ephemeral, but never print it even on client failures.
report := strings.ReplaceAll(string(output), token, "[fixture token redacted]")
if err != nil {
t.Fatalf("headless HTTP client failed: %v\n%s", err, report)
}
// 仅退出零不够,报告必须声明 status ok 且 runtimeAI 实际执行过。
if !strings.Contains(report, `"status":"ok"`) || !strings.Contains(report, `"runtimeAI":true`) {
t.Fatalf("headless HTTP client did not return success: %s", report)
}
t.Log(report)
}
@@ -0,0 +1,162 @@
// Headless 测试专用 worker 适配:固定生成输出,但准入、认领、取消、事件和 canonical 落库仍走生产实现。
package platform
import (
"bytes"
"database/sql"
"encoding/json"
"image"
"image/color"
"image/png"
"net"
"net/http"
"path/filepath"
"strings"
"sync"
"sync/atomic"
"testing"
"gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex"
)
// Only the generation transport is deterministic. Admission, claims, events,
// canonical writes and action receipts use the real service and isolated DB.
// headlessWorkerRoutes 搭建 Unix 假 worker 与私有控制路由,返回给端到端客户端;不是生产服务注册入口。
func headlessWorkerRoutes(t *testing.T, db *sql.DB, callbacks map[string]string, project, account string) http.Handler {
t.Helper()
// gate 同步确认生成已进入并控制释放,sync.Once 防止并发控制重复 close 通道。
type gate struct {
entered, release chan struct{}
started, released sync.Once
}
var mu sync.Mutex
var held *gate
var executions atomic.Int32
var picture bytes.Buffer
pixels := image.NewRGBA(image.Rect(0, 0, 3, 2))
pixels.Set(0, 0, color.RGBA{B: 255, A: 255})
if err := png.Encode(&picture, pixels); err != nil {
t.Fatal(err)
}
socket := filepath.Join(t.TempDir(), "worker.sock")
listener, err := net.Listen("unix", socket)
if err != nil {
t.Fatal(err)
}
worker := &http.Server{Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/canvas/models" {
reply(w, 200, response{"models": []any{
codex.CanvasModel{ID: "fixture-text", Label: "Fixture text", Available: true, InputModalities: []string{"text", "image"}, OutputModalities: []string{"text"}, MaxInputBytes: 1 << 20, MaxExecutionMS: 90000},
codex.CanvasModel{ID: "fixture-image", Label: "Fixture image", Available: true, InputModalities: []string{"text", "image"}, OutputModalities: []string{"image"}, MaxInputBytes: 1 << 20, MaxExecutionMS: 90000},
}})
return
}
if r.URL.Path != "/canvas/exec" {
reject(w, 404, "not_found")
return
}
var task codex.CanvasTask
if json.NewDecoder(r.Body).Decode(&task) != nil {
reject(w, 400, "invalid_request")
return
}
executions.Add(1)
mu.Lock()
current := held
mu.Unlock()
if current != nil {
current.started.Do(func() { close(current.entered) })
select {
case <-current.release:
case <-r.Context().Done():
return
}
mu.Lock()
if held == current {
held = nil
}
mu.Unlock()
}
if task.OutputModality == "image" {
reply(w, 200, response{"output": codex.CanvasOutput{Kind: "image", Image: &codex.CanvasImage{MIME: "image/png", Data: picture.Bytes()}}})
} else {
reply(w, 200, response{"result": "headless fixture output"})
}
})}
// 清理先释放正在阻塞的生成再关闭 server,避免用例失败后泄漏等待 goroutine。
go worker.Serve(listener)
t.Cleanup(func() {
mu.Lock()
if held != nil {
held.released.Do(func() { close(held.release) })
}
mu.Unlock()
worker.Close()
})
// 不启动周期队列,测试通过 execute 控制认领时刻,以稳定覆盖运行中目标移动/取消等竞态。
s := &service{db: db, origin: "https://api.example.com", canvasAI: codex.NewCanvasClient(socket)}
mux := http.NewServeMux()
prefix := "/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai"
mux.HandleFunc("GET "+prefix+"/models", s.protected(callbacks, s.canvasAIModels))
mux.HandleFunc("POST "+prefix+"/runs", s.protected(callbacks, s.createCanvasAIRun))
mux.HandleFunc("GET "+prefix+"/runs/{run}", s.protected(callbacks, s.getCanvasAIRun))
mux.HandleFunc("GET "+prefix+"/operations/{request}", s.protected(callbacks, s.getCanvasAIAdmission))
mux.HandleFunc("POST "+prefix+"/runs/{run}/cancel", s.protected(callbacks, s.cancelCanvasAIRun))
mux.HandleFunc("POST "+prefix+"/runs/{run}/apply", s.protected(callbacks, s.applyCanvasAIOutput))
// Private test controls are not registered by production Register().
mux.HandleFunc("POST "+prefix+"/fixture/{action}", s.protected(callbacks, func(w http.ResponseWriter, r *http.Request, p, a string) error {
if p != project || a != account {
reject(w, 403, "forbidden")
return nil
}
// arm/wait/release 管理传输门闩,execute 驱动一次真实队列认领,stats 暴露调用计数。
switch r.PathValue("action") {
case "arm":
mu.Lock()
held = &gate{entered: make(chan struct{}), release: make(chan struct{})}
mu.Unlock()
case "wait":
mu.Lock()
current := held
mu.Unlock()
if current == nil {
reject(w, 409, "worker_not_armed")
return nil
}
select {
case <-current.entered:
case <-r.Context().Done():
return nil
}
case "release":
mu.Lock()
if held != nil {
held.released.Do(func() { close(held.release) })
}
mu.Unlock()
case "execute":
run, err := s.claimCanvasRun(r.Context())
if err != nil || run == nil || run.Project != project || run.Account != account || run.Workspace != r.PathValue("workspace") {
reject(w, 409, "fixture_run_unavailable")
return nil
}
s.executeCanvasRun(r.Context(), *run)
case "stats":
default:
reject(w, 404, "not_found")
return nil
}
reply(w, 200, response{"executions": executions.Load()})
return nil
}))
// 其他平台请求走常规 Register;只有 AI 路径分流到可受测试精确控制的 service。
regular := http.NewServeMux()
Register(regular, db, callbacks, "https://api.example.com", nil)
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if strings.Contains(r.URL.Path, "/canvas/ai/") {
mux.ServeHTTP(w, r)
} else {
regular.ServeHTTP(w, r)
}
})
}
+5
View File
@@ -1,3 +1,4 @@
// 图规模预检与幂等键归一化,供多种画布 HTTP 命令共享。
package platform package platform
import ( import (
@@ -6,9 +7,13 @@ import (
"strings" "strings"
) )
// canvasIdempotencyKey 统一 UUID 大小写,格式合法性由具体入口继续验证。
func canvasIdempotencyKey(r *http.Request) string { func canvasIdempotencyKey(r *http.Request) string {
return strings.ToLower(r.Header.Get("Idempotency-Key")) return strings.ToLower(r.Header.Get("Idempotency-Key"))
} }
// canvasExceededGraphLimits 只判断节点/边/knot 数量超限;坏 JSON 返回 false 交给完整校验报告 400。
// 与 normalizeCanvas 分离,使合法可解码但规模过大的请求能明确返回 413。
func canvasExceededGraphLimits(raw json.RawMessage) bool { func canvasExceededGraphLimits(raw json.RawMessage) bool {
var doc struct { var doc struct {
Nodes []json.RawMessage `json:"nodes"` Nodes []json.RawMessage `json:"nodes"`
+496
View File
@@ -0,0 +1,496 @@
// Canonical 画布的内存模型与纯事务 reducer:元素稳定身份独立于 owner,跨画布编辑一次校验最终全图。
package platform
import (
"encoding/json"
"errors"
"math"
"reflect"
"sort"
"strings"
)
// 文档格式与写入协议独立版本化,前者描述模型视图,后者描述请求/回执契约。
const canvasModelFormat = 1
const canvasModelProtocol = 2
var errCanvasModel = errors.New("invalid_canvas_model")
var errModelConflict = errors.New("canvas_model_field_conflict")
// modelParent 用父画布和入口元素描述唯一所有权;不依赖旧 frameId 或投影端口。
type modelParent struct {
CanvasID string `json:"canvasId"`
EntryElementID string `json:"entryElementId"`
}
// modelCanvas 的根 Parent 为 nil,其他画布必须有唯一且有效的入口节点。
type modelCanvas struct {
ID string `json:"id"`
Parent *modelParent `json:"parent"`
}
// canvasModel 同时保留活跃对象、删除 incarnation 和死记录;Versions 也保留已移除画布的版本。
type canvasModel struct {
Root string
Canvases map[string]modelCanvas
Elements map[string]map[string]any
Tombstones map[string]int64
TombstoneOwners map[string]string
DeadRecords map[string]map[string]any
Versions map[string]int64
}
// modelView 为客户端提供完整或参与者局部模型;Removed 明确列出已归档但仍有版本的画布。
type modelView struct {
Format int `json:"documentFormatVersion"`
ProjectID string `json:"projectId"`
Canvases []modelCanvas `json:"canvases"`
Elements []map[string]any `json:"elements"`
Tombstones map[string]int64 `json:"tombstones"`
Versions map[string]int64 `json:"versions"`
Complete bool `json:"complete"`
Removed []string `json:"removedCanvasIds"`
}
// modelTarget 以 ID+incarnation 定位一代元素,避免删除后恢复的同 ID 被旧操作命中。
type modelTarget struct {
ID string `json:"id"`
Incarnation int64 `json:"incarnation"`
}
// modelChange 使用 before/after 做比较交换;data 字段的 Present 指针区分缺字段和显式 null。
type modelChange struct {
Kind string `json:"kind"`
ID string `json:"id,omitempty"`
Target modelTarget `json:"target,omitempty"`
Field string `json:"field,omitempty"`
Before json.RawMessage `json:"before"`
After json.RawMessage `json:"after"`
BeforePresent *bool `json:"beforePresent,omitempty"`
AfterPresent *bool `json:"afterPresent,omitempty"`
}
// modelOperation 是需跨请求去重的逻辑操作,一次包含若干有序变更。
type modelOperation struct {
ID string `json:"id"`
Changes []modelChange `json:"changes"`
}
// modelBatch 将多逻辑操作与所有参与画布版本打包;RequestID 必须等于 HTTP 幂等键。
type modelBatch struct {
ProtocolVersion int `json:"protocol_version"`
RequestID string `json:"request_id"`
Expected map[string]int64 `json:"expected_versions"`
Operations []modelOperation `json:"operations"`
}
// emptyModel 初始化所有索引,尚无活跃画布,需迁移或构造后通过 validateCanvasModel。
func emptyModel(root string) canvasModel {
return canvasModel{Root: root, Canvases: map[string]modelCanvas{}, Elements: map[string]map[string]any{}, Tombstones: map[string]int64{}, TombstoneOwners: map[string]string{}, DeadRecords: map[string]map[string]any{}, Versions: map[string]int64{}}
}
// modelString 只读取已解码 JSON 字符串,类型错误返回空值交由上层验证。
func modelString(value any) string { text, _ := value.(string); return text }
// modelInt 只接受 JavaScript 安全正整数,防止版本/incarnation 跨端精度丢失。
func modelInt(value any) int64 {
number, ok := value.(float64)
if !ok || number < 1 || number > 9007199254740991 || math.Trunc(number) != number {
return 0
}
return int64(number)
}
// modelJSONSafe 递归限制深度并拒绝非有限浮点或非 JSON 类型,允许未知组件保留合法数据。
func modelJSONSafe(value any, depth int) bool {
if depth > 64 {
return false
}
switch value := value.(type) {
case nil, bool, string:
return true
case float64:
return !math.IsNaN(value) && !math.IsInf(value, 0)
case []any:
for _, item := range value {
if !modelJSONSafe(item, depth+1) {
return false
}
}
return true
case map[string]any:
for _, item := range value {
if !modelJSONSafe(item, depth+1) {
return false
}
}
return true
}
return false
}
// modelEqual 统一到 JSON 值域后比较,使 Go 整数/结构体与解码出的 float64/对象能按语义相等。
func modelEqual(left, right any) bool {
// Round-trip numeric Go structs and JSON records to the same JSON value domain.
a, ea := json.Marshal(left)
b, eb := json.Marshal(right)
if ea != nil || eb != nil {
return false
}
var av, bv any
return json.Unmarshal(a, &av) == nil && json.Unmarshal(b, &bv) == nil && reflect.DeepEqual(av, bv)
}
// view 按稳定 ID 排序输出,participants 为 nil 表示完整模型,否则只返回给定画布及其墓碑。
func (model canvasModel) view(participants map[string]int64) modelView {
view := modelView{Format: canvasModelFormat, ProjectID: model.Root, Canvases: []modelCanvas{}, Elements: []map[string]any{}, Tombstones: map[string]int64{}, Versions: map[string]int64{}, Complete: participants == nil, Removed: []string{}}
for _, id := range sortedKeys(model.Canvases) {
if participants != nil {
if _, exists := participants[id]; !exists {
continue
}
}
view.Canvases = append(view.Canvases, model.Canvases[id])
view.Versions[id] = model.Versions[id]
}
for _, id := range sortedKeys(model.Elements) {
element := model.Elements[id]
if participants != nil {
if _, exists := participants[modelString(element["ownerCanvasId"])]; !exists {
continue
}
}
view.Elements = append(view.Elements, element)
}
// 删除代数也必须处于安全整数范围;活跃元素的 incarnation 稍后要求严格高于其墓碑。
for id, incarnation := range model.Tombstones {
owner := model.TombstoneOwners[id]
if live := model.Elements[id]; live != nil {
owner = modelString(live["ownerCanvasId"])
}
if participants != nil {
if _, exists := participants[owner]; !exists {
continue
}
}
view.Tombstones[id] = incarnation
}
for _, id := range sortedKeys(model.Versions) {
if participants != nil {
if _, exists := participants[id]; !exists {
continue
}
}
view.Versions[id] = model.Versions[id]
if _, exists := model.Canvases[id]; !exists {
view.Removed = append(view.Removed, id)
}
}
return view
}
// sortedKeys 为模型、投影和回执提供确定顺序,不依赖 Go map 遍历顺序。
func sortedKeys[T any](values map[string]T) []string {
keys := make([]string, 0, len(values))
for key := range values {
keys = append(keys, key)
}
sort.Strings(keys)
return keys
}
// cloneModel 深拷贝 JSON 兼容模型,让 reducer 失败时输入对象及嵌套 data 不被污染。
func cloneModel(model canvasModel) canvasModel {
raw, _ := json.Marshal(model)
var copy canvasModel
_ = json.Unmarshal(raw, &copy)
return copy
}
// modelAncestors 从当前画布向根遍历,拒绝缺父、循环和超过八层边界的路径。
func modelAncestors(model canvasModel, id string) ([]string, error) {
path, seen := []string{}, map[string]bool{}
for id != "" {
canvas, exists := model.Canvases[id]
if !exists || seen[id] || len(path) > 8 {
return nil, errCanvasModel
}
seen[id] = true
path = append(path, id)
id = ""
if canvas.Parent != nil {
id = canvas.Parent.CanvasID
}
}
return path, nil
}
// modelCommonCanvas 从右端最近祖先向上寻找交集,确定连接唯一的最低共同祖先所有者。
func modelCommonCanvas(model canvasModel, left, right string) (string, error) {
a, err := modelAncestors(model, left)
if err != nil {
return "", err
}
b, err := modelAncestors(model, right)
if err != nil {
return "", err
}
seen := map[string]bool{}
for _, id := range a {
seen[id] = true
}
for _, id := range b {
if seen[id] {
return id, nil
}
}
return "", errCanvasModel
}
// validateCanvasModel 对最终状态检查唯一根、入口所有权、元素代数、JSON 预算及连接最低共同祖先。
// 未知组件的合法 data/envelope 字段保留;仅已知 v1 组件追加相应业务数据约束。
func validateCanvasModel(model canvasModel) error {
if !uuidSlugPattern.MatchString(model.Root) || len(model.Canvases) == 0 || len(model.Canvases) > 256 || len(model.Elements) > 128000 {
return errCanvasModel
}
roots, entries, counts := 0, map[string]bool{}, map[string][2]int{}
for id, canvas := range model.Canvases {
if id != canvas.ID || !uuidSlugPattern.MatchString(id) {
return errCanvasModel
}
if _, err := modelAncestors(model, id); err != nil {
return err
}
if canvas.Parent == nil {
roots++
if id != model.Root {
return errCanvasModel
}
continue
}
entry := model.Elements[canvas.Parent.EntryElementID]
if entry == nil || entry["structure"] != "node" || entry["ownerCanvasId"] != canvas.Parent.CanvasID || entries[canvas.Parent.EntryElementID] {
return errCanvasModel
}
entries[canvas.Parent.EntryElementID] = true
}
if roots != 1 {
return errCanvasModel
}
for id, incarnation := range model.Tombstones {
if !canvasID.MatchString(id) || incarnation < 1 || incarnation > 9007199254740991 {
return errCanvasModel
}
}
for id, element := range model.Elements {
if !modelJSONSafe(element, 0) {
return errCanvasModel
}
owner, component := modelString(element["ownerCanvasId"]), modelString(element["componentId"])
_, canvasExists := model.Canvases[owner]
incarnation, version := modelInt(element["incarnation"]), modelInt(element["dataVersion"])
data, dataOK := element["data"].(map[string]any)
if !canvasID.MatchString(id) || element["id"] != id || !canvasExists || incarnation == 0 || incarnation <= model.Tombstones[id] || version == 0 || component == "" || len(component) > 128 || !dataOK || data == nil {
return errCanvasModel
}
encoded, err := json.Marshal(element)
if err != nil || len(encoded) > 1<<20 {
return errCanvasModel
}
count := counts[owner]
switch element["structure"] {
case "node":
count[0]++
geometry, ok := element["geometry"].(map[string]any)
if !ok || !canvasNumber(geometry["x"], -1e6, 1e6) || !canvasNumber(geometry["y"], -1e6, 1e6) || !canvasNumber(geometry["width"], 0.000001, 1e6) || !canvasNumber(geometry["height"], 0.000001, 1e6) || !canvasNumber(geometry["rotation"], 0, math.Nextafter(360, 0)) {
return errCanvasModel
}
if version == 1 && canvasChoice(component, "text", "image", "script", "plain-text", "plain-image", "icon", "frame") {
// Canonical frames can inherit rotation while changing owners. The
// legacy snapshot writer's zero-angle restriction does not apply here.
if !canvasString(data["title"], 300) || !canvasString(data["text"], 100000) {
return errCanvasModel
}
if ai, exists := data["ai"]; exists && !validCanvasAI(ai, component) {
return errCanvasModel
}
if asset, exists := data["assetId"]; exists && (!canvasChoice(component, "image", "plain-image") || !uuidSlugPattern.MatchString(modelString(asset))) {
return errCanvasModel
}
}
case "connection":
count[1]++
source, sourceOK := element["source"].(map[string]any)
target, targetOK := element["target"].(map[string]any)
if !sourceOK || !targetOK {
return errCanvasModel
}
a, b := model.Elements[modelString(source["elementId"])], model.Elements[modelString(target["elementId"])]
if a == nil || b == nil || a["structure"] != "node" || b["structure"] != "node" {
return errCanvasModel
}
for _, endpoint := range []map[string]any{source, target} {
if port, exists := endpoint["portId"]; exists && (!canvasString(port, 256) || modelString(port) == "") {
return errCanvasModel
}
}
common, err := modelCommonCanvas(model, modelString(a["ownerCanvasId"]), modelString(b["ownerCanvasId"]))
if err != nil || common != owner {
return errCanvasModel
}
default:
return errCanvasModel
}
if count[0] > 500 || count[1] > 2000 {
return errGraphCapacity
}
counts[owner] = count
}
return nil
}
// Pure transaction reducer. Unknown component data/envelope fields are retained.
// applyModelOperations 在副本依次执行变更,允许批次中间态暂不完整,最后统一验证所有权和引用。
func applyModelOperations(initial canvasModel, operations []modelOperation) (canvasModel, map[string]bool, error) {
model, touched, seen := cloneModel(initial), map[string]bool{}, map[string]bool{}
if len(operations) == 0 || len(operations) > 2500 {
return model, nil, errCanvasModel
}
changeCount := 0
for _, operation := range operations {
if !uuidSlugPattern.MatchString(operation.ID) || seen[operation.ID] || len(operation.Changes) == 0 {
return model, nil, errCanvasModel
}
seen[operation.ID] = true
for _, change := range operation.Changes {
changeCount++
if changeCount > 10000 {
return model, nil, errGraphCapacity
}
var before, after any
if json.Unmarshal(change.Before, &before) != nil || json.Unmarshal(change.After, &after) != nil {
return model, nil, errCanvasModel
}
switch change.Kind {
case "field":
// 字段编辑必须命中同代元素;data.<key> 是单层键,其他字段只允许明确白名单。
element := model.Elements[change.Target.ID]
if element == nil || modelInt(element["incarnation"]) != change.Target.Incarnation {
return model, nil, errModelConflict
}
touched[modelString(element["ownerCanvasId"])] = true
if strings.HasPrefix(change.Field, "data.") {
key := strings.TrimPrefix(change.Field, "data.")
if key == "" || canvasChoice(key, "__proto__", "constructor", "prototype") {
return model, nil, errCanvasModel
}
data := element["data"].(map[string]any)
prior, present := data[key]
// beforePresent 缺省表示字段存在,因此缺字段与现有 null 不会被误当作同一前态。
if present != (change.BeforePresent == nil || *change.BeforePresent) || !modelEqual(prior, before) {
return model, nil, errModelConflict
}
if change.AfterPresent != nil && !*change.AfterPresent {
delete(data, key)
} else {
data[key] = after
}
} else {
if !canvasChoice(change.Field, "geometry", "ownerCanvasId", "source", "target", "path") {
return model, nil, errCanvasModel
}
if !modelEqual(element[change.Field], before) {
return model, nil, errModelConflict
}
element[change.Field] = after
if change.Field == "ownerCanvasId" {
touched[modelString(after)] = true
}
}
case "element":
// 整记录增删替换先比较前态;删除留下死记录,恢复要求比已删除代数更新的 incarnation。
if !canvasID.MatchString(change.ID) || !modelEqual(model.Elements[change.ID], before) {
return model, nil, errModelConflict
}
if prior := model.Elements[change.ID]; prior != nil {
touched[modelString(prior["ownerCanvasId"])] = true
}
if after == nil {
if prior := model.Elements[change.ID]; prior != nil {
model.Tombstones[change.ID] = modelInt(prior["incarnation"])
model.TombstoneOwners[change.ID] = modelString(prior["ownerCanvasId"])
model.DeadRecords[change.ID] = prior
}
delete(model.Elements, change.ID)
} else {
record, ok := after.(map[string]any)
if !ok || record["id"] != change.ID {
return model, nil, errCanvasModel
}
if before == nil && modelInt(record["incarnation"]) <= model.Tombstones[change.ID] {
return model, nil, errModelConflict
}
if prior := model.Elements[change.ID]; prior != nil && modelInt(record["incarnation"]) != modelInt(prior["incarnation"]) {
return model, nil, errModelConflict
}
model.Elements[change.ID] = record
touched[modelString(record["ownerCanvasId"])] = true
}
case "canvas":
// 画布关系变动同时触及旧父和新父,确保入口所有权变化被版本向量覆盖。
prior, exists := model.Canvases[change.ID]
var priorValue any
if exists {
priorValue = prior
}
if !uuidSlugPattern.MatchString(change.ID) || !modelEqual(priorValue, before) {
return model, nil, errModelConflict
}
touched[change.ID] = true
if prior.Parent != nil {
touched[prior.Parent.CanvasID] = true
}
if after == nil {
delete(model.Canvases, change.ID)
} else {
var canvas modelCanvas
if json.Unmarshal(change.After, &canvas) != nil || canvas.ID != change.ID {
return model, nil, errCanvasModel
}
model.Canvases[change.ID] = canvas
if canvas.Parent != nil {
touched[canvas.Parent.CanvasID] = true
}
}
default:
return model, nil, errCanvasModel
}
}
}
if err := validateCanvasModel(model); err != nil {
return model, nil, err
}
// Endpoint owners are read participants, guarding against delete/restore races in child canvases.
for _, operation := range operations {
for _, change := range operation.Changes {
if change.Kind == "element" && string(change.Before) == "null" || change.Kind == "field" && (change.Field == "source" || change.Field == "target") {
id := change.ID
if change.Kind == "field" {
id = change.Target.ID
}
element := model.Elements[id]
if element != nil && element["structure"] == "connection" {
for _, field := range []string{"source", "target"} {
endpoint := element[field].(map[string]any)
touched[modelString(model.Elements[modelString(endpoint["elementId"])]["ownerCanvasId"])] = true
}
}
}
}
}
// 每个参与者无论本批被触及多少次都只递增一次;数据库权限与预期版本仍由 HTTP 层检查。
for id := range touched {
model.Versions[id] = initial.Versions[id] + 1
}
return model, touched, nil
}
@@ -0,0 +1,405 @@
// Canonical 原子性数据库回归:需 PLATFORM_TEST_DATABASE_URL 指向隔离且已迁移测试库,未配置则跳过。
package platform
import (
"bytes"
"context"
"crypto/rand"
"crypto/sha256"
"database/sql"
"encoding/base64"
"encoding/hex"
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"testing"
"time"
)
// canonicalAtomicFixture 持有随机项目、真实路由与源快照,所有请求共用有效账户和独立工作区。
type canonicalAtomicFixture struct {
db *sql.DB
mux *http.ServeMux
project, account, workspace, root, token string
legacy json.RawMessage
}
// newCanonicalAtomicFixture 建账户/会话/admin/旧图,并按外键关系注册数据清理;不自动执行迁移脚本。
func newCanonicalAtomicFixture(t *testing.T) *canonicalAtomicFixture {
t.Helper()
dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL")
if dsn == "" {
t.Skip("requires an isolated integration database")
}
db, err := sql.Open("pgx", dsn)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { db.Close() })
var entropy [12]byte
_, _ = rand.Read(entropy[:])
f := &canonicalAtomicFixture{db: db, project: "canonical-atomic-" + hex.EncodeToString(entropy[:])}
ctx := context.Background()
t.Cleanup(func() {
for _, table := range []string{"canvas_ai_runs", "canvas_model_operations", "canvas_model_identity_map", "canvas_model_requests", "canvas_model_projects", "canvas_asset_bindings", "canvas_subgraphs", "workspaces", "project_accounts"} {
_, _ = db.ExecContext(ctx, "DELETE FROM "+table+" WHERE project=$1", f.project)
}
})
if err = db.QueryRowContext(ctx, `INSERT INTO project_accounts(project,id) VALUES($1,gen_random_uuid()) RETURNING id::text`, f.project).Scan(&f.account); err != nil {
t.Fatal(err)
}
var tokenBytes [32]byte
_, _ = rand.Read(tokenBytes[:])
f.token = base64.RawURLEncoding.EncodeToString(tokenBytes[:])
hash := sha256.Sum256([]byte(f.token))
if _, err = db.ExecContext(ctx, `INSERT INTO project_sessions(token_hash,project,account_id,expires_at) VALUES($1,$2,$3,now()+interval '1 hour')`, base64.RawURLEncoding.EncodeToString(hash[:]), f.project, f.account); err != nil {
t.Fatal(err)
}
if err = db.QueryRowContext(ctx, `INSERT INTO workspaces(project,name,owner_id) VALUES($1,'Canonical atomic',$2) RETURNING id::text`, f.project, f.account).Scan(&f.workspace); err != nil {
t.Fatal(err)
}
if _, err = db.ExecContext(ctx, `INSERT INTO workspace_members(project,workspace_id,account_id,role) VALUES($1,$2,$3,'admin')`, f.project, f.workspace, f.account); err != nil {
t.Fatal(err)
}
f.legacy = json.RawMessage(`{"schema_version":1,"nodes":[` + modelLegacyFrame + `,{"id":"a","type":"material","position":{"x":150,"y":260},"width":240,"height":72,"data":{"kind":"text","title":"a","text":"preserved","frameId":"f"}},{"id":"b","type":"material","position":{"x":180,"y":300},"width":240,"height":72,"data":{"kind":"text","title":"b","text":"preserved","frameId":"f"}},{"id":"c","type":"material","position":{"x":0,"y":0},"width":240,"height":72,"data":{"kind":"text","title":"c","text":"unrelated"}}],"edges":[{"id":"e","source":"a","target":"b"}],"viewport":{"x":0,"y":0,"zoom":1}}`)
if err = db.QueryRowContext(ctx, `INSERT INTO materials(project,workspace_id,kind,title,created_by,canvas_document) VALUES($1,$2,'board','Root',$3,$4) RETURNING id::text`, f.project, f.workspace, f.account, f.legacy).Scan(&f.root); err != nil {
t.Fatal(err)
}
f.mux = http.NewServeMux()
Register(f.mux, db, map[string]string{f.project: "https://app.example.com/auth/callback"}, "https://api.example.com", nil)
return f
}
// path 返回本 fixture 根的 canonical 入口,避免测试错用旧快照路径。
func (f *canonicalAtomicFixture) path() string {
return "/projects/" + f.project + "/workspaces/" + f.workspace + "/materials/" + f.root + "/canvas/model"
}
// request 携带会话、预期账户及 v2 协商,并沿用传入 context 以测试数据库写入中途取消。
func (f *canonicalAtomicFixture) request(ctx context.Context, method, path, key string, raw []byte) *httptest.ResponseRecorder {
r := httptest.NewRequest(method, path, bytes.NewReader(raw)).WithContext(ctx)
r.Header.Set("Authorization", "Bearer "+f.token)
r.Header.Set("X-Expected-Account", f.account)
r.Header.Set("Accept", "application/vnd.foundry.canvas+json;version=2")
if key != "" {
r.Header.Set("Idempotency-Key", key)
}
w := httptest.NewRecorder()
f.mux.ServeHTTP(w, r)
return w
}
// canonicalAtomicResponse 先断言实际 HTTP 状态,再解码响应,避免把错误 JSON 当作正常模型使用。
func canonicalAtomicResponse(t *testing.T, w *httptest.ResponseRecorder, status int) response {
t.Helper()
if w.Code != status {
t.Fatalf("canonical response got %d %s want %d", w.Code, w.Body.String(), status)
}
var body response
if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
t.Fatal(err)
}
return body
}
// read 直接从权威模型表装配完整模型,检查 HTTP 应答外的持久化事实。
func (f *canonicalAtomicFixture) read(t *testing.T) canvasModel {
t.Helper()
tx, err := f.db.BeginTx(context.Background(), nil)
if err != nil {
t.Fatal(err)
}
defer tx.Rollback()
model, err := loadCanvasModel(context.Background(), tx, f.project, f.workspace, f.root)
if err != nil {
t.Fatal(err)
}
return model
}
// concurrent 同时放行多请求并按原索引收集,二十秒上下文限制等待,不以返回顺序猜赢家。
func (f *canonicalAtomicFixture) concurrent(t *testing.T, path string, keys []string, bodies [][]byte) []*httptest.ResponseRecorder {
t.Helper()
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
type result struct {
index int
writer *httptest.ResponseRecorder
}
start, done := make(chan struct{}), make(chan result, len(keys))
for i := range keys {
go func(index int) {
<-start
done <- result{index, f.request(ctx, "POST", path, keys[index], bodies[index])}
}(i)
}
close(start)
out := make([]*httptest.ResponseRecorder, len(keys))
for range keys {
select {
case value := <-done:
out[value.index] = value.writer
case <-ctx.Done():
t.Fatal("canonical concurrent requests did not finish")
}
}
return out
}
// TestCanonicalConcurrentMigrationAndOwnershipWrites 验证同键迁移/编辑只执行一次,不同条件所有权写只有一个赢家。
// 成功和冲突都必须有可查询冻结回执,未涉及元素和树不得被部分改写。
func TestCanonicalConcurrentMigrationAndOwnershipWrites(t *testing.T) {
f := newCanonicalAtomicFixture(t)
ctx := context.Background()
key := modelTestID(8000)
input := response{"protocol_version": 2, "request_id": key, "expected_versions": map[string]int64{f.root: 1}}
raw := modelJSON(input)
replies := f.concurrent(t, f.path()+"/migrate", []string{key, key, key, key}, [][]byte{raw, raw, raw, raw})
first := canonicalAtomicResponse(t, replies[0], 200)
for _, reply := range replies[1:] {
if !modelEqual(first, canonicalAtomicResponse(t, reply, 200)) {
t.Fatal("concurrent migration allocated different identities or receipts")
}
}
ids := map[string]string{}
for _, value := range first["identity_map"].([]any) {
mapping := value.(map[string]any)
ids[mapping["sourceId"].(string)] = mapping["elementId"].(string)
}
before := f.read(t)
child := modelString(before.Elements[ids["a"]]["ownerCanvasId"])
if len(before.Canvases) != 2 || len(ids) != 5 || child == f.root || before.Versions[f.root] != 2 || before.Versions[child] != 1 {
t.Fatal("concurrent migration duplicated the implicit partition or version barrier")
}
key = modelTestID(8001)
edit := modelBatch{ProtocolVersion: 2, RequestID: key, Expected: map[string]int64{child: 1}, Operations: []modelOperation{{ID: modelTestID(8002), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: ids["a"], Incarnation: 1}, Field: "data.title", Before: modelJSON("a"), After: modelJSON("renamed")}}}}}
raw = modelJSON(edit)
replies = f.concurrent(t, f.path()+"/operations", []string{key, key, key, key}, [][]byte{raw, raw, raw, raw})
first = canonicalAtomicResponse(t, replies[0], 200)
for _, reply := range replies[1:] {
if !modelEqual(first, canonicalAtomicResponse(t, reply, 200)) {
t.Fatal("concurrent edit retry changed its original receipt")
}
}
before = f.read(t)
if before.Versions[child] != 2 || before.Versions[f.root] != 2 || modelString(before.Elements[ids["a"]]["data"].(map[string]any)["title"]) != "renamed" {
t.Fatal("concurrent edit executed more than once")
}
// 两请求共享同一版本向量,各移动不同节点但都移动其连接,验证条件写竞争而非简单串行重放。
var batches []modelBatch
var keys []string
var bodies [][]byte
for index, node := range []string{ids["a"], ids["b"]} {
key := modelTestID(8100 + index)
batch := modelBatch{ProtocolVersion: 2, RequestID: key, Expected: map[string]int64{f.root: 2, child: 2}, Operations: []modelOperation{{ID: modelTestID(8200 + index), Changes: []modelChange{
{Kind: "field", Target: modelTarget{ID: node, Incarnation: 1}, Field: "ownerCanvasId", Before: modelJSON(child), After: modelJSON(f.root)},
{Kind: "field", Target: modelTarget{ID: ids["e"], Incarnation: 1}, Field: "ownerCanvasId", Before: modelJSON(child), After: modelJSON(f.root)},
}}}}
batches, keys, bodies = append(batches, batch), append(keys, key), append(bodies, modelJSON(batch))
}
replies = f.concurrent(t, f.path()+"/operations", keys, bodies)
winner, successes := -1, 0
for index, reply := range replies {
status := 412
if reply.Code == 200 {
winner, successes, status = index, successes+1, 200
}
body := canonicalAtomicResponse(t, reply, status)
queried := canonicalAtomicResponse(t, f.request(ctx, "GET", f.path()+"/operations/"+keys[index], "", nil), 200)
if !modelEqual(body, queried) || status == 412 && (body["status"] != "not-applied" || body["terminal"] != true || body["error"] != "version_conflict") {
t.Fatal("a competing write lost its queryable applied or zero-effect receipt")
}
}
if successes != 1 {
t.Fatal("competing conditional ownership writes did not have exactly one winner")
}
after := f.read(t)
if err := validateCanvasModel(after); err != nil {
t.Fatal(err)
}
nodes := []string{ids["a"], ids["b"]}
if after.Versions[f.root] != 3 || after.Versions[child] != 3 || modelString(after.Elements[nodes[winner]]["ownerCanvasId"]) != f.root || modelString(after.Elements[nodes[1-winner]]["ownerCanvasId"]) != child || modelString(after.Elements[ids["e"]]["ownerCanvasId"]) != f.root || !modelEqual(before.Elements[ids["c"]], after.Elements[ids["c"]]) || !modelEqual(before.Canvases, after.Canvases) {
t.Fatal("competing ownership writes published a partial node/edge/tree or advanced versions twice")
}
var count int
if err := f.db.QueryRowContext(ctx, `SELECT count(*) FROM canvas_model_operations WHERE project=$1`, f.project).Scan(&count); err != nil || count != 2 {
t.Fatalf("logical operations: %d %v", count, err)
}
changed := batches[winner]
changed.Operations[0].ID = modelTestID(8999)
body := canonicalAtomicResponse(t, f.request(ctx, "POST", f.path()+"/operations", keys[winner], modelJSON(changed)), 409)
if body["error"] != "idempotency_conflict" || !modelEqual(after, f.read(t)) {
t.Fatal("same key with different bytes changed the canonical model")
}
}
// TestCanonicalMigrationLateCancellationRollsBack 用独占表锁卡住后期身份映射 INSERT,观察确实到达后才取消请求。
// 所有模型/关系/新素材和旧版本应回滚,随后同原请求能安全重试且只分配一次最终身份映射。
func TestCanonicalMigrationLateCancellationRollsBack(t *testing.T) {
f := newCanonicalAtomicFixture(t)
ctx, stop := context.WithTimeout(context.Background(), 20*time.Second)
defer stop()
barrier, err := f.db.BeginTx(ctx, nil)
if err != nil {
t.Fatal(err)
}
defer barrier.Rollback()
if _, err = barrier.ExecContext(ctx, `LOCK TABLE canvas_model_identity_map IN ACCESS EXCLUSIVE MODE`); err != nil {
t.Fatal(err)
}
var blocker int
if err = barrier.QueryRowContext(ctx, `SELECT pg_backend_pid()`).Scan(&blocker); err != nil {
t.Fatal(err)
}
key := modelTestID(8300)
input := response{"protocol_version": 2, "request_id": key, "expected_versions": map[string]int64{f.root: 1}}
requestContext, cancel := context.WithCancel(ctx)
defer cancel()
done := make(chan *httptest.ResponseRecorder, 1)
go func() { done <- f.request(requestContext, "POST", f.path()+"/migrate", key, modelJSON(input)) }()
// Observe the actual late INSERT blocked behind this transaction. A timer
// alone cannot prove migration reached canonical/material/subgraph writes.
// 查询 pg_stat_activity/pg_blocking_pids 证明是目标后期写被阻塞,不用单纯 sleep 推断执行进度。
ticker := time.NewTicker(10 * time.Millisecond)
defer ticker.Stop()
observed := false
for !observed {
if err = f.db.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM pg_stat_activity WHERE usename=current_user AND query LIKE 'INSERT INTO canvas_model_identity_map%' AND $1=ANY(pg_blocking_pids(pid)))`, blocker).Scan(&observed); err != nil {
t.Fatal(err)
}
if observed {
break
}
select {
case reply := <-done:
t.Fatalf("migration did not reach its late write: %d %s", reply.Code, reply.Body.String())
case <-ctx.Done():
t.Fatal("migration never reached its late identity-map INSERT")
case <-ticker.C:
}
}
cancel()
select {
case reply := <-done:
canonicalAtomicResponse(t, reply, 503)
case <-ctx.Done():
t.Fatal("cancelled migration did not finish")
}
if err = barrier.Rollback(); err != nil {
t.Fatal(err)
}
for _, table := range []string{"canvas_model_projects", "canvas_model_canvases", "canvas_model_elements", "canvas_model_identity_map", "canvas_model_requests", "canvas_model_operations", "canvas_subgraphs"} {
var count int
if err = f.db.QueryRowContext(ctx, "SELECT count(*) FROM "+table+" WHERE project=$1", f.project).Scan(&count); err != nil || count != 0 {
t.Fatalf("late cancellation left %s rows: %d %v", table, count, err)
}
}
var count int
var version int64
var source json.RawMessage
if err = f.db.QueryRowContext(ctx, `SELECT count(*) FROM materials WHERE project=$1`, f.project).Scan(&count); err != nil || count != 1 {
t.Fatalf("synthetic partition material survived rollback: %d %v", count, err)
}
if err = f.db.QueryRowContext(ctx, `SELECT canvas_version,canvas_document FROM materials WHERE project=$1 AND id=$2`, f.project, f.root).Scan(&version, &source); err != nil || version != 1 || !modelEqual(f.legacy, source) {
t.Fatalf("late cancellation changed legacy source/version: %d %v", version, err)
}
// Infrastructure failure saved no result. The same original request can be
// retried safely, and all subsequent retries must return its one identity map.
first := canonicalAtomicResponse(t, f.request(ctx, "POST", f.path()+"/migrate", key, modelJSON(input)), 200)
retry := canonicalAtomicResponse(t, f.request(ctx, "POST", f.path()+"/migrate", key, modelJSON(input)), 200)
if !modelEqual(first, retry) || len(f.read(t).Canvases) != 2 {
t.Fatal("retry after rollback duplicated identities or the implicit partition")
}
}
// TestCanonicalMigrationPermissionVersionAndRunGuards 检查 viewer、陈旧版本及 queued/running AI 阻止身份屏障。
// 原拒绝键在版本或任务状态改变后仍冻结,新的请求键才能在条件满足后执行迁移。
func TestCanonicalMigrationPermissionVersionAndRunGuards(t *testing.T) {
f := newCanonicalAtomicFixture(t)
ctx := context.Background()
input := func(key string, version int64) response {
return response{"protocol_version": 2, "request_id": key, "expected_versions": map[string]int64{f.root: version}}
}
call := func(key string, version int64, status int) response {
t.Helper()
return canonicalAtomicResponse(t, f.request(ctx, "POST", f.path()+"/migrate", key, modelJSON(input(key, version))), status)
}
assertLegacy := func(version int64) {
t.Helper()
for _, table := range []string{"canvas_model_projects", "canvas_model_canvases", "canvas_model_elements", "canvas_model_identity_map", "canvas_subgraphs"} {
var count int
if err := f.db.QueryRowContext(ctx, "SELECT count(*) FROM "+table+" WHERE project=$1", f.project).Scan(&count); err != nil || count != 0 {
t.Fatalf("rejected migration left %s rows: %d %v", table, count, err)
}
}
var count int
var current int64
var source json.RawMessage
if err := f.db.QueryRowContext(ctx, `SELECT count(*) FROM materials WHERE project=$1`, f.project).Scan(&count); err != nil || count != 1 {
t.Fatalf("rejected migration created a material: %d %v", count, err)
}
if err := f.db.QueryRowContext(ctx, `SELECT canvas_version,canvas_document FROM materials WHERE project=$1 AND id=$2`, f.project, f.root).Scan(&current, &source); err != nil || current != version || !modelEqual(f.legacy, source) {
t.Fatalf("rejected migration changed legacy source/version: %d %v", current, err)
}
}
if _, err := f.db.ExecContext(ctx, `UPDATE workspace_members SET role='viewer' WHERE project=$1 AND workspace_id=$2 AND account_id=$3`, f.project, f.workspace, f.account); err != nil {
t.Fatal(err)
}
if call(modelTestID(8500), 1, 403)["error"] != "forbidden" {
t.Fatal("viewer crossed the identity migration barrier")
}
assertLegacy(1)
if _, err := f.db.ExecContext(ctx, `UPDATE workspace_members SET role='admin' WHERE project=$1 AND workspace_id=$2 AND account_id=$3`, f.project, f.workspace, f.account); err != nil {
t.Fatal(err)
}
staleKey := modelTestID(8501)
rejected := call(staleKey, 2, 412)
if rejected["status"] != "not-applied" || rejected["terminal"] != true || rejected["error"] != "migration_version_conflict" {
t.Fatal("stale source migration did not produce a zero-effect receipt")
}
assertLegacy(1)
// Advance the old writer to the formerly rejected expected version. That
// cannot turn the same frozen negative request into a migration later.
if _, err := f.db.ExecContext(ctx, `UPDATE materials SET canvas_version=2 WHERE project=$1 AND id=$2`, f.project, f.root); err != nil {
t.Fatal(err)
}
if !modelEqual(rejected, call(staleKey, 2, 412)) {
t.Fatal("a source version change reevaluated a rejected migration key")
}
assertLegacy(2)
run := modelTestID(8400)
if _, err := f.db.ExecContext(ctx, `INSERT INTO canvas_ai_runs(project,workspace_id,board_id,id,account_id,idempotency_key,payload_hash,status,plan,create_response) VALUES($1,$2,$3,$4,$5,$6,'fixture','queued','{}','{}')`, f.project, f.workspace, f.root, run, f.account, modelTestID(8401)); err != nil {
t.Fatal(err)
}
if _, err := f.db.ExecContext(ctx, `INSERT INTO canvas_ai_steps(project,workspace_id,run_id,id,board_id,node_id,ordinal,status,model_id,frozen_input,target_fingerprint) VALUES($1,$2,$3,'fixture',$4,'a',0,'queued','fixture','{}','fixture')`, f.project, f.workspace, run, f.root); err != nil {
t.Fatal(err)
}
for index, status := range []string{"queued", "running"} {
if _, err := f.db.ExecContext(ctx, `UPDATE canvas_ai_runs SET status=$4 WHERE project=$1 AND workspace_id=$2 AND id=$3`, f.project, f.workspace, run, status); err != nil {
t.Fatal(err)
}
if _, err := f.db.ExecContext(ctx, `UPDATE canvas_ai_steps SET status=$4 WHERE project=$1 AND workspace_id=$2 AND run_id=$3`, f.project, f.workspace, run, status); err != nil {
t.Fatal(err)
}
body := call(modelTestID(8600+index), 2, 409)
if body["status"] != "not-applied" || body["terminal"] != true || body["error"] != "migration_waiting_for_runs" {
t.Fatal("identity migration crossed queued or outcome-unknown execution")
}
assertLegacy(2)
}
if _, err := f.db.ExecContext(ctx, `UPDATE canvas_ai_steps SET status='cancelled' WHERE project=$1 AND workspace_id=$2 AND run_id=$3`, f.project, f.workspace, run); err != nil {
t.Fatal(err)
}
if _, err := f.db.ExecContext(ctx, `UPDATE canvas_ai_runs SET status='cancelled' WHERE project=$1 AND workspace_id=$2 AND id=$3`, f.project, f.workspace, run); err != nil {
t.Fatal(err)
}
if call(modelTestID(8601), 2, 409)["error"] != "migration_waiting_for_runs" {
t.Fatal("settling paid work changed the frozen rejection")
}
call(modelTestID(8602), 2, 200)
model := f.read(t)
if model.Versions[f.root] != 3 || len(model.Canvases) != 2 {
t.Fatal("explicit migration after execution settled lost its source version barrier")
}
}
+44
View File
@@ -0,0 +1,44 @@
// Canonical 树的旧入口屏障,防止旧快照或子图命令覆盖已迁入的稳定身份模型。
package platform
import (
"net/http"
"strings"
)
// Old frozen receipts remain readable. Old whole-snapshot/ownership writers may
// not edit a migrated tree, even when their old client has not seen the barrier.
// guardLegacyCanonicalRequest 在 protected 分派前执行;历史回执 GET 可读,但旧快照读取和旧写命令被引导到模型接口。
// 返回 true 表示已经响应 409,调用方必须停止后续业务处理。
func (s *service) guardLegacyCanonicalRequest(w http.ResponseWriter, r *http.Request, project, account string) (bool, error) {
if r.PathValue("material") == "" {
return false, nil
}
path := r.URL.Path
legacy := strings.HasSuffix(path, "/canvas")
if r.Method != http.MethodGet {
for _, part := range []string{"/canvas/subgraphs", "/canvas/connections", "/canvas/transactions", "/canvas/operations"} {
legacy = legacy || strings.Contains(path, part)
}
}
if !legacy {
return false, nil
}
tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil {
return false, err
}
defer tx.Rollback()
if _, _, err = lockMaterial(r.Context(), tx, project, r.PathValue("workspace"), r.PathValue("material"), account); err != nil {
return false, err
}
root, err := canonicalRoot(r.Context(), tx, project, r.PathValue("workspace"), r.PathValue("material"))
if err != nil {
return false, err
}
if root == "" {
return false, nil
}
reply(w, 409, response{"error": "canonical_write_required", "root_id": root, "model_path": "canvas/model"})
return true, nil
}
+519
View File
@@ -0,0 +1,519 @@
// Canonical 读/迁移/写入口:冻结请求回执与逻辑操作去重,业务数据和回执同事务提交。
package platform
import (
"context"
"crypto/rand"
"database/sql"
"encoding/hex"
"encoding/json"
"io"
"net/http"
)
const modelMigrateAction = "model.migrate.v1"
const modelEditAction = "model.operations.v2"
// newModelID 用随机字节生成 UUIDv4,随机源失败返回空值,由调用方拒绝后续处理。
func newModelID() string {
var value [16]byte
if _, err := rand.Read(value[:]); err != nil {
return ""
}
value[6], value[8] = value[6]&0x0f|0x40, value[8]&0x3f|0x80
text := hex.EncodeToString(value[:])
return text[:8] + "-" + text[8:12] + "-" + text[12:16] + "-" + text[16:20] + "-" + text[20:]
}
// legacyModelRoot 沿活跃父链寻找旧树根,拒绝循环、归档和过深树。
func legacyModelRoot(r *http.Request, tx *sql.Tx, project, workspace, board string) (string, error) {
seen := map[string]bool{}
for len(seen) <= 8 {
if seen[board] {
return "", errCanvasModel
}
seen[board] = true
relation, err := readSubgraphRelation(r, tx, project, workspace, board)
if err == sql.ErrNoRows {
return board, nil
}
if err != nil {
return "", err
}
if relation.Archived {
return "", sql.ErrNoRows
}
board = relation.Parent
}
return "", errCanvasModel
}
// collectLegacyModel 收集根下最多 256 个 board 快照及关系,限额多取一项用于检测超限。
func collectLegacyModel(r *http.Request, tx *sql.Tx, project, workspace, root string) (map[string]canvasSnapshot, []subgraphRelation, error) {
rows, err := tx.QueryContext(r.Context(), `WITH RECURSIVE tree(id,path) AS (SELECT $3::uuid,ARRAY[$3::uuid] UNION ALL SELECT s.child_board_id,t.path||s.child_board_id FROM tree t JOIN canvas_subgraphs s ON s.project=$1 AND s.workspace_id=$2 AND s.parent_board_id=t.id WHERE s.archived_at IS NULL AND NOT s.child_board_id=ANY(t.path) AND cardinality(t.path)<=8) SELECT m.id::text,m.canvas_version,COALESCE(m.canvas_document,'{"schema_version":2,"nodes":[],"edges":[],"viewport":{"x":0,"y":0,"zoom":1}}'::jsonb) FROM tree t JOIN materials m ON m.project=$1 AND m.workspace_id=$2 AND m.id=t.id WHERE m.kind='board' ORDER BY m.id LIMIT 257`, project, workspace, root)
if err != nil {
return nil, nil, err
}
snapshots := map[string]canvasSnapshot{}
for rows.Next() {
var snapshot canvasSnapshot
if err = rows.Scan(&snapshot.BoardID, &snapshot.Version, &snapshot.Document); err != nil {
rows.Close()
return nil, nil, err
}
snapshots[snapshot.BoardID] = snapshot
}
err = rows.Err()
rows.Close()
if err != nil {
return nil, nil, err
}
if len(snapshots) == 0 || len(snapshots) > 256 {
return nil, nil, errGraphCapacity
}
rows, err = tx.QueryContext(r.Context(), `SELECT parent_board_id::text,frame_id,child_board_id::text FROM canvas_subgraphs WHERE project=$1 AND workspace_id=$2 AND archived_at IS NULL ORDER BY child_board_id`, project, workspace)
if err != nil {
return nil, nil, err
}
defer rows.Close()
relations := []subgraphRelation{}
for rows.Next() {
var relation subgraphRelation
if err = rows.Scan(&relation.Parent, &relation.Frame, &relation.Child); err != nil {
return nil, nil, err
}
if _, exists := snapshots[relation.Parent]; exists {
relations = append(relations, relation)
}
}
return snapshots, relations, rows.Err()
}
// modelRequestRetry 按项目/工作区/账户/request ID 查冻结回执,并核对根、动作和载荷摘要防止跨用途复用。
func modelRequestRetry(w http.ResponseWriter, r *http.Request, tx *sql.Tx, project, workspace, account, root, action, key, hash string) (bool, error) {
var previousRoot, previousAction, previousHash string
var status int
var body json.RawMessage
err := tx.QueryRowContext(r.Context(), `SELECT root_id::text,action,payload_hash,response_status,response_body FROM canvas_model_requests WHERE project=$1 AND workspace_id=$2 AND account_id=$3 AND request_id=$4`, project, workspace, account, key).Scan(&previousRoot, &previousAction, &previousHash, &status, &body)
if err == sql.ErrNoRows {
return false, nil
}
if err != nil {
return false, err
}
if previousRoot != root || previousAction != action || previousHash != hash {
reject(w, 409, "idempotency_conflict")
return true, nil
}
reply(w, status, body)
return true, nil
}
// commitModelReceipt 注入协议和请求 ID,保存应用或终局拒绝回执后提交;提交成功才对外响应。
func commitModelReceipt(w http.ResponseWriter, r *http.Request, tx *sql.Tx, project, workspace, account, root, action, key, hash string, status int, body response) error {
body["request_id"], body["protocol_version"] = key, canvasModelProtocol
raw, err := json.Marshal(body)
if err != nil {
return err
}
_, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_model_requests(project,workspace_id,account_id,request_id,root_id,action,protocol_version,payload_hash,response_status,response_body) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)`, project, workspace, account, key, root, action, canvasModelProtocol, hash, status, raw)
if err != nil {
return err
}
if err = tx.Commit(); err != nil {
return err
}
reply(w, status, body)
return nil
}
// decodeModelRequest 限制五 MiB、未知字段与尾随 JSON;失败立即写出 400。
func decodeModelRequest(w http.ResponseWriter, r *http.Request, input any) bool {
decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, canvasLimit))
decoder.DisallowUnknownFields()
if decoder.Decode(input) != nil || decoder.Decode(new(any)) != io.EOF {
reject(w, 400, "invalid_model_request")
return false
}
return true
}
// getCanvasModel 未迁移时返回根和源版本表;已迁移时读模型表,在发送 JSON/NDJSON 前释放锁。
func (s *service) getCanvasModel(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet {
reject(w, 405, "method_not_allowed")
return nil
}
tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil {
return err
}
defer tx.Rollback()
workspace, board := r.PathValue("workspace"), r.PathValue("material")
kind, _, err := lockMaterial(r.Context(), tx, project, workspace, board, account)
if err != nil {
return err
}
if kind != "board" {
reject(w, 400, "invalid_material")
return nil
}
root, err := canonicalRoot(r.Context(), tx, project, workspace, board)
if err != nil {
return err
}
if root == "" {
root, err = legacyModelRoot(r, tx, project, workspace, board)
if err != nil {
return err
}
snapshots, _, err := collectLegacyModel(r, tx, project, workspace, root)
if err != nil {
return err
}
versions := map[string]int64{}
for id, snapshot := range snapshots {
versions[id] = snapshot.Version
}
reply(w, 409, response{"error": "canonical_migration_required", "root_id": root, "source_versions": versions, "document_format_version": canvasModelFormat})
return nil
}
model, err := loadCanvasModel(r.Context(), tx, project, workspace, root)
if err != nil {
return err
}
if err = tx.Rollback(); err != nil {
return err
}
if r.Header.Get("Accept") == modelStreamType {
writeCanvasModelStream(r.Context(), w, model)
return nil
}
w.Header().Add("Vary", "Accept")
reply(w, 200, response{"model": model.view(nil)})
return nil
}
// migrateCanonicalCanvas 是显式身份屏障:完整确认旧树版本、等待在途 AI 结束,再保存模型及身份映射。
func (s *service) migrateCanonicalCanvas(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodPost {
reject(w, 405, "method_not_allowed")
return nil
}
var input struct {
ProtocolVersion int `json:"protocol_version"`
RequestID string `json:"request_id"`
Expected map[string]int64 `json:"expected_versions"`
}
if !decodeModelRequest(w, r, &input) {
return nil
}
key := canvasIdempotencyKey(r)
if input.ProtocolVersion != canvasModelProtocol || !uuidSlugPattern.MatchString(key) || input.RequestID != key || len(input.Expected) == 0 || len(input.Expected) > 256 {
reject(w, 400, "invalid_model_migration")
return nil
}
tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil {
return err
}
defer tx.Rollback()
workspace, board := r.PathValue("workspace"), r.PathValue("material")
kind, role, err := lockMaterial(r.Context(), tx, project, workspace, board, account)
if err != nil {
return err
}
if kind != "board" {
reject(w, 400, "invalid_material")
return nil
}
if role == "viewer" {
reject(w, 403, "forbidden")
return nil
}
root, err := canonicalRoot(r.Context(), tx, project, workspace, board)
if err != nil {
return err
}
already := root != ""
if !already {
root, err = legacyModelRoot(r, tx, project, workspace, board)
if err != nil {
return err
}
}
done, err := modelRequestRetry(w, r, tx, project, workspace, account, root, modelMigrateAction, key, payloadDigest(input))
if err != nil || done {
return err
}
// 已鉴权且可冻结的业务拒绝也入回执表,同请求不能在外部条件改变后变成新的执行。
rejectMigration := func(status int, code string) error {
return commitModelReceipt(w, r, tx, project, workspace, account, root, modelMigrateAction, key, payloadDigest(input), status, response{"status": "not-applied", "terminal": true, "error": code})
}
if already {
return rejectMigration(409, "canonical_migration_already_applied")
}
snapshots, relations, err := collectLegacyModel(r, tx, project, workspace, root)
if err != nil {
return err
}
if len(snapshots) != len(input.Expected) {
return rejectMigration(412, "migration_version_conflict")
}
for id, snapshot := range snapshots {
if input.Expected[id] != snapshot.Version {
return rejectMigration(412, "migration_version_conflict")
}
}
// Active or outcome-unknown paid work must settle before the identity barrier.
for id := range snapshots {
var busy bool
if err = tx.QueryRowContext(r.Context(), `SELECT EXISTS(SELECT 1 FROM canvas_ai_steps WHERE project=$1 AND workspace_id=$2 AND board_id=$3 AND status IN('queued','running'))`, project, workspace, id).Scan(&busy); err != nil {
return err
}
if busy {
return rejectMigration(409, "migration_waiting_for_runs")
}
}
migration, err := migrateCanvasModel(root, snapshots, relations, newModelID)
if err != nil {
return rejectMigration(422, "model_migration_failed")
}
versionsRaw, _ := json.Marshal(input.Expected)
_, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_model_projects(project,workspace_id,root_id,migration_id,source_versions) VALUES($1,$2,$3,$4,$5)`, project, workspace, root, key, versionsRaw)
if err != nil {
return err
}
before := emptyModel(root)
for id, snapshot := range snapshots {
before.Versions[id] = snapshot.Version
}
participants := map[string]bool{}
for id := range migration.Model.Canvases {
participants[id] = true
}
if err = s.saveCanvasModel(r, tx, project, workspace, account, before, migration.Model, participants); err != nil {
return err
}
for _, identity := range migration.Identities {
_, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_model_identity_map(project,workspace_id,root_id,source_canvas_id,source_structure,source_element_id,element_id) VALUES($1,$2,$3,$4,$5,$6,$7)`, project, workspace, root, identity.SourceCanvasID, identity.Structure, identity.SourceID, identity.ElementID)
if err != nil {
return err
}
}
return commitModelReceipt(w, r, tx, project, workspace, account, root, modelMigrateAction, key, payloadDigest(input), 200, response{"status": "applied", "model": migration.Model.view(nil), "identity_map": migration.Identities, "source_versions": input.Expected})
}
// submitCanvasModelOperations 校验预期版本与跨请求逻辑操作 ID,运行纯 reducer 后检查完整参与者和资产权限。
func (s *service) submitCanvasModelOperations(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodPost {
reject(w, 405, "method_not_allowed")
return nil
}
var input modelBatch
if !decodeModelRequest(w, r, &input) {
return nil
}
key := canvasIdempotencyKey(r)
if input.ProtocolVersion != canvasModelProtocol || !uuidSlugPattern.MatchString(key) || input.RequestID != key || len(input.Expected) == 0 || len(input.Expected) > 256 || len(input.Operations) == 0 || len(input.Operations) > 2500 {
reject(w, 400, "invalid_model_request")
return nil
}
for id, version := range input.Expected {
if !uuidSlugPattern.MatchString(id) || version < 0 || version > 9007199254740990 {
reject(w, 400, "invalid_model_version")
return nil
}
}
tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil {
return err
}
defer tx.Rollback()
workspace, board := r.PathValue("workspace"), r.PathValue("material")
kind, role, err := lockMaterial(r.Context(), tx, project, workspace, board, account)
if err != nil {
return err
}
if kind != "board" {
reject(w, 400, "invalid_material")
return nil
}
if role == "viewer" {
reject(w, 403, "forbidden")
return nil
}
root, err := canonicalRoot(r.Context(), tx, project, workspace, board)
if err != nil {
return err
}
if root == "" {
reject(w, 409, "canonical_migration_required")
return nil
}
done, err := modelRequestRetry(w, r, tx, project, workspace, account, root, modelEditAction, key, payloadDigest(input))
if err != nil || done {
return err
}
// terminal not-applied 冻结本次确定拒绝;连接故障等未定结果返回依赖错误,由客户端同键查询/重试。
rejectBatch := func(status int, code string) error {
return commitModelReceipt(w, r, tx, project, workspace, account, root, modelEditAction, key, payloadDigest(input), status, response{"status": "not-applied", "terminal": true, "error": code})
}
before, err := loadCanvasModel(r.Context(), tx, project, workspace, root)
if err != nil {
return err
}
for id, expected := range input.Expected {
if before.Versions[id] != expected {
return rejectBatch(412, "version_conflict")
}
}
// operation_id 独立于 request_id,防止同一逻辑编辑被换请求键再次应用。
for _, operation := range input.Operations {
if !uuidSlugPattern.MatchString(operation.ID) {
return rejectBatch(400, "invalid_model_operation")
}
var used bool
if err = tx.QueryRowContext(r.Context(), `SELECT EXISTS(SELECT 1 FROM canvas_model_operations WHERE project=$1 AND workspace_id=$2 AND operation_id=$3)`, project, workspace, operation.ID).Scan(&used); err != nil {
return err
}
if used {
return rejectBatch(409, "operation_already_applied")
}
}
after, touched, err := applyModelOperations(before, input.Operations)
if err != nil {
code := "invalid_model_operation"
if err == errModelConflict {
code = "canvas_model_field_conflict"
}
return rejectBatch(409, code)
}
// reducer 识别的读写参与者都必须在 Expected 中;额外明确参与者也推进一次版本。
for id := range touched {
if _, exists := input.Expected[id]; !exists {
return rejectBatch(428, "version_required")
}
}
for id := range input.Expected {
if _, existed := before.Versions[id]; !existed {
if _, created := after.Canvases[id]; !created {
return rejectBatch(409, "invalid_model_participant")
}
var exists bool
if err = tx.QueryRowContext(r.Context(), `SELECT EXISTS(SELECT 1 FROM materials WHERE project=$1 AND workspace_id=$2 AND id=$3)`, project, workspace, id).Scan(&exists); err != nil {
return err
}
if exists {
return rejectBatch(409, "canvas_identity_conflict")
}
}
if !touched[id] {
touched[id] = true
after.Versions[id] = before.Versions[id] + 1
}
}
// 新身份不能占用同项目其他树的元素 ID;新增或更换资产引用须按当前授权重新核对。
for id, element := range after.Elements {
if before.Elements[id] == nil {
var foreign bool
if err = tx.QueryRowContext(r.Context(), `SELECT EXISTS(SELECT 1 FROM canvas_model_elements WHERE project=$1 AND element_id=$2 AND (workspace_id<>$3 OR root_id<>$4))`, project, id, workspace, root).Scan(&foreign); err != nil {
return err
}
if foreign {
return rejectBatch(409, "element_identity_conflict")
}
}
if element["structure"] == "node" {
data := element["data"].(map[string]any)
if asset := modelString(data["assetId"]); asset != "" {
prior := before.Elements[id]
if prior == nil || !modelEqual(prior["data"].(map[string]any)["assetId"], data["assetId"]) {
readable, e := assetReadable(r, tx, project, workspace, asset, account)
if e != nil {
return e
}
if !readable {
return rejectBatch(400, "invalid_asset_reference")
}
}
}
}
}
for id := range after.DeadRecords {
if before.Elements[id] != nil || before.Tombstones[id] > 0 {
continue
}
var foreign bool
if err = tx.QueryRowContext(r.Context(), `SELECT EXISTS(SELECT 1 FROM canvas_model_elements WHERE project=$1 AND element_id=$2 AND (workspace_id<>$3 OR root_id<>$4))`, project, id, workspace, root).Scan(&foreign); err != nil {
return err
}
if foreign {
return rejectBatch(409, "element_identity_conflict")
}
}
if err = s.saveCanvasModel(r, tx, project, workspace, account, before, after, touched); err != nil {
return err
}
ids := []string{}
for _, operation := range input.Operations {
ids = append(ids, operation.ID)
_, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_model_operations(project,workspace_id,operation_id,request_id,account_id) VALUES($1,$2,$3,$4,$5)`, project, workspace, operation.ID, key, account)
if err != nil {
return err
}
}
return commitModelReceipt(w, r, tx, project, workspace, account, root, modelEditAction, key, payloadDigest(input), 200, response{"status": "applied", "operation_ids": ids, "model": after.view(input.Expected)})
}
// getCanvasModelOperation 当前授权后只返回本人同根冻结回执;缺记录为 unknown,不能声称确定没有执行。
func (s *service) getCanvasModelOperation(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet {
reject(w, 405, "method_not_allowed")
return nil
}
key := r.PathValue("request")
if !uuidSlugPattern.MatchString(key) {
reject(w, 400, "invalid_request_id")
return nil
}
tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil {
return err
}
defer tx.Rollback()
workspace, board := r.PathValue("workspace"), r.PathValue("material")
if _, _, err = lockMaterial(r.Context(), tx, project, workspace, board, account); err != nil {
return err
}
root, err := canonicalRoot(r.Context(), tx, project, workspace, board)
if err != nil {
return err
}
if root == "" {
root, err = legacyModelRoot(r, tx, project, workspace, board)
if err != nil {
return err
}
}
var body json.RawMessage
err = tx.QueryRowContext(r.Context(), `SELECT response_body FROM canvas_model_requests WHERE project=$1 AND workspace_id=$2 AND account_id=$3 AND request_id=$4 AND root_id=$5`, project, workspace, account, key, root).Scan(&body)
if err == sql.ErrNoRows {
reply(w, 404, response{"status": "unknown", "error": "operation_receipt_unknown", "request_id": key})
return nil
}
if err != nil {
return err
}
if err = tx.Rollback(); err != nil {
return err
}
reply(w, 200, body)
return nil
}
// modelExists 为其他平台流程提供是否已进入 canonical 树的轻量查询。
func modelExists(ctx context.Context, tx *sql.Tx, project, workspace, board string) (bool, error) {
root, err := canonicalRoot(ctx, tx, project, workspace, board)
return root != "", err
}
@@ -0,0 +1,415 @@
// Canonical 生命周期综合回归:使用真实 HTTP 与隔离 PostgreSQL,覆盖迁移屏障和增量写入持久化。
package platform
import (
"bytes"
"context"
"crypto/rand"
"crypto/sha256"
"database/sql"
"encoding/base64"
"encoding/hex"
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"testing"
)
// TestCanonicalModelMigrationAndIncrementalLifecycle 从旧 frame 分区迁移开始,逐步验证稳定身份、局部版本、墓碑和逻辑去重。
// 依赖 PLATFORM_TEST_DATABASE_URL;后续各段沿用前段版本,失败应在最早断言处定位。
func TestCanonicalModelMigrationAndIncrementalLifecycle(t *testing.T) {
dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL")
if dsn == "" {
t.Skip("requires an isolated integration database")
}
db, err := sql.Open("pgx", dsn)
if err != nil {
t.Fatal(err)
}
defer db.Close()
ctx := context.Background()
var entropy [12]byte
_, _ = rand.Read(entropy[:])
project := "canonical-" + hex.EncodeToString(entropy[:])
defer func() {
for _, table := range []string{"canvas_model_operations", "canvas_model_identity_map", "canvas_model_requests", "canvas_model_projects", "canvas_asset_bindings", "canvas_subgraphs", "workspaces", "project_accounts"} {
_, _ = db.ExecContext(ctx, "DELETE FROM "+table+" WHERE project=$1", project)
}
}()
var account, workspace, root string
if err = db.QueryRowContext(ctx, `INSERT INTO project_accounts(project,id) VALUES($1,gen_random_uuid()) RETURNING id::text`, project).Scan(&account); err != nil {
t.Fatal(err)
}
var tokenBytes [32]byte
_, _ = rand.Read(tokenBytes[:])
token := base64.RawURLEncoding.EncodeToString(tokenBytes[:])
hash := sha256.Sum256([]byte(token))
if _, err = db.ExecContext(ctx, `INSERT INTO project_sessions(token_hash,project,account_id,expires_at) VALUES($1,$2,$3,now()+interval '1 hour')`, base64.RawURLEncoding.EncodeToString(hash[:]), project, account); err != nil {
t.Fatal(err)
}
if err = db.QueryRowContext(ctx, `INSERT INTO workspaces(project,name,owner_id) VALUES($1,'Canonical',$2) RETURNING id::text`, project, account).Scan(&workspace); err != nil {
t.Fatal(err)
}
if _, err = db.ExecContext(ctx, `INSERT INTO workspace_members(project,workspace_id,account_id,role) VALUES($1,$2,$3,'admin')`, project, workspace, account); err != nil {
t.Fatal(err)
}
legacy := json.RawMessage(`{"schema_version":1,"nodes":[` + modelLegacyFrame + `,{"id":"a","type":"plainText","position":{"x":150,"y":260},"width":240,"height":72,"data":{"kind":"plain-text","title":"a","text":"preserved","frameId":"f"}}],"edges":[],"viewport":{"x":0,"y":0,"zoom":1}}`)
if err = db.QueryRowContext(ctx, `INSERT INTO materials(project,workspace_id,kind,title,created_by,canvas_document) VALUES($1,$2,'board','Root',$3,$4) RETURNING id::text`, project, workspace, account, legacy).Scan(&root); err != nil {
t.Fatal(err)
}
mux := http.NewServeMux()
Register(mux, db, map[string]string{project: "https://app.example.com/auth/callback"}, "https://api.example.com", nil)
base := "/projects/" + project + "/workspaces/" + workspace + "/materials/" + root + "/canvas"
// call 经完整认证路由发请求;read 则从模型表独立重建,避免只相信回执中的内存结果。
call := func(method, path string, input any, key string, status int) response {
t.Helper()
raw, _ := json.Marshal(input)
request := httptest.NewRequest(method, path, bytes.NewReader(raw))
request.Header.Set("Authorization", "Bearer "+token)
request.Header.Set("Accept", "application/vnd.foundry.canvas+json;version=2")
if key != "" {
request.Header.Set("Idempotency-Key", key)
}
writer := httptest.NewRecorder()
mux.ServeHTTP(writer, request)
if writer.Code != status {
t.Fatalf("%s %s got %d %s want %d", method, path, writer.Code, writer.Body.String(), status)
}
out := response{}
if writer.Body.Len() > 0 {
if err := json.Unmarshal(writer.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
}
return out
}
read := func() canvasModel {
t.Helper()
tx, err := db.BeginTx(ctx, nil)
if err != nil {
t.Fatal(err)
}
defer tx.Rollback()
model, err := loadCanvasModel(ctx, tx, project, workspace, root)
if err != nil {
t.Fatal(err)
}
return model
}
// GET 只返回迁移需求,不隐式分配身份;显式迁移成功后旧 HTTP/数据库快照写入都应被屏障拦住。
if call("GET", base+"/model", nil, "", 409)["error"] != "canonical_migration_required" {
t.Fatal("legacy read silently migrated")
}
var count int
if err = db.QueryRowContext(ctx, `SELECT count(*) FROM canvas_model_projects WHERE project=$1`, project).Scan(&count); err != nil || count != 0 {
t.Fatal("GET created a canonical project")
}
migrationKey := modelTestID(1000)
migrationInput := response{"protocol_version": 2, "request_id": migrationKey, "expected_versions": map[string]int64{root: 1}}
migration := call("POST", base+"/model/migrate", migrationInput, migrationKey, 200)
if migration["status"] != "applied" {
t.Fatal("migration missing applied receipt")
}
retry := call("POST", base+"/model/migrate", migrationInput, migrationKey, 200)
if !modelEqual(migration["identity_map"], retry["identity_map"]) {
t.Fatal("migration retry allocated a second identity map")
}
identities := migration["identity_map"].([]any)
nodeID, frameID := "", ""
for _, item := range identities {
mapping := item.(map[string]any)
switch mapping["sourceId"] {
case "a":
nodeID = mapping["elementId"].(string)
case "f":
frameID = mapping["elementId"].(string)
}
}
model := read()
if nodeID == "" || frameID == "" || len(model.Canvases) != 2 {
t.Fatal("migration lost identities or an implicit partition")
}
child := modelString(model.Elements[nodeID]["ownerCanvasId"])
if child == root || model.Canvases[child].Parent.EntryElementID != frameID || model.Versions[root] != 2 || model.Versions[child] != 1 {
t.Fatal("canonical owning tree or version barrier is incorrect")
}
if call("PATCH", base, response{"document": legacy}, "", 409)["error"] != "canonical_write_required" {
t.Fatal("old snapshot writer can overwrite canonical records")
}
call("GET", base, nil, "", 409)
if _, err = db.ExecContext(ctx, `UPDATE materials SET canvas_document=$4,canvas_version=canvas_version+1 WHERE project=$1 AND workspace_id=$2 AND id=$3`, project, workspace, root, legacy); err == nil {
t.Fatal("database identity barrier allowed an old writer")
}
// 每个 edit 分配不同请求与逻辑操作 ID,预期版本由用例显式给出,避免辅助函数掩盖版本错误。
edit := func(n int, versions map[string]int64, changes ...modelChange) response {
t.Helper()
key := modelTestID(n)
input := modelBatch{ProtocolVersion: 2, RequestID: key, Expected: versions, Operations: []modelOperation{{ID: modelTestID(n + 10000), Changes: changes}}}
return call("POST", base+"/model/operations", input, key, 200)
}
titleChange := modelChange{Kind: "field", Target: modelTarget{ID: nodeID, Incarnation: 1}, Field: "data.title", Before: modelJSON("a"), After: modelJSON("renamed")}
first := edit(1001, map[string]int64{child: 1}, titleChange)
if first["model"].(map[string]any)["complete"] != false {
t.Fatal("operation receipt pretends to be a full project snapshot")
}
model = read()
if model.Versions[root] != 2 || model.Versions[child] != 2 || model.Elements[nodeID]["data"].(map[string]any)["text"] != "preserved" {
t.Fatal("child edit changed unrelated canvas/version/content")
}
requestKey := modelTestID(1001)
repeat := modelBatch{ProtocolVersion: 2, RequestID: requestKey, Expected: map[string]int64{child: 1}, Operations: []modelOperation{{ID: modelTestID(11001), Changes: []modelChange{titleChange}}}}
call("POST", base+"/model/operations", repeat, requestKey, 200)
if read().Versions[child] != 2 {
t.Fatal("exact retry executed twice")
}
if call("GET", base+"/model/operations/"+requestKey, nil, "", 200)["status"] != "applied" {
t.Fatal("lost ACK cannot be queried")
}
if call("GET", base+"/model/operations/"+modelTestID(9999), nil, "", 404)["status"] != "unknown" {
t.Fatal("missing receipt claimed zero writes")
}
// Move is a row owner update, retaining ElementId and incarnation.
// 元素移动只改 owner 与几何,不能删除再新建或改变 incarnation。
geometry := model.Elements[nodeID]["geometry"]
edit(1002, map[string]int64{root: 2, child: 2}, modelChange{Kind: "field", Target: modelTarget{ID: nodeID, Incarnation: 1}, Field: "ownerCanvasId", Before: modelJSON(child), After: modelJSON(root)}, modelChange{Kind: "field", Target: modelTarget{ID: nodeID, Incarnation: 1}, Field: "geometry", Before: modelJSON(geometry), After: modelJSON(map[string]any{"x": 150, "y": 260, "width": 240, "height": 72, "rotation": 0})})
model = read()
if model.Elements[nodeID]["ownerCanvasId"] != root || modelInt(model.Elements[nodeID]["incarnation"]) != 1 {
t.Fatal("move recreated the element")
}
// Future component/envelope bytes survive editing another object and legacy projections.
// 不认识的组件/数据版本和 envelope 作为不透明 JSON 保留,不因生成兼容快照而丢失。
opaqueID := modelTestID(3000)
opaque := modelTestNode(opaqueID, root)
opaque["componentId"], opaque["dataVersion"], opaque["data"], opaque["futureEnvelope"] = "future.plugin", float64(9), map[string]any{"raw": []any{map[string]any{"keep": true}}}, map[string]any{"extension": "retained"}
edit(1003, map[string]int64{root: 3}, modelChange{Kind: "element", ID: opaqueID, Before: modelJSON(nil), After: modelJSON(opaque)})
model = read()
if !modelEqual(model.Elements[opaqueID], opaque) {
t.Fatal("future component data changed")
}
edit(1004, map[string]int64{root: 4}, modelChange{Kind: "element", ID: nodeID, Before: modelJSON(model.Elements[nodeID]), After: modelJSON(nil)})
model = read()
if model.Tombstones[nodeID] != 1 {
t.Fatal("delete did not persist its lifecycle tombstone")
}
// 恢复同 ID 需升级 incarnation,旧代回调得到确定拒绝且不得改动任何版本或旁观元素。
restored := modelTestNode(nodeID, root)
restored["componentId"] = "plain-text"
restored["incarnation"] = float64(2)
restored["data"].(map[string]any)["title"] = "restored"
edit(1005, map[string]int64{root: 5}, modelChange{Kind: "element", ID: nodeID, Before: modelJSON(nil), After: modelJSON(restored)})
staleKey := modelTestID(1006)
stale := modelBatch{ProtocolVersion: 2, RequestID: staleKey, Expected: map[string]int64{root: 6}, Operations: []modelOperation{{ID: modelTestID(11006), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: nodeID, Incarnation: 1}, Field: "data.title", Before: modelJSON("restored"), After: modelJSON("stale callback")}}}}}
if call("POST", base+"/model/operations", stale, staleKey, 409)["status"] != "not-applied" {
t.Fatal("stale callback did not receive a zero-write receipt")
}
if call("GET", base+"/model/operations/"+staleKey, nil, "", 200)["terminal"] != true {
t.Fatal("terminal rejection was not queryable")
}
model = read()
if model.Versions[root] != 6 || !modelEqual(model.Elements[opaqueID], opaque) || modelInt(model.Elements[nodeID]["incarnation"]) != 2 {
t.Fatal("stale callback or unrelated update damaged state")
}
duplicateKey := modelTestID(1007)
duplicate := modelBatch{ProtocolVersion: 2, RequestID: duplicateKey, Expected: map[string]int64{root: 6}, Operations: []modelOperation{{ID: modelTestID(11002), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: nodeID, Incarnation: 2}, Field: "data.title", Before: modelJSON("restored"), After: modelJSON("duplicate effect")}}}}}
if call("POST", base+"/model/operations", duplicate, duplicateKey, 409)["error"] != "operation_already_applied" {
t.Fatal("logical operation was executed under a new request ID")
}
var owner string
var incarnation int64
if err = db.QueryRowContext(ctx, `SELECT owner_canvas_id::text,incarnation FROM canvas_model_elements WHERE project=$1 AND element_id=$2 AND NOT deleted`, project, nodeID).Scan(&owner, &incarnation); err != nil || owner != root || incarnation != 2 {
t.Fatal("canonical row authority disagrees with the API")
}
if call("GET", base+"/model", nil, "", 200)["model"].(map[string]any)["complete"] != true {
t.Fatal("initial read has no explicit coverage")
}
// Negotiate the same authenticated canonical read as a streamed transfer.
// 相同授权入口协商 NDJSON,头部版本与真实模型一致,末尾必须存在 complete。
streamRequest := httptest.NewRequest("GET", base+"/model", nil)
streamRequest.Header.Set("Authorization", "Bearer "+token)
streamRequest.Header.Set("Accept", modelStreamType)
streamWriter := httptest.NewRecorder()
mux.ServeHTTP(streamWriter, streamRequest)
streamed := streamRecords(t, streamWriter)
if streamWriter.Code != 200 || streamWriter.Header().Get("Content-Type") != modelStreamType || len(streamed) < 2 || streamed[0]["projectId"] != root || streamed[len(streamed)-1]["kind"] != "complete" || !modelEqual(streamed[0]["versions"], read().Versions) {
t.Fatal("authenticated stream lost canonical snapshot coverage")
}
// An object created and removed inside one transaction still has a lifecycle fact.
// 同批创建又删除仍要留下墓碑和死记录,不能当作未发生而允许旧生命周期被再次接受。
ghostID := modelTestID(4000)
ghost := modelTestNode(ghostID, root)
edit(1008, map[string]int64{root: 6}, modelChange{Kind: "element", ID: ghostID, Before: modelJSON(nil), After: modelJSON(ghost)}, modelChange{Kind: "element", ID: ghostID, Before: modelJSON(ghost), After: modelJSON(nil)})
model = read()
if model.Tombstones[ghostID] != 1 || model.Elements[ghostID] != nil {
t.Fatal("in-batch create/delete lost its tombstone")
}
ghost["incarnation"] = float64(2)
edit(1009, map[string]int64{root: 7}, modelChange{Kind: "element", ID: ghostID, Before: modelJSON(nil), After: modelJSON(ghost)})
if modelInt(read().Elements[ghostID]["incarnation"]) != 2 {
t.Fatal("restore after an in-batch delete did not preserve identity")
}
// Session changes cannot send an old account's queued request as a new account.
request := httptest.NewRequest("GET", base+"/model", nil)
request.Header.Set("Authorization", "Bearer "+token)
request.Header.Set("X-Expected-Account", modelTestID(7777))
writer := httptest.NewRecorder()
mux.ServeHTTP(writer, request)
if writer.Code != 409 {
t.Fatal("expected-account barrier was ignored")
}
// A new partition's entry, owning canvas and versions publish atomically.
// 新画布以期望版本零参与,入口节点和树关系同批创建;归档/恢复保留版本围栏。
newCanvas, newFrame := modelTestID(5000), modelTestID(5001)
frame := modelTestNode(newFrame, root)
frame["componentId"] = "frame"
canvas := modelCanvas{ID: newCanvas, Parent: &modelParent{CanvasID: root, EntryElementID: newFrame}}
edit(1010, map[string]int64{root: 8, newCanvas: 0}, modelChange{Kind: "canvas", ID: newCanvas, Before: modelJSON(nil), After: modelJSON(canvas)}, modelChange{Kind: "element", ID: newFrame, Before: modelJSON(nil), After: modelJSON(frame)})
model = read()
if model.Versions[newCanvas] != 1 || model.Canvases[newCanvas].Parent.EntryElementID != newFrame {
t.Fatal("partition creation was not atomic")
}
edit(1011, map[string]int64{root: 9, newCanvas: 1}, modelChange{Kind: "canvas", ID: newCanvas, Before: modelJSON(canvas), After: modelJSON(nil)}, modelChange{Kind: "element", ID: newFrame, Before: modelJSON(frame), After: modelJSON(nil)})
model = read()
if _, exists := model.Canvases[newCanvas]; exists || model.Versions[newCanvas] != 2 {
t.Fatal("partition archive lost its version fence")
}
frame["incarnation"] = float64(2)
edit(1012, map[string]int64{root: 10, newCanvas: 2}, modelChange{Kind: "element", ID: newFrame, Before: modelJSON(nil), After: modelJSON(frame)}, modelChange{Kind: "canvas", ID: newCanvas, Before: modelJSON(nil), After: modelJSON(canvas)})
model = read()
if model.Versions[newCanvas] != 3 || modelInt(model.Elements[newFrame]["incarnation"]) != 2 {
t.Fatal("partition restore reused a stale lifecycle or version")
}
// A cross-scale entry move writes ownership, child binding and presentation units together.
// 跨缩放移动同时更改 owner、geometry、presentation 单位元数据和孩子 Parent,内部成员记录应不变。
innerCanvas, innerFrame, memberID := modelTestID(5100), modelTestID(5101), modelTestID(5102)
container := modelTestNode(innerFrame, root)
container["componentId"] = "frame"
originalPresentation := response{"contentScale": .75, "future": response{"keep": "metadata"}}
container["data"].(map[string]any)["presentation"] = originalPresentation
member := modelTestNode(memberID, innerCanvas)
member["data"].(map[string]any)["fontSize"] = float64(17)
inner := modelCanvas{ID: innerCanvas, Parent: &modelParent{CanvasID: root, EntryElementID: innerFrame}}
absent := false
edit(1013, map[string]int64{root: model.Versions[root], newCanvas: model.Versions[newCanvas], innerCanvas: 0},
modelChange{Kind: "field", Target: modelTarget{ID: newFrame, Incarnation: 2}, Field: "data.presentation", Before: modelJSON(nil), BeforePresent: &absent, After: modelJSON(response{"contentScale": 2})},
modelChange{Kind: "element", ID: innerFrame, Before: modelJSON(nil), After: modelJSON(container)},
modelChange{Kind: "canvas", ID: innerCanvas, Before: modelJSON(nil), After: modelJSON(inner)},
modelChange{Kind: "element", ID: memberID, Before: modelJSON(nil), After: modelJSON(member)})
model = read()
oldGeometry := model.Elements[innerFrame]["geometry"]
containerGeometry := oldGeometry.(map[string]any)
normalizedGeometry := response{"x": (containerGeometry["x"].(float64) - 24) / 2, "y": (containerGeometry["y"].(float64) - 36) / 2, "width": containerGeometry["width"].(float64) / 2, "height": containerGeometry["height"].(float64) / 2, "rotation": containerGeometry["rotation"]}
normalizedPresentation := response{"contentScale": .75, "unitScale": .5, "future": response{"keep": "metadata"}}
movedInner := inner
movedInner.Parent = &modelParent{CanvasID: newCanvas, EntryElementID: innerFrame}
edit(1014, map[string]int64{root: model.Versions[root], newCanvas: model.Versions[newCanvas], innerCanvas: model.Versions[innerCanvas]},
modelChange{Kind: "field", Target: modelTarget{ID: innerFrame, Incarnation: 1}, Field: "ownerCanvasId", Before: modelJSON(root), After: modelJSON(newCanvas)},
modelChange{Kind: "field", Target: modelTarget{ID: innerFrame, Incarnation: 1}, Field: "geometry", Before: modelJSON(oldGeometry), After: modelJSON(normalizedGeometry)},
modelChange{Kind: "field", Target: modelTarget{ID: innerFrame, Incarnation: 1}, Field: "data.presentation", Before: modelJSON(originalPresentation), After: modelJSON(normalizedPresentation)},
modelChange{Kind: "canvas", ID: innerCanvas, Before: modelJSON(inner), After: modelJSON(movedInner)})
model = read()
if modelString(model.Elements[innerFrame]["ownerCanvasId"]) != newCanvas || model.Canvases[innerCanvas].Parent.CanvasID != newCanvas || !modelEqual(model.Elements[innerFrame]["data"].(map[string]any)["presentation"], normalizedPresentation) || !modelEqual(model.Elements[memberID], member) {
t.Fatal("scaled container move changed its member or lost the atomic unit/ownership boundary")
}
if call("GET", base+"/model/operations/"+modelTestID(1014), nil, "", 200)["status"] != "applied" {
t.Fatal("scaled move receipt was not queryable by its original identity")
}
edit(1015, map[string]int64{root: model.Versions[root], newCanvas: model.Versions[newCanvas], innerCanvas: model.Versions[innerCanvas]},
modelChange{Kind: "field", Target: modelTarget{ID: innerFrame, Incarnation: 1}, Field: "ownerCanvasId", Before: modelJSON(newCanvas), After: modelJSON(root)},
modelChange{Kind: "field", Target: modelTarget{ID: innerFrame, Incarnation: 1}, Field: "geometry", Before: modelJSON(normalizedGeometry), After: modelJSON(oldGeometry)},
modelChange{Kind: "field", Target: modelTarget{ID: innerFrame, Incarnation: 1}, Field: "data.presentation", Before: modelJSON(normalizedPresentation), After: modelJSON(originalPresentation)},
modelChange{Kind: "canvas", ID: innerCanvas, Before: modelJSON(movedInner), After: modelJSON(inner)})
model = read()
if _, exists := model.Elements[innerFrame]["data"].(map[string]any)["presentation"].(map[string]any)["unitScale"]; exists || !modelEqual(model.Elements[memberID], member) || model.Canvases[innerCanvas].Parent.CanvasID != root {
t.Fatal("scaled move inverse did not restore absent unit metadata and the original child binding")
}
// Several logical edits share one atomic request while retaining every deduplication identity.
// 多逻辑编辑共用一个事务和版本增量,但每个原操作 ID 都必须登记并禁止换请求键重放。
batchKey, firstLogical, secondLogical := modelTestID(1016), modelTestID(22001), modelTestID(22002)
batchVersion := model.Versions[innerCanvas]
batch := modelBatch{ProtocolVersion: 2, RequestID: batchKey, Expected: map[string]int64{innerCanvas: batchVersion}, Operations: []modelOperation{
{ID: firstLogical, Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: memberID, Incarnation: 1}, Field: "data.title", Before: modelJSON(memberID), After: modelJSON("intermediate")}}},
{ID: secondLogical, Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: memberID, Incarnation: 1}, Field: "data.title", Before: modelJSON("intermediate"), After: modelJSON("batched")}}},
}}
batched := call("POST", base+"/model/operations", batch, batchKey, 200)
if !modelEqual(batched["operation_ids"], []string{firstLogical, secondLogical}) {
t.Fatal("batch receipt did not cover every original logical ID")
}
model = read()
if model.Versions[innerCanvas] != batchVersion+1 || modelString(model.Elements[memberID]["data"].(map[string]any)["title"]) != "batched" {
t.Fatal("batch lost ordered conditions or advanced the canvas version more than once")
}
if !modelEqual(call("GET", base+"/model/operations/"+batchKey, nil, "", 200), batched) || !modelEqual(call("POST", base+"/model/operations", batch, batchKey, 200), batched) {
t.Fatal("batch query/retry did not return its original receipt")
}
batch.RequestID = modelTestID(1017)
batch.Expected[innerCanvas] = model.Versions[innerCanvas]
batch.Operations = batch.Operations[:1]
if call("POST", base+"/model/operations", batch, batch.RequestID, 409)["error"] != "operation_already_applied" {
t.Fatal("a covered logical ID was executable under a new request key")
}
// A later failed condition cannot publish the earlier edit or consume its logical identity.
// 后一个 before 条件失败必须回滚先成功的内存前缀,也不能消费该前缀的逻辑操作 ID。
failedKey := modelTestID(1018)
batch.RequestID = failedKey
batch.Operations = []modelOperation{
{ID: modelTestID(22003), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: memberID, Incarnation: 1}, Field: "data.title", Before: modelJSON("batched"), After: modelJSON("must roll back")}}},
{ID: modelTestID(22004), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: memberID, Incarnation: 1}, Field: "data.title", Before: modelJSON("wrong before"), After: modelJSON("invalid")}}},
}
if call("POST", base+"/model/operations", batch, failedKey, 409)["status"] != "not-applied" {
t.Fatal("failed batch did not produce a zero-write terminal receipt")
}
model = read()
if model.Versions[innerCanvas] != batchVersion+1 || modelString(model.Elements[memberID]["data"].(map[string]any)["title"]) != "batched" {
t.Fatal("a failed batch leaked its successful prefix")
}
var consumed int
if err = db.QueryRowContext(ctx, `SELECT count(*) FROM canvas_model_operations WHERE project=$1 AND operation_id=$2`, project, modelTestID(22003)).Scan(&consumed); err != nil || consumed != 0 {
t.Fatal("a rejected atomic prefix consumed a logical operation ID")
}
// A compacted wire projection retains prefix IDs with conditional no-ops, including in a child scope.
// 压缩后的 wire 批次用条件无操作保留前缀身份;只触及孩子版本且保留创建/删除生命周期事实。
projectedKey, guardLogical, effectLogical := modelTestID(1019), modelTestID(22005), modelTestID(22006)
projectedGhost := modelTestID(5200)
finalGhost := modelTestNode(projectedGhost, innerCanvas)
finalGhost["data"].(map[string]any)["text"] = "composed final value"
parentVersion := model.Versions[root]
projection := modelBatch{ProtocolVersion: 2, RequestID: projectedKey, Expected: map[string]int64{innerCanvas: model.Versions[innerCanvas]}, Operations: []modelOperation{
{ID: guardLogical, Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: memberID, Incarnation: 1}, Field: "data.title", Before: modelJSON("batched"), After: modelJSON("batched")}}},
{ID: effectLogical, Changes: []modelChange{
{Kind: "field", Target: modelTarget{ID: memberID, Incarnation: 1}, Field: "data.title", Before: modelJSON("batched"), After: modelJSON("projected final")},
{Kind: "element", ID: projectedGhost, Before: modelJSON(nil), After: modelJSON(finalGhost)},
{Kind: "element", ID: projectedGhost, Before: modelJSON(finalGhost), After: modelJSON(nil)},
}},
}}
projectedReceipt := call("POST", base+"/model/operations", projection, projectedKey, 200)
model = read()
if !modelEqual(projectedReceipt["operation_ids"], []string{guardLogical, effectLogical}) || model.Versions[innerCanvas] != batchVersion+2 || model.Versions[root] != parentVersion {
t.Fatal("projected prefix lost its logical coverage or widened the child writer scope")
}
if modelString(model.Elements[memberID]["data"].(map[string]any)["title"]) != "projected final" || model.Tombstones[projectedGhost] != 1 || !modelEqual(model.DeadRecords[projectedGhost], finalGhost) {
t.Fatal("projected effect lost final data, tombstone or archived lifecycle record")
}
if !modelEqual(call("GET", base+"/model/operations/"+projectedKey, nil, "", 200), projectedReceipt) {
t.Fatal("compacted projection receipt was not recoverable by its original key")
}
// A locally canceled incarnation was never sent; undo may first publish incarnation 2.
// 本地取消且从未发送的第一代没有服务端墓碑;首次发布第二代仍合法,旧代回调不可冒领。
locallyElidedID := modelTestID(5201)
locallyRestored := modelTestNode(locallyElidedID, innerCanvas)
locallyRestored["incarnation"] = float64(2)
edit(1020, map[string]int64{innerCanvas: model.Versions[innerCanvas]}, modelChange{Kind: "element", ID: locallyElidedID, Before: modelJSON(nil), After: modelJSON(locallyRestored)})
model = read()
if modelInt(model.Elements[locallyElidedID]["incarnation"]) != 2 || model.Tombstones[locallyElidedID] != 0 {
t.Fatal("local elision undo reused a canceled life or invented an ACK tombstone")
}
staleElisionKey := modelTestID(1021)
staleElision := modelBatch{ProtocolVersion: 2, RequestID: staleElisionKey, Expected: map[string]int64{innerCanvas: model.Versions[innerCanvas]}, Operations: []modelOperation{{ID: modelTestID(22007), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: locallyElidedID, Incarnation: 1}, Field: "data.title", Before: modelJSON(locallyElidedID), After: modelJSON("stale local callback")}}}}}
if call("POST", base+"/model/operations", staleElision, staleElisionKey, 409)["status"] != "not-applied" || !modelEqual(read().Elements[locallyElidedID], locallyRestored) {
t.Fatal("a callback from the locally canceled incarnation changed its restored successor")
}
}
+298
View File
@@ -0,0 +1,298 @@
// 将旧快照树显式迁入 canonical 模型,保存完整旧→新稳定身份映射,原输入文档保持不变。
package platform
import (
"encoding/json"
"fmt"
"strings"
)
// modelIdentity 包含来源画布和结构类型,避免不同画布或 node/edge 同名时映射碰撞。
type modelIdentity struct {
SourceCanvasID string `json:"sourceCanvasId"`
Structure string `json:"structure"`
SourceID string `json:"sourceId"`
ElementID string `json:"elementId"`
}
// modelMigration 返回模型、身份映射和普通旧 frame 新生成的画布 ID,由外层事务一次保存。
type modelMigration struct {
Model canvasModel
Identities []modelIdentity
NewCanvases []string
}
// modelSpace 描述累积到根的平移/缩放,用于迁移曲线路径,不应用 viewport。
type modelSpace struct{ X, Y, Scale float64 }
// No source document is changed. IDs are allocated once inside the eventual
// migration transaction and the complete mapping is stored with its receipt.
// migrateCanvasModel 通过注入 allocate 分配一次性稳定 ID;重复或非法分配结果直接拒绝。
func migrateCanvasModel(root string, snapshots map[string]canvasSnapshot, relations []subgraphRelation, allocate func() string) (modelMigration, error) {
result := modelMigration{Model: emptyModel(root), Identities: []modelIdentity{}, NewCanvases: []string{}}
documents, nodes := map[string]map[string]any{}, map[string]map[string]any{}
identities, children, synthetic := map[string]string{}, map[string]string{}, map[string]bool{}
used := map[string]bool{}
for board := range snapshots {
used[board] = true
}
nextID := func() (string, error) {
id := allocate()
if !uuidSlugPattern.MatchString(id) || used[id] {
return "", errCanvasModel
}
used[id] = true
return id, nil
}
identityKey := func(board, structure, id string) string { return board + "/" + structure + "/" + id }
for _, board := range sortedKeys(snapshots) {
if !uuidSlugPattern.MatchString(board) || snapshots[board].Version < 1 {
return result, errCanvasModel
}
normalized, valid := normalizeCanvas(snapshots[board].Document)
if !valid {
return result, errCanvasModel
}
var document map[string]any
if json.Unmarshal(normalized, &document) != nil {
return result, errCanvasModel
}
documents[board] = document
result.Model.Canvases[board] = modelCanvas{ID: board}
result.Model.Versions[board] = snapshots[board].Version + 1
for _, collection := range []string{"nodes", "edges"} {
structure := "node"
if collection == "edges" {
structure = "connection"
}
for _, value := range document[collection].([]any) {
record := value.(map[string]any)
old := record["id"].(string)
id, err := nextID()
if err != nil {
return result, err
}
identities[identityKey(board, structure, old)] = id
result.Identities = append(result.Identities, modelIdentity{SourceCanvasID: board, Structure: structure, SourceID: old, ElementID: id})
if structure == "node" {
nodes[canvasNodeKey(board, old)] = record
}
}
}
}
// 已有独立子图保留画布 ID,入口节点换为新元素 ID;关系必须与快照 subgraph 一致。
for _, relation := range relations {
if relation.Archived {
continue
}
key := canvasNodeKey(relation.Parent, relation.Frame)
frame := nodes[key]
if frame == nil || documents[relation.Child] == nil || children[key] != "" || relation.Child == root {
return result, errCanvasModel
}
data := frame["data"].(map[string]any)
sub, _ := data["subgraph"].(map[string]any)
if data["kind"] != "frame" || sub["boardId"] != relation.Child || result.Model.Canvases[relation.Child].Parent != nil {
return result, errCanvasModel
}
children[key] = relation.Child
result.Model.Canvases[relation.Child] = modelCanvas{ID: relation.Child, Parent: &modelParent{CanvasID: relation.Parent, EntryElementID: identities[identityKey(relation.Parent, "node", relation.Frame)]}}
}
// Ordinary legacy frameId groups also become actual canvases, even if empty.
// 没有独立子图的旧框也变成真实画布(包括空框),随后把显式 frameId 成员迁入。
for _, key := range sortedKeys(nodes) {
node := nodes[key]
data := node["data"].(map[string]any)
if data["kind"] != "frame" {
continue
}
if _, linked := data["subgraph"]; linked && children[key] == "" {
return result, errCanvasModel
}
if children[key] != "" {
continue
}
id, err := nextID()
if err != nil {
return result, err
}
board := strings.SplitN(key, "/", 2)[0]
children[key], synthetic[key] = id, true
result.Model.Canvases[id] = modelCanvas{ID: id, Parent: &modelParent{CanvasID: board, EntryElementID: identities[identityKey(board, "node", node["id"].(string))]}}
result.Model.Versions[id] = 1
result.NewCanvases = append(result.NewCanvases, id)
}
for _, board := range sortedKeys(documents) {
for index, value := range documents[board]["nodes"].([]any) {
node := value.(map[string]any)
original := node["data"].(map[string]any)
data := map[string]any{}
for key, value := range original {
data[key] = value
}
kind := data["kind"].(string)
owner := board
geometry := legacyModelGeometry(node, kind)
if frameID, exists := data["frameId"].(string); exists {
frame := nodes[canvasNodeKey(board, frameID)]
child := children[canvasNodeKey(board, frameID)]
if frame == nil || child == "" {
return result, errCanvasModel
}
position := frame["position"].(map[string]any)
frameData := frame["data"].(map[string]any)
scale := modelContentScale(frameData)
geometry["x"] = (geometry["x"].(float64) - position["x"].(float64) - 24) / scale
geometry["y"] = (geometry["y"].(float64) - position["y"].(float64) - 36) / scale
geometry["width"], geometry["height"] = geometry["width"].(float64)/scale, geometry["height"].(float64)/scale
owner = child
}
for _, key := range []string{"kind", "rotation", "frameId", "subgraph", "ports"} {
delete(data, key)
}
id := identities[identityKey(board, "node", node["id"].(string))]
result.Model.Elements[id] = map[string]any{"id": id, "incarnation": float64(1), "ownerCanvasId": owner, "componentId": kind, "dataVersion": float64(1), "structure": "node", "geometry": geometry, "data": data, "orderKey": fmt.Sprintf("%s/%012d", board, index)}
}
}
spaces, err := modelSpaces(result.Model)
if err != nil {
return result, err
}
// 解开最多八层旧 port 链,得到 canonical 真实元素端点;方向错误或循环均拒绝。
resolve := func(board, node, handle, direction string) (map[string]any, error) {
seen := map[string]bool{}
for depth := 0; depth <= 8; depth++ {
key := canvasNodeKey(board, node)
legacy := nodes[key]
if legacy == nil || seen[key+"/"+handle] {
return nil, errCanvasModel
}
seen[key+"/"+handle] = true
data := legacy["data"].(map[string]any)
if data["kind"] != "frame" || !strings.HasPrefix(handle, "port:") {
endpoint := map[string]any{"elementId": identities[identityKey(board, "node", node)]}
if handle != "" {
endpoint["portId"] = handle
}
return endpoint, nil
}
ports, _ := data["ports"].([]any)
found := false
for _, value := range ports {
port := value.(map[string]any)
if port["id"] == strings.TrimPrefix(handle, "port:") && port["direction"] == direction {
node, handle = modelString(port["nodeId"]), modelString(port["handle"])
if !synthetic[key] {
board = children[key]
}
found = true
break
}
}
if !found {
return nil, errCanvasModel
}
}
return nil, errCanvasModel
}
for _, board := range sortedKeys(documents) {
for index, value := range documents[board]["edges"].([]any) {
edge := value.(map[string]any)
source, err := resolve(board, modelString(edge["source"]), modelString(edge["sourceHandle"]), "output")
if err != nil {
return result, err
}
target, err := resolve(board, modelString(edge["target"]), modelString(edge["targetHandle"]), "input")
if err != nil {
return result, err
}
owner, err := modelCommonCanvas(result.Model, modelString(result.Model.Elements[source["elementId"].(string)]["ownerCanvasId"]), modelString(result.Model.Elements[target["elementId"].(string)]["ownerCanvasId"]))
if err != nil {
return result, err
}
from, to := spaces[board], spaces[owner]
projectEdgePath(edge, from.Scale/to.Scale, (from.X-to.X)/to.Scale, (from.Y-to.Y)/to.Scale)
data, _ := edge["data"].(map[string]any)
if data == nil {
data = map[string]any{}
}
path := data["path"]
delete(data, "path")
id := identities[identityKey(board, "connection", edge["id"].(string))]
result.Model.Elements[id] = map[string]any{"id": id, "incarnation": float64(1), "ownerCanvasId": owner, "componentId": "connection", "dataVersion": float64(1), "structure": "connection", "source": source, "target": target, "path": path, "data": data, "orderKey": fmt.Sprintf("%s/%012d", board, index)}
}
}
if err := validateCanvasModel(result.Model); err != nil {
return result, err
}
return result, nil
}
// modelContentScale 读取正展示缩放,缺省一;仅在迁移几何和路径空间计算时使用。
func modelContentScale(data map[string]any) float64 {
presentation, _ := data["presentation"].(map[string]any)
if scale, ok := presentation["contentScale"].(float64); ok && scale > 0 {
return scale
}
return 1
}
// legacyModelGeometry 为旧节点缺省尺寸补种类默认值,将 position/rotation 汇总到 canonical geometry。
func legacyModelGeometry(node map[string]any, kind string) map[string]any {
width, height := float64(260), float64(200)
switch kind {
case "plain-text":
width, height = 240, 72
case "plain-image":
width, height = 320, 240
case "icon":
width, height = 80, 80
case "frame":
width, height = 640, 400
}
if value, exists := node["width"].(float64); exists {
width = value
}
if value, exists := node["height"].(float64); exists {
height = value
}
position := node["position"].(map[string]any)
data := node["data"].(map[string]any)
rotation, _ := data["rotation"].(float64)
return map[string]any{"x": position["x"], "y": position["y"], "width": width, "height": height, "rotation": rotation}
}
// modelSpaces 迭代从已知父空间求孩子累计空间,九轮仍未覆盖或无进展表示树无效。
func modelSpaces(model canvasModel) (map[string]modelSpace, error) {
result := map[string]modelSpace{model.Root: {Scale: 1}}
remaining := len(model.Canvases) - 1
for depth := 0; remaining > 0 && depth < 9; depth++ {
progress := false
for _, id := range sortedKeys(model.Canvases) {
canvas := model.Canvases[id]
if _, exists := result[id]; exists || canvas.Parent == nil {
continue
}
parent, exists := result[canvas.Parent.CanvasID]
if !exists {
continue
}
entry := model.Elements[canvas.Parent.EntryElementID]
if entry == nil {
return nil, errCanvasModel
}
geometry := entry["geometry"].(map[string]any)
data := entry["data"].(map[string]any)
result[id] = modelSpace{X: parent.X + (geometry["x"].(float64)+24)*parent.Scale, Y: parent.Y + (geometry["y"].(float64)+36)*parent.Scale, Scale: parent.Scale * modelContentScale(data)}
remaining--
progress = true
}
if !progress {
return nil, errCanvasModel
}
}
if remaining != 0 {
return nil, errCanvasModel
}
return result, nil
}
+331
View File
@@ -0,0 +1,331 @@
// Canonical 模型持久化及旧快照投影;数据库模型表是权威来源,canvas_document 是内部兼容视图。
package platform
import (
"context"
"database/sql"
"encoding/json"
"net/http"
"sort"
)
// canonicalRoot 查询所属模型根,尚未迁移返回空字符串而非缺行错误。
func canonicalRoot(ctx context.Context, tx *sql.Tx, project, workspace, board string) (string, error) {
var root string
err := tx.QueryRowContext(ctx, `SELECT root_id::text FROM canvas_model_canvases WHERE project=$1 AND workspace_id=$2 AND canvas_id=$3`, project, workspace, board).Scan(&root)
if err == sql.ErrNoRows {
return "", nil
}
return root, err
}
// loadCanvasModel 读取根下所有画布/元素,保留归档版本与删除记录,重建后执行完整模型校验。
func loadCanvasModel(ctx context.Context, tx *sql.Tx, project, workspace, root string) (canvasModel, error) {
model := emptyModel(root)
rows, err := tx.QueryContext(ctx, `SELECT canvas_id::text,parent_canvas_id::text,entry_element_id,version,archived FROM canvas_model_canvases WHERE project=$1 AND workspace_id=$2 AND root_id=$3 ORDER BY canvas_id`, project, workspace, root)
if err != nil {
return model, err
}
for rows.Next() {
var canvas modelCanvas
var parent, entry sql.NullString
var version int64
var archived bool
if err = rows.Scan(&canvas.ID, &parent, &entry, &version, &archived); err != nil {
rows.Close()
return model, err
}
if parent.Valid {
canvas.Parent = &modelParent{CanvasID: parent.String, EntryElementID: entry.String}
}
model.Versions[canvas.ID] = version
if !archived {
model.Canvases[canvas.ID] = canvas
}
}
err = rows.Err()
rows.Close()
if err != nil {
return model, err
}
rows, err = tx.QueryContext(ctx, `SELECT element_id,record,deleted,deleted_incarnation FROM canvas_model_elements WHERE project=$1 AND workspace_id=$2 AND root_id=$3 ORDER BY element_id`, project, workspace, root)
if err != nil {
return model, err
}
defer rows.Close()
for rows.Next() {
var id string
var raw json.RawMessage
var deleted bool
var dead int64
if err = rows.Scan(&id, &raw, &deleted, &dead); err != nil {
return model, err
}
if dead > 0 {
model.Tombstones[id] = dead
}
var element map[string]any
if err = json.Unmarshal(raw, &element); err != nil {
return model, err
}
if dead > 0 {
model.TombstoneOwners[id] = modelString(element["ownerCanvasId"])
}
if !deleted {
model.Elements[id] = element
} else {
model.DeadRecords[id] = element
}
}
if err = rows.Err(); err != nil {
return model, err
}
return model, validateCanvasModel(model)
}
// Only changed element rows are written. canvas_document is a compatibility
// projection for internal AI readers, never the source of a canonical GET/replay.
// saveCanvasModel 在调用方事务中写参与画布与真正变化的元素,更新所有权关系并同步兼容快照。
// 先按 canonical 稳定身份使 AI 目标失效,再开启事务级 canonical_writer 以通过数据库旧写入屏障。
func (s *service) saveCanvasModel(r *http.Request, tx *sql.Tx, project, workspace, account string, before, after canvasModel, participants map[string]bool) error {
ctx := r.Context()
if err := invalidateCanonicalAIIdentities(r, tx, project, workspace, before, after); err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `SELECT set_config('foundry.canonical_writer','on',true)`); err != nil {
return err
}
projection, err := projectCanvasModel(after)
if err != nil {
return err
}
for _, id := range sortedKeys(participants) {
canvas, active := after.Canvases[id]
if active {
if _, existed := before.Versions[id]; !existed {
title := "Canvas"
if canvas.Parent != nil {
data := after.Elements[canvas.Parent.EntryElementID]["data"].(map[string]any)
if value := modelString(data["title"]); value != "" {
title = value
}
}
if _, err = tx.ExecContext(ctx, `INSERT INTO materials(project,workspace_id,id,kind,title,created_by) VALUES($1,$2,$3,'board',$4,$5)`, project, workspace, id, title, account); err != nil {
return err
}
}
var parent, entry any
if canvas.Parent != nil {
parent, entry = canvas.Parent.CanvasID, canvas.Parent.EntryElementID
}
_, err = tx.ExecContext(ctx, `INSERT INTO canvas_model_canvases(project,workspace_id,root_id,canvas_id,parent_canvas_id,entry_element_id,version) VALUES($1,$2,$3,$4,$5,$6,$7) ON CONFLICT(project,workspace_id,canvas_id) DO UPDATE SET parent_canvas_id=EXCLUDED.parent_canvas_id,entry_element_id=EXCLUDED.entry_element_id,version=EXCLUDED.version,archived=false`, project, workspace, after.Root, id, parent, entry, after.Versions[id])
} else {
_, err = tx.ExecContext(ctx, `UPDATE canvas_model_canvases SET archived=true,version=$4 WHERE project=$1 AND workspace_id=$2 AND canvas_id=$3`, project, workspace, id, after.Versions[id])
}
if err != nil {
return err
}
}
// 只更新变化记录;同项目元素 ID 已属于其他 workspace/root 时,受限 upsert 不覆盖并报冲突。
for _, id := range sortedKeys(after.Elements) {
element := after.Elements[id]
if modelEqual(before.Elements[id], element) && before.Tombstones[id] == after.Tombstones[id] {
continue
}
raw, err := json.Marshal(element)
if err != nil {
return err
}
written, err := tx.ExecContext(ctx, `INSERT INTO canvas_model_elements(project,workspace_id,root_id,element_id,owner_canvas_id,incarnation,deleted_incarnation,record) VALUES($1,$2,$3,$4,$5,$6,$7,$8) ON CONFLICT(project,element_id) DO UPDATE SET owner_canvas_id=EXCLUDED.owner_canvas_id,incarnation=EXCLUDED.incarnation,deleted_incarnation=EXCLUDED.deleted_incarnation,record=EXCLUDED.record,deleted=false WHERE canvas_model_elements.workspace_id=EXCLUDED.workspace_id AND canvas_model_elements.root_id=EXCLUDED.root_id`, project, workspace, after.Root, id, element["ownerCanvasId"], modelInt(element["incarnation"]), after.Tombstones[id], raw)
if err != nil {
return err
}
if count, err := written.RowsAffected(); err != nil {
return err
} else if count != 1 {
return errModelConflict
}
}
// 删除也持久保留最后记录及代数,后续恢复/去重不能把墓碑当成从未存在。
for _, id := range sortedKeys(after.Tombstones) {
if after.Elements[id] != nil || before.Elements[id] == nil && before.Tombstones[id] == after.Tombstones[id] {
continue
}
record := after.DeadRecords[id]
if record == nil {
return errCanvasModel
}
raw, err := json.Marshal(record)
if err != nil {
return err
}
written, err := tx.ExecContext(ctx, `INSERT INTO canvas_model_elements(project,workspace_id,root_id,element_id,owner_canvas_id,incarnation,deleted_incarnation,record,deleted) VALUES($1,$2,$3,$4,$5,$6,$6,$7,true) ON CONFLICT(project,element_id) DO UPDATE SET owner_canvas_id=EXCLUDED.owner_canvas_id,incarnation=EXCLUDED.incarnation,deleted_incarnation=EXCLUDED.deleted_incarnation,record=EXCLUDED.record,deleted=true WHERE canvas_model_elements.workspace_id=EXCLUDED.workspace_id AND canvas_model_elements.root_id=EXCLUDED.root_id`, project, workspace, after.Root, id, record["ownerCanvasId"], after.Tombstones[id], raw)
if err != nil {
return err
}
if count, err := written.RowsAffected(); err != nil {
return err
} else if count != 1 {
return errModelConflict
}
}
// Archive relations first; parent/entry changes then install the final owning tree.
for _, id := range sortedKeys(participants) {
if id != after.Root {
if _, err = tx.ExecContext(ctx, `UPDATE canvas_subgraphs SET archived_at=now() WHERE project=$1 AND workspace_id=$2 AND child_board_id=$3`, project, workspace, id); err != nil {
return err
}
}
}
// 先归档旧关系,再按祖先深度由外向内安装最终树,避免父入口变动时出现重复活跃关系。
canvases := sortedKeys(after.Canvases)
sort.SliceStable(canvases, func(i, j int) bool {
a, _ := modelAncestors(after, canvases[i])
b, _ := modelAncestors(after, canvases[j])
return len(a) < len(b)
})
for _, id := range canvases {
canvas := after.Canvases[id]
if !participants[id] || canvas.Parent == nil {
continue
}
_, err = tx.ExecContext(ctx, `INSERT INTO canvas_subgraphs(project,workspace_id,parent_board_id,frame_id,child_board_id) VALUES($1,$2,$3,$4,$5) ON CONFLICT(project,workspace_id,child_board_id) DO UPDATE SET parent_board_id=EXCLUDED.parent_board_id,frame_id=EXCLUDED.frame_id,archived_at=NULL`, project, workspace, canvas.Parent.CanvasID, canvas.Parent.EntryElementID, id)
if err != nil {
return err
}
}
for _, id := range sortedKeys(participants) {
if _, active := after.Canvases[id]; !active {
_, err = tx.ExecContext(ctx, `UPDATE materials SET canvas_version=$4 WHERE project=$1 AND workspace_id=$2 AND id=$3`, project, workspace, id, after.Versions[id])
if err != nil {
return err
}
continue
}
// Asset bindings still run through service checks; canonical identity
// invalidation has already run on the normalized before/after models.
if err = s.saveCanvas(r, tx, project, workspace, canvasSnapshot{BoardID: id, Version: after.Versions[id], Document: projection[id]}); err != nil {
return err
}
}
return nil
}
// projectCanvasModel 为旧 AI reader 生成 v2 快照,只投影已知 v1 组件,未知组件仍完整保存在 canonical 表。
func projectCanvasModel(model canvasModel) (map[string]json.RawMessage, error) {
documents := map[string]map[string]any{}
for id := range model.Canvases {
documents[id] = map[string]any{"schema_version": float64(2), "nodes": []any{}, "edges": []any{}, "viewport": map[string]any{"x": float64(0), "y": float64(0), "zoom": float64(1)}}
}
elements := sortedKeys(model.Elements)
sort.SliceStable(elements, func(i, j int) bool {
return modelString(model.Elements[elements[i]]["orderKey"]) < modelString(model.Elements[elements[j]]["orderKey"])
})
childByEntry := map[string]string{}
for id, canvas := range model.Canvases {
if canvas.Parent != nil {
childByEntry[canvas.Parent.EntryElementID] = id
}
}
for _, id := range elements {
element := model.Elements[id]
if element["structure"] != "node" {
continue
}
kind := modelString(element["componentId"])
if modelInt(element["dataVersion"]) != 1 || !canvasChoice(kind, "text", "script", "image", "plain-text", "plain-image", "icon", "frame") {
continue
}
data := map[string]any{}
for key, value := range element["data"].(map[string]any) {
data[key] = value
}
data["kind"] = kind
geometry := element["geometry"].(map[string]any)
data["rotation"] = geometry["rotation"]
typ := "material"
switch kind {
case "plain-text":
typ = "plainText"
case "plain-image":
typ = "plainImage"
case "icon":
typ = "icon"
case "frame":
typ = "frame"
}
if child := childByEntry[id]; child != "" {
data["subgraph"], data["ports"] = map[string]any{"boardId": child}, []any{}
}
node := map[string]any{"id": id, "type": typ, "position": map[string]any{"x": geometry["x"], "y": geometry["y"]}, "width": geometry["width"], "height": geometry["height"], "data": data}
owner := modelString(element["ownerCanvasId"])
documents[owner]["nodes"] = append(documents[owner]["nodes"].([]any), node)
}
// Canonical 连接直接指真实元素;投影时才沿祖先树生成旧式 frame/port 链,不能反向作为权威身份。
for _, id := range elements {
element := model.Elements[id]
if element["structure"] != "connection" || element["componentId"] != "connection" || modelInt(element["dataVersion"]) != 1 {
continue
}
owner := modelString(element["ownerCanvasId"])
endpoints := []canvasConnectionEndpoint{}
skip := false
for index, field := range []string{"source", "target"} {
endpoint := element[field].(map[string]any)
node := model.Elements[modelString(endpoint["elementId"])]
board := modelString(node["ownerCanvasId"])
if connectionNode(documents[board], modelString(node["id"])) == nil {
skip = true
break
}
handle := modelString(endpoint["portId"])
if handle == "" {
handle = "left"
if index == 0 {
handle = "right"
}
}
path := []subgraphRelation{}
for next := board; next != owner; {
canvas := model.Canvases[next]
if canvas.Parent == nil {
return nil, errCanvasModel
}
path = append(path, subgraphRelation{Parent: canvas.Parent.CanvasID, Frame: canvas.Parent.EntryElementID, Child: next})
next = canvas.Parent.CanvasID
}
direction := "output"
if index == 1 {
direction = "input"
}
resolved, _, err := exposeConnectionEndpoint(canvasConnectionEndpoint{Board: board, Node: modelString(node["id"]), Handle: handle}, direction, path, documents)
// Direct frame/icon endpoints are canonical concepts; old AI readers cannot execute them.
if err != nil {
skip = true
break
}
endpoints = append(endpoints, resolved)
}
if skip {
continue
}
data := map[string]any{}
for key, value := range element["data"].(map[string]any) {
data[key] = value
}
if element["path"] != nil {
data["path"] = element["path"]
}
edge := map[string]any{"id": id, "source": endpoints[0].Node, "target": endpoints[1].Node, "sourceHandle": endpoints[0].Handle, "targetHandle": endpoints[1].Handle, "data": data}
documents[owner]["edges"] = append(documents[owner]["edges"].([]any), edge)
}
result := map[string]json.RawMessage{}
for id, document := range documents {
raw, err := json.Marshal(document)
if err != nil {
return nil, err
}
result[id] = raw
}
return result, nil
}
+116
View File
@@ -0,0 +1,116 @@
// Canonical 模型 NDJSON 传输:从已一致捕获的内存模型编码,不边读库边向慢客户端发送。
package platform
import (
"context"
"encoding/json"
"net/http"
)
const modelStreamType = "application/vnd.foundry.canvas-model+ndjson;version=1"
// The caller captures a coherent model while holding the workspace lock, then
// releases its transaction before writing. A slow reader must not hold a writer.
// This streams transfer/encoding; it does not stream database row acquisition.
// writeCanvasModelStream 发送 header、elements 批次和 complete,统一 token/sequence 供客户端检测截断或混流。
func writeCanvasModelStream(ctx context.Context, w http.ResponseWriter, model canvasModel) {
token := newModelID()
if token == "" {
reject(w, 500, "model_stream_unavailable")
return
}
view := model.view(nil)
// A count covers direct members only; an empty canvas is explicit too.
// 头部显式声明每画布直接元素数、总数与身份 owner,空画布也必须覆盖。
counts := map[string]int{}
owners := map[string]string{}
for _, canvas := range view.Canvases {
counts[canvas.ID] = 0
}
for _, element := range view.Elements {
owner := modelString(element["ownerCanvasId"])
if _, ok := counts[owner]; !ok {
reject(w, 500, "invalid_model_coverage")
return
}
id := modelString(element["id"])
if id == "" || owners[id] != "" {
reject(w, 500, "invalid_model_identity")
return
}
owners[id] = owner
counts[owner]++
}
header := response{"streamVersion": 1, "kind": "header", "sequence": 0, "snapshotToken": token,
"documentFormatVersion": canvasModelFormat, "projectId": model.Root, "canvases": view.Canvases,
"versions": view.Versions, "tombstones": view.Tombstones, "removedCanvasIds": view.Removed, "elementCount": len(view.Elements), "canvasElementCounts": counts, "elementOwners": owners}
const maxLine = 8 * 1024 * 1024
const maxBytes = 64 * 1024 * 1024
sequence, total := 0, 0
started := false
// 每行/总字节/记录数均有预算;开始前可写结构化错误,开始后只能停流让缺 complete 表示失败。
write := func(value response) bool {
if ctx.Err() != nil {
return false
}
raw, err := json.Marshal(value)
if err != nil || len(raw) > maxLine || total+len(raw)+1 > maxBytes || sequence >= 4096 {
if !started {
reject(w, 413, "model_stream_budget")
}
return false
}
if !started {
w.Header().Set("Content-Type", modelStreamType)
w.Header().Set("Cache-Control", "no-store")
w.Header().Add("Vary", "Accept")
w.Header().Set("X-Content-Type-Options", "nosniff")
w.WriteHeader(http.StatusOK)
started = true
}
total += len(raw) + 1
if n, writeErr := w.Write(append(raw, '\n')); writeErr != nil || n != len(raw)+1 {
return false
}
sequence++
// A missing terminal record is an explicit incomplete stream at the client.
// Never append an unrelated JSON error after streaming has begun.
return http.NewResponseController(w).Flush() == nil
}
if !write(header) {
return
}
batch := []map[string]any{}
batchBytes := 0
// 批次最多 64 元素或约 512 KiB,单个大元素仍受统一 maxLine 限制。
flush := func() bool {
if len(batch) == 0 {
return true
}
if !write(response{"streamVersion": 1, "kind": "elements", "sequence": sequence, "snapshotToken": token, "elements": batch}) {
return false
}
batch, batchBytes = []map[string]any{}, 0
return true
}
for _, element := range view.Elements {
if ctx.Err() != nil {
return
}
raw, err := json.Marshal(element)
if err != nil {
return
}
if len(batch) > 0 && (len(batch) == 64 || batchBytes+len(raw) > 512*1024) {
if !flush() {
return
}
}
batch = append(batch, element)
batchBytes += len(raw)
}
if !flush() {
return
}
write(response{"streamVersion": 1, "kind": "complete", "sequence": sequence, "snapshotToken": token, "elementCount": len(view.Elements)})
}
@@ -0,0 +1,147 @@
// 模型/协议纯回归:用内存对象与 recorder 验证身份、原子变更或流传输契约,不访问真实数据库。
package platform
import (
"bufio"
"context"
"encoding/json"
"fmt"
"net/http/httptest"
"testing"
)
// streamRecords 把 recorder 内每行 JSON 转为断言对象;用例中的小记录不需要增大 Scanner 缺省预算。
func streamRecords(t *testing.T, writer *httptest.ResponseRecorder) []response {
t.Helper()
var records []response
scanner := bufio.NewScanner(writer.Body)
for scanner.Scan() {
var record response
if err := json.Unmarshal(scanner.Bytes(), &record); err != nil {
t.Fatal(err)
}
records = append(records, record)
}
if err := scanner.Err(); err != nil {
t.Fatal(err)
}
return records
}
// TestCanonicalModelStreamFramesAndSnapshot 用超过两个批次的元素验证 header/批次/complete 分帧,token、序号、墓碑和全元素 owner 清单必须一致且无重复漏项。
func TestCanonicalModelStreamFramesAndSnapshot(t *testing.T) {
model := modelTestDocument()
for i := 0; i < 129; i++ {
id := fmt.Sprintf("extra-%03d", i)
model.Elements[id] = modelTestNode(id, modelRootID)
}
model.Tombstones["deleted"] = 2
model.TombstoneOwners["deleted"] = modelRootID
writer := httptest.NewRecorder()
writeCanvasModelStream(context.Background(), writer, model)
if writer.Code != 200 || writer.Header().Get("Content-Type") != modelStreamType || !writer.Flushed {
t.Fatal("stream was not negotiated/flushed", writer.Code, writer.Header())
}
records := streamRecords(t, writer)
if len(records) != 5 || records[0]["kind"] != "header" || records[4]["kind"] != "complete" {
t.Fatal("missing stream framing", len(records))
}
token := modelString(records[0]["snapshotToken"])
if !uuidSlugPattern.MatchString(token) || records[0]["projectId"] != modelRootID || !modelEqual(records[0]["versions"], model.Versions) || !modelEqual(records[0]["tombstones"], model.Tombstones) {
t.Fatal("stream header lost snapshot identity")
}
owners := records[0]["elementOwners"].(map[string]any)
if len(owners) != len(model.Elements) {
t.Fatal("identity manifest must cover unloaded elements too")
}
for id, element := range model.Elements {
if owners[id] != element["ownerCanvasId"] {
t.Fatal("identity manifest mixed owners", id)
}
}
seen := map[string]bool{}
for i, record := range records {
if record["sequence"] != float64(i) || record["snapshotToken"] != token || record["streamVersion"] != float64(1) {
t.Fatal("mixed or unordered snapshot")
}
if record["kind"] == "elements" {
items := record["elements"].([]any)
if len(items) == 0 || len(items) > 64 {
t.Fatal("unbounded record batch")
}
for _, item := range items {
element := item.(map[string]any)
id := modelString(element["id"])
if seen[id] || !modelEqual(element, model.Elements[id]) {
t.Fatal("duplicated or corrupted stream element")
}
seen[id] = true
}
}
}
if len(seen) != len(model.Elements) || records[4]["elementCount"] != float64(len(seen)) {
t.Fatal("terminal coverage mismatch")
}
}
// cancelStreamWriter 在首个 flush 后取消请求,用于验证已开始流的中途停止语义。
type cancelStreamWriter struct {
*httptest.ResponseRecorder
cancel context.CancelFunc
}
// Flush 先模拟实际输出,再取消,使下一次编码检测到上下文结束。
func (writer cancelStreamWriter) Flush() {
writer.ResponseRecorder.Flush()
writer.cancel()
}
// TestCanonicalModelStreamCancellationNeverClaimsCompletion 第一次 Flush 即取消上下文,验证仅发 header,不能追加 complete 或假成功尾记录。
func TestCanonicalModelStreamCancellationNeverClaimsCompletion(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
writer := httptest.NewRecorder()
writeCanvasModelStream(ctx, cancelStreamWriter{writer, cancel}, modelTestDocument())
records := streamRecords(t, writer)
if len(records) != 1 || records[0]["kind"] != "header" {
t.Fatal("cancelled stream wrote a tail", len(records))
}
}
// TestCanonicalModelStreamDeclaresDirectScopeCountsIncludingEmptyCanvases 验证每个 scope 只计直接成员且显式保留零元素画布,未知 owner 必须在首次 Flush 前拒绝。
func TestCanonicalModelStreamDeclaresDirectScopeCountsIncludingEmptyCanvases(t *testing.T) {
model := modelTestDocument()
empty, nested := modelTestID(41), modelTestID(42)
model.Canvases[empty] = modelCanvas{ID: empty, Parent: &modelParent{CanvasID: model.Root, EntryElementID: "frame-empty"}}
model.Canvases[nested] = modelCanvas{ID: nested, Parent: &modelParent{CanvasID: model.Root, EntryElementID: "frame-nested"}}
model.Versions[empty], model.Versions[nested] = 1, 1
model.Elements["frame-empty"] = modelTestNode("frame-empty", model.Root)
model.Elements["frame-nested"] = modelTestNode("frame-nested", model.Root)
model.Elements["nested-node"] = modelTestNode("nested-node", nested)
writer := httptest.NewRecorder()
writeCanvasModelStream(context.Background(), writer, model)
records := streamRecords(t, writer)
if !modelEqual(records[0]["canvasElementCounts"], map[string]int{model.Root: 3, empty: 0, nested: 1}) {
t.Fatal("scope counts must count direct members, preserve empty scopes and match the captured snapshot")
}
bad := modelTestDocument()
bad.Elements["a"]["ownerCanvasId"] = "foreign"
failed := httptest.NewRecorder()
writeCanvasModelStream(context.Background(), failed, bad)
if failed.Code != 500 || failed.Flushed {
t.Fatal("invalid owner must fail before publishing a scope certificate")
}
}
// TestCanonicalModelStreamRejectsAmbiguousIdentityManifest 构造空或重复内部元素 ID,验证不发布有歧义的身份清单,返回 500 且未开始流。
func TestCanonicalModelStreamRejectsAmbiguousIdentityManifest(t *testing.T) {
for _, id := range []string{"", "a"} {
model := modelTestDocument()
model.Elements["other"] = modelTestNode(id, modelRootID)
writer := httptest.NewRecorder()
writeCanvasModelStream(context.Background(), writer, model)
if writer.Code != 500 || writer.Flushed {
t.Fatal("ambiguous identity was published before rejection")
}
}
}
+265
View File
@@ -0,0 +1,265 @@
// 模型/协议纯回归:用内存对象与 recorder 验证身份、原子变更或流传输契约,不访问真实数据库。
package platform
import (
"bytes"
_ "embed"
"encoding/json"
"fmt"
"testing"
)
const modelRootID = "10000000-0000-4000-8000-000000000001"
const modelChildID = "10000000-0000-4000-8000-000000000002"
const modelLegacyFrame = `{"id":"f","type":"frame","position":{"x":100,"y":200},"width":640,"height":400,"data":{"kind":"frame","title":"Partition","text":"","labelMode":"fixed"}}`
// The schema runner mounts only the test binary, not the source tree.
//
//go:embed testdata/foundry-model-operation-v2.json
var canonicalFrontendFixture []byte
// modelJSON 将测试值统一编码为 before/after 原始 JSON。
func modelJSON(value any) json.RawMessage { raw, _ := json.Marshal(value); return raw }
// modelTestID 生成确定 UUID,便于跨回归复用可预期的请求/操作/资源身份。
func modelTestID(n int) string { return fmt.Sprintf("90000000-0000-4000-8000-%012d", n) }
// modelTestAllocator 返回有独立计数器的分配器,让迁移身份分配可重复断言。
func modelTestAllocator() func() string {
next := 0
return func() string { next++; return modelTestID(next) }
}
// modelTestNode 构造最小有效 v1 text 节点,其嵌套 data/geometry 每次独立创建。
func modelTestNode(id, owner string) map[string]any {
return map[string]any{"id": id, "incarnation": float64(1), "ownerCanvasId": owner, "componentId": "text", "dataVersion": float64(1), "structure": "node", "data": map[string]any{"title": id, "text": "preserved"}, "geometry": map[string]any{"x": float64(0), "y": float64(0), "width": float64(260), "height": float64(200), "rotation": float64(0)}}
}
// modelTestDocument 提供版本一根画布和一个 a 节点的最小完整模型。
func modelTestDocument() canvasModel {
model := emptyModel(modelRootID)
model.Canvases[modelRootID] = modelCanvas{ID: modelRootID}
model.Versions[modelRootID] = 1
model.Elements["a"] = modelTestNode("a", modelRootID)
return model
}
// TestCanonicalFramesRetainRotationAcrossOwnerChanges 检查 canonical frame 跨 owner 后保留旋转、兼容投影和无关 AI patch 不抹角度,同时旧快照写契约仍拒绝旋转 frame。
func TestCanonicalFramesRetainRotationAcrossOwnerChanges(t *testing.T) {
model := modelTestDocument()
frame := modelTestNode("f", modelRootID)
frame["componentId"] = "frame"
frame["geometry"].(map[string]any)["rotation"] = float64(30)
model.Elements["f"] = frame
model.Canvases[modelChildID] = modelCanvas{ID: modelChildID, Parent: &modelParent{CanvasID: modelRootID, EntryElementID: "f"}}
model.Versions[modelChildID] = 1
member := modelTestNode("nested-frame", modelChildID)
member["componentId"] = "frame"
model.Elements["nested-frame"] = member
if err := validateCanvasModel(model); err != nil {
t.Fatalf("valid canonical frame rotation rejected: %v", err)
}
geometry := member["geometry"].(map[string]any)
moved := map[string]any{"x": float64(100), "y": float64(80), "width": float64(520), "height": float64(400), "rotation": float64(30)}
after, touched, err := applyModelOperations(model, []modelOperation{{ID: modelTestID(80), Changes: []modelChange{
{Kind: "field", Target: modelTarget{ID: "nested-frame", Incarnation: 1}, Field: "ownerCanvasId", Before: modelJSON(modelChildID), After: modelJSON(modelRootID)},
{Kind: "field", Target: modelTarget{ID: "nested-frame", Incarnation: 1}, Field: "geometry", Before: modelJSON(geometry), After: modelJSON(moved)},
}}})
if err != nil || !touched[modelRootID] || !touched[modelChildID] {
t.Fatalf("rotated frame owner change failed: %v", err)
}
if after.Elements["nested-frame"]["ownerCanvasId"] != modelRootID || !modelEqual(after.Elements["nested-frame"]["geometry"], moved) || model.Elements["nested-frame"]["ownerCanvasId"] != modelChildID {
t.Fatal("owner change lost geometry or changed the source model")
}
projection, err := projectCanvasModel(after)
if err != nil {
t.Fatal(err)
}
var document map[string]any
if err := json.Unmarshal(projection[modelRootID], &document); err != nil {
t.Fatal(err)
}
rotated := 0
for _, raw := range document["nodes"].([]any) {
node := raw.(map[string]any)
if node["id"] != "f" && node["id"] != "nested-frame" {
continue
}
rotated++
if node["data"].(map[string]any)["rotation"] != float64(30) {
t.Fatal("reader projection erased canonical rotation")
}
}
if rotated != 2 {
t.Fatal("reader projection omitted a rotated frame")
}
patched, err := prepareModelAIPatch(after, modelRootID, "a", response{"text": "new text"})
if err != nil || patched.Elements["f"]["geometry"].(map[string]any)["rotation"] != float64(30) {
t.Fatalf("unrelated canonical AI patch rejected or rewound rotation: %v", err)
}
bad := cloneModel(after)
bad.Elements["f"]["geometry"].(map[string]any)["rotation"] = float64(360)
if validateCanvasModel(bad) == nil {
t.Fatal("out-of-range canonical rotation accepted")
}
legacy := json.RawMessage(`{"schema_version":1,"nodes":[{"id":"f","type":"frame","position":{"x":0,"y":0},"width":640,"height":400,"data":{"kind":"frame","title":"F","text":"","rotation":30}}],"edges":[],"viewport":{"x":0,"y":0,"zoom":1}}`)
if _, valid := normalizeCanvas(legacy); valid {
t.Fatal("canonical support changed the legacy snapshot write contract")
}
}
// TestCanonicalMigrationResolvesCanvasLocalIdentitiesAndPorts 用父子同名节点证明迁移分配不同全局身份,并将端口边解析为真实子节点、推进版本屏障且保留输入快照。
func TestCanonicalMigrationResolvesCanvasLocalIdentitiesAndPorts(t *testing.T) {
root := `{"schema_version":2,"nodes":[{"id":"a","type":"plainText","position":{"x":0,"y":0},"width":240,"height":72,"data":{"kind":"plain-text","title":"parent","text":""}},{"id":"f","type":"frame","position":{"x":100,"y":200},"width":640,"height":400,"data":{"kind":"frame","title":"F","text":"","subgraph":{"boardId":"` + modelChildID + `"},"ports":[{"id":"p","nodeId":"a","handle":"right","direction":"output"}]}}],"edges":[{"id":"e","source":"f","sourceHandle":"port:p","target":"a","targetHandle":"left"}],"viewport":{"x":0,"y":0,"zoom":1}}`
child := `{"schema_version":2,"nodes":[{"id":"a","type":"plainText","position":{"x":10,"y":20},"width":240,"height":72,"data":{"kind":"plain-text","title":"child","text":""}}],"edges":[],"viewport":{"x":0,"y":0,"zoom":1}}`
snapshots := map[string]canvasSnapshot{modelRootID: {BoardID: modelRootID, Version: 3, Document: json.RawMessage(root)}, modelChildID: {BoardID: modelChildID, Version: 7, Document: json.RawMessage(child)}}
result, err := migrateCanvasModel(modelRootID, snapshots, []subgraphRelation{{Parent: modelRootID, Frame: "f", Child: modelChildID}}, modelTestAllocator())
if err != nil {
t.Fatal(err)
}
ids := map[string]string{}
for _, mapping := range result.Identities {
ids[mapping.SourceCanvasID+"/"+mapping.Structure+"/"+mapping.SourceID] = mapping.ElementID
}
parentA, childA := ids[modelRootID+"/node/a"], ids[modelChildID+"/node/a"]
if parentA == childA || parentA == "" || childA == "" {
t.Fatal("canvas-local node IDs were merged")
}
edge := result.Model.Elements[ids[modelRootID+"/connection/e"]]
if edge["source"].(map[string]any)["elementId"] != childA || edge["target"].(map[string]any)["elementId"] != parentA || edge["ownerCanvasId"] != modelRootID {
t.Fatal("logical endpoint or common ancestor owner was lost")
}
if result.Model.Canvases[modelChildID].Parent.EntryElementID != ids[modelRootID+"/node/f"] || result.Model.Versions[modelRootID] != 4 || result.Model.Versions[modelChildID] != 8 {
t.Fatal("migration did not publish an identity/version barrier")
}
if string(snapshots[modelRootID].Document) != root || string(snapshots[modelChildID].Document) != child {
t.Fatal("migration mutated source snapshots")
}
projection, err := projectCanvasModel(result.Model)
if err != nil {
t.Fatal(err)
}
for _, raw := range projection {
if _, valid := normalizeCanvas(raw); !valid {
t.Fatalf("invalid compatibility projection: %s", raw)
}
}
}
// TestCanonicalMigrationTurnsImplicitFramesIntoOwningCanvases 验证旧 frameId 分区成为新画布,成员几何改为 owner 局部坐标且 data 中不再存第二份 frameId 所有权。
func TestCanonicalMigrationTurnsImplicitFramesIntoOwningCanvases(t *testing.T) {
root := `{"schema_version":1,"nodes":[` + modelLegacyFrame + `,{"id":"a","type":"plainText","position":{"x":150,"y":260},"width":240,"height":72,"data":{"kind":"plain-text","title":"a","text":"","frameId":"f"}}],"edges":[],"viewport":{"x":0,"y":0,"zoom":1}}`
result, err := migrateCanvasModel(modelRootID, map[string]canvasSnapshot{modelRootID: {BoardID: modelRootID, Version: 1, Document: json.RawMessage(root)}}, nil, modelTestAllocator())
if err != nil {
t.Fatal(err)
}
if len(result.NewCanvases) != 1 || len(result.Model.Canvases) != 2 {
t.Fatal("legacy partition was not given a canvas")
}
var node map[string]any
for _, mapping := range result.Identities {
if mapping.SourceID == "a" {
node = result.Model.Elements[mapping.ElementID]
}
}
geometry := node["geometry"].(map[string]any)
if node["ownerCanvasId"] != result.NewCanvases[0] || geometry["x"] != float64(26) || geometry["y"] != float64(24) {
t.Fatal("membership or owner-local geometry changed")
}
if _, exists := node["data"].(map[string]any)["frameId"]; exists {
t.Fatal("second ownership fact leaked into canonical data")
}
}
// TestCanonicalOperationsPreserveOpaquePayloadAndStableMoveIdentity 移动已知元素 owner 时保留 ID,触及新旧画布,并原样保留未知组件数据及 envelope,输入模型不被修改。
func TestCanonicalOperationsPreserveOpaquePayloadAndStableMoveIdentity(t *testing.T) {
model := modelTestDocument()
frame := modelTestNode("f", modelRootID)
frame["componentId"] = "frame"
model.Elements["f"] = frame
model.Canvases[modelChildID] = modelCanvas{ID: modelChildID, Parent: &modelParent{CanvasID: modelRootID, EntryElementID: "f"}}
model.Versions[modelChildID] = 1
future := modelTestNode("future", modelRootID)
future["componentId"], future["dataVersion"], future["data"], future["futureEnvelope"] = "plugin.future", float64(42), map[string]any{"nested": map[string]any{"list": []any{"x", float64(2)}}}, map[string]any{"retain": true}
future["data"].(map[string]any)["constructor"] = map[string]any{"retain": true}
future["data"].(map[string]any)["__proto__"] = map[string]any{"ordinary": "JSON data"}
model.Elements["future"] = future
op := modelOperation{ID: modelTestID(1), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: "a", Incarnation: 1}, Field: "ownerCanvasId", Before: modelJSON(modelRootID), After: modelJSON(modelChildID)}}}
after, touched, err := applyModelOperations(model, []modelOperation{op})
if err != nil {
t.Fatal(err)
}
if after.Elements["a"]["id"] != "a" || after.Elements["a"]["ownerCanvasId"] != modelChildID || !touched[modelRootID] || !touched[modelChildID] {
t.Fatal("move changed identity or omitted a participant")
}
if !modelEqual(after.Elements["future"], future) || model.Elements["a"]["ownerCanvasId"] != modelRootID {
t.Fatal("opaque payload or old snapshot was mutated")
}
}
// TestCanonicalDeleteRestoreRejectsOldIncarnation 删除产生墓碑,恢复升级 incarnation;旧代异步字段编辑不能命中新一代同 ID 元素。
func TestCanonicalDeleteRestoreRejectsOldIncarnation(t *testing.T) {
model := modelTestDocument()
deleted, _, err := applyModelOperations(model, []modelOperation{{ID: modelTestID(1), Changes: []modelChange{{Kind: "element", ID: "a", Before: modelJSON(model.Elements["a"]), After: modelJSON(nil)}}}})
if err != nil {
t.Fatal(err)
}
if deleted.Tombstones["a"] != 1 {
t.Fatal("missing tombstone")
}
restored := modelTestNode("a", modelRootID)
restored["incarnation"] = float64(2)
live, _, err := applyModelOperations(deleted, []modelOperation{{ID: modelTestID(2), Changes: []modelChange{{Kind: "element", ID: "a", Before: modelJSON(nil), After: modelJSON(restored)}}}})
if err != nil {
t.Fatal(err)
}
_, _, err = applyModelOperations(live, []modelOperation{{ID: modelTestID(3), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: "a", Incarnation: 1}, Field: "data.title", Before: modelJSON("a"), After: modelJSON("stale")}}}})
if err != errModelConflict || live.Elements["a"]["data"].(map[string]any)["title"] != "a" {
t.Fatal("old callback claimed the restored incarnation")
}
}
// TestCanonicalValidationRejectsPartialChangesAndWrongEdgeOwner 第二个变更失败时输入不变;另构造跨父子的连接却归孩子所有,要求最终模型校验拒绝。
func TestCanonicalValidationRejectsPartialChangesAndWrongEdgeOwner(t *testing.T) {
model := modelTestDocument()
before := modelJSON(model)
operations := []modelOperation{{ID: modelTestID(1), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: "a", Incarnation: 1}, Field: "data.title", Before: modelJSON("a"), After: modelJSON("changed")}, {Kind: "field", Target: modelTarget{ID: "missing", Incarnation: 1}, Field: "geometry", Before: modelJSON(nil), After: modelJSON(nil)}}}}
if _, _, err := applyModelOperations(model, operations); err == nil {
t.Fatal("invalid second change was accepted")
}
if string(modelJSON(model)) != string(before) {
t.Fatal("failed batch changed the source")
}
frame := modelTestNode("f", modelRootID)
frame["componentId"] = "frame"
model.Elements["f"] = frame
model.Canvases[modelChildID] = modelCanvas{ID: modelChildID, Parent: &modelParent{CanvasID: modelRootID, EntryElementID: "f"}}
model.Versions[modelChildID] = 1
model.Elements["child"] = modelTestNode("child", modelChildID)
model.Elements["e"] = map[string]any{"id": "e", "ownerCanvasId": modelChildID, "incarnation": float64(1), "componentId": "connection", "dataVersion": float64(1), "structure": "connection", "data": map[string]any{}, "source": map[string]any{"elementId": "a"}, "target": map[string]any{"elementId": "child"}, "path": nil}
if validateCanvasModel(model) == nil {
t.Fatal("cross-child connection acquired a child owner")
}
}
// TestCanonicalFrontendProtocolFixture 读取嵌入的前端协议样本,验证请求 envelope 与 reducer 兼容,且仅改变预期标题和一次版本。
func TestCanonicalFrontendProtocolFixture(t *testing.T) {
var input modelBatch
decoder := json.NewDecoder(bytes.NewReader(canonicalFrontendFixture))
decoder.DisallowUnknownFields()
if err := decoder.Decode(&input); err != nil {
t.Fatal(err)
}
if input.ProtocolVersion != canvasModelProtocol || !uuidSlugPattern.MatchString(input.RequestID) || input.Expected[modelRootID] != 3 {
t.Fatal("frontend fixture envelope is incompatible")
}
before := modelTestDocument()
before.Versions[modelRootID] = 3
after, touched, err := applyModelOperations(before, input.Operations)
if err != nil {
t.Fatal(err)
}
if !touched[modelRootID] || after.Versions[modelRootID] != 4 || after.Elements["a"]["data"].(map[string]any)["title"] != "renamed" || after.Elements["a"]["data"].(map[string]any)["text"] != "preserved" {
t.Fatal("frontend fixture did not apply exactly its intended field change")
}
}
+153
View File
@@ -0,0 +1,153 @@
// 旧快照操作协议 v1 的纯批处理器,canonical 模型协议 v2 使用另一套 before/after reducer。
package platform
import (
"encoding/json"
"errors"
"fmt"
)
const canvasOperationsProtocol = 1
// canvasOperation 表示节点/边创建、patch 或删除,元素 ID 与完整 Record 内 ID 必须一致。
type canvasOperation struct {
ID string `json:"id"`
Type string `json:"type"`
CanvasID string `json:"canvas_id"`
ElementID string `json:"element_id"`
Record json.RawMessage `json:"record,omitempty"`
Patch map[string]json.RawMessage `json:"patch,omitempty"`
}
// canvasOperationBatch 用请求键及参与画布版本表包裹有序操作,HTTP 编排负责授权和事务。
type canvasOperationBatch struct {
ProtocolVersion int `json:"protocol_version"`
RequestID string `json:"request_id"`
ExpectedVersions map[string]int64 `json:"expected_versions"`
Operations []canvasOperation `json:"operations"`
}
var errInvalidCanvasOperation = errors.New("invalid_canvas_operation")
// applyCanvasOperations stages a complete batch. Input snapshots are never mutated.
// HTTP/auth/version/idempotency are checked by the transaction coordinator.
// applyCanvasOperations 复制所有输入,执行完全部操作才统一 normalize 并各增一次版本,失败不返回部分结果。
func applyCanvasOperations(initial map[string]canvasSnapshot, operations []canvasOperation) (map[string]canvasSnapshot, error) {
if len(operations) == 0 || len(operations) > 2500 {
return nil, errInvalidCanvasOperation
}
documents := make(map[string]map[string]json.RawMessage, len(initial))
for id, snapshot := range initial {
var document map[string]json.RawMessage
if json.Unmarshal(snapshot.Document, &document) != nil {
return nil, errInvalidCanvasOperation
}
documents[id] = document
}
seen := map[string]bool{}
for _, operation := range operations {
if !uuidSlugPattern.MatchString(operation.ID) || seen[operation.ID] || !canvasID.MatchString(operation.ElementID) {
return nil, errInvalidCanvasOperation
}
seen[operation.ID] = true
document := documents[operation.CanvasID]
if document == nil {
return nil, errInvalidCanvasOperation
}
collection := ""
switch operation.Type {
case "node.create", "node.patch", "node.delete":
collection = "nodes"
case "edge.create", "edge.patch", "edge.delete":
collection = "edges"
default:
return nil, errInvalidCanvasOperation
}
var records []map[string]json.RawMessage
if json.Unmarshal(document[collection], &records) != nil {
return nil, errInvalidCanvasOperation
}
index := -1
for i, record := range records {
var id string
_ = json.Unmarshal(record["id"], &id)
if id == operation.ElementID {
index = i
break
}
}
switch operation.Type {
case "node.create", "edge.create":
if index >= 0 || len(operation.Record) == 0 || len(operation.Patch) != 0 {
return nil, fmt.Errorf("%w: create conflict", errInvalidCanvasOperation)
}
var record map[string]json.RawMessage
var id string
if json.Unmarshal(operation.Record, &record) != nil || json.Unmarshal(record["id"], &id) != nil || id != operation.ElementID {
return nil, errInvalidCanvasOperation
}
records = append(records, record)
case "node.delete", "edge.delete":
if index < 0 || len(operation.Record) != 0 || len(operation.Patch) != 0 {
return nil, fmt.Errorf("%w: missing delete target", errInvalidCanvasOperation)
}
records = append(records[:index], records[index+1:]...)
case "node.patch", "edge.patch":
if index < 0 || len(operation.Record) != 0 || len(operation.Patch) == 0 {
return nil, errInvalidCanvasOperation
}
for field, value := range operation.Patch {
allowed := field == "data" || collection == "nodes" && (field == "position" || field == "width" || field == "height") || collection == "edges" && (field == "source" || field == "target" || field == "sourceHandle" || field == "targetHandle")
if !allowed {
return nil, errInvalidCanvasOperation
}
// data 是逐键 merge(null 删除),几何等字段整体替换,避免位置 patch 覆盖其他已保存内容。
if field == "data" {
// Merge individual data fields; a geometry-only patch never rolls back titles/assets.
var before, patch map[string]json.RawMessage
if json.Unmarshal(records[index][field], &before) != nil || json.Unmarshal(value, &patch) != nil || patch == nil {
return nil, errInvalidCanvasOperation
}
if before == nil {
before = map[string]json.RawMessage{}
}
for key, item := range patch {
if string(item) == "null" {
delete(before, key)
} else {
before[key] = item
}
}
encoded, err := json.Marshal(before)
if err != nil {
return nil, err
}
records[index][field] = encoded
} else {
records[index][field] = append(json.RawMessage(nil), value...)
}
}
}
encoded, err := json.Marshal(records)
if err != nil {
return nil, err
}
document[collection] = encoded
}
result := make(map[string]canvasSnapshot, len(initial))
for id, document := range documents {
raw, err := json.Marshal(document)
if err != nil {
return nil, err
}
normalized, valid := normalizeCanvas(raw)
if !valid {
return nil, errInvalidCanvasOperation
}
snapshot := initial[id]
snapshot.Document = normalized
snapshot.Version++
result[id] = snapshot
}
return result, nil
}
+223
View File
@@ -0,0 +1,223 @@
// 旧无界面操作批次 HTTP 协调器,原子验证多快照并冻结成功/终局拒绝回执。
package platform
import (
"database/sql"
"encoding/json"
"io"
"net/http"
"sort"
"time"
)
const canvasOperationsAction = "headless.operations.v1"
// submitCanvasOperations 严格验证协议和参与者,稳定取锁后先重放回执,再比较版本并执行纯批处理。
func (s *service) submitCanvasOperations(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodPost {
reject(w, 405, "method_not_allowed")
return nil
}
if !acceptsCanvasV2(r) {
reject(w, 409, "canvas_schema_upgrade_required")
return nil
}
key := canvasIdempotencyKey(r)
if !uuidSlugPattern.MatchString(key) {
reject(w, 400, "invalid_idempotency_key")
return nil
}
var input canvasOperationBatch
decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, canvasLimit))
decoder.DisallowUnknownFields()
if decoder.Decode(&input) != nil || decoder.Decode(new(any)) != io.EOF || input.ProtocolVersion != canvasOperationsProtocol || input.RequestID != key || len(input.Operations) == 0 || len(input.Operations) > 2500 || len(input.ExpectedVersions) == 0 || len(input.ExpectedVersions) > 64 {
reject(w, 400, "invalid_canvas_operation_batch")
return nil
}
workspace, board := r.PathValue("workspace"), r.PathValue("material")
if _, ok := input.ExpectedVersions[board]; !ok {
reject(w, 428, "version_required")
return nil
}
participants := make([]string, 0, len(input.ExpectedVersions))
for id, version := range input.ExpectedVersions {
if !uuidSlugPattern.MatchString(id) || version < 1 {
reject(w, 400, "invalid_canvas_operation_batch")
return nil
}
participants = append(participants, id)
}
for _, operation := range input.Operations {
if _, ok := input.ExpectedVersions[operation.CanvasID]; !ok {
reject(w, 428, "version_required")
return nil
}
}
sort.Strings(participants)
tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil {
return err
}
defer tx.Rollback()
// lockMaterial serializes the workspace; sorted participants preserve a stable lock order.
for _, id := range participants {
kind, role, e := lockMaterial(r.Context(), tx, project, workspace, id, account)
if e != nil {
return e
}
if kind != "board" {
reject(w, 400, "invalid_material")
return nil
}
if role == "viewer" {
reject(w, 403, "forbidden")
return nil
}
}
// Resolve the same request before comparing expected versions: exact retry after lost ACK succeeds.
done, err := transactionRetry(w, r, tx, project, account, board, canvasOperationsAction, key, payloadDigest(input))
if err != nil {
return err
}
if done {
return nil
}
before := make([]canvasSnapshot, 0, len(participants))
initial := map[string]canvasSnapshot{}
for _, id := range participants {
snapshot, e := loadCanvas(r, tx, project, workspace, id)
if e != nil {
return e
}
if snapshot.Version != input.ExpectedVersions[id] {
return commitCanvasOperationReceipt(w, r, tx, project, account, board, input, 412, response{"error": "version_conflict", "status": "not-applied", "terminal": true, "request_id": key}, nil, nil)
}
initial[id] = snapshot
before = append(before, snapshot)
}
staged, err := applyCanvasOperations(initial, input.Operations)
if err != nil {
return commitCanvasOperationReceipt(w, r, tx, project, account, board, input, 400, response{"error": "invalid_canvas_operation", "status": "not-applied", "terminal": true, "request_id": key}, nil, nil)
}
snapshots := make([]canvasSnapshot, 0, len(participants))
versions := map[string]int64{}
// Validate all participant documents before writing any of them.
// 写快照前逐一验证所有权、AI 模型和资产;任一拒绝结束整个批次。
for _, id := range participants {
snapshot := staged[id]
valid, e := validateCanvasRelations(r, tx, project, workspace, id, initial[id].Document, snapshot.Document)
if e != nil {
return e
}
if !valid {
return commitCanvasOperationReceipt(w, r, tx, project, account, board, input, 409, response{"error": "ownership_conflict", "status": "not-applied", "terminal": true, "request_id": key}, nil, nil)
}
if !s.validateCanvasAIModels(w, r, snapshot.Document) {
return nil
}
valid, e = s.validateCanvasAssets(r, tx, project, workspace, account, snapshot.Document)
if e != nil {
return e
}
if !valid {
return commitCanvasOperationReceipt(w, r, tx, project, account, board, input, 400, response{"error": "invalid_asset_reference", "status": "not-applied", "terminal": true, "request_id": key}, nil, nil)
}
snapshots = append(snapshots, snapshot)
versions[id] = snapshot.Version
}
for _, snapshot := range snapshots {
if err = s.saveCanvas(r, tx, project, workspace, snapshot); err != nil {
return err
}
}
operationIDs := make([]string, 0, len(input.Operations))
for _, operation := range input.Operations {
operationIDs = append(operationIDs, operation.ID)
}
body := response{"protocol_version": canvasOperationsProtocol, "status": "applied", "request_id": key, "operation_ids": operationIDs, "snapshots": snapshots, "applied_versions": versions, "parent": staged[board]}
return commitCanvasOperationReceipt(w, r, tx, project, account, board, input, 200, body, before, versions)
}
// A terminal rejection also reserves the frozen key/body. Losing that response must
// not turn a definite zero-write result into a future execution of the same request.
// commitCanvasOperationReceipt 将应用或 terminal 拒绝写入七天回执,与本事务已做的变更一起提交。
func commitCanvasOperationReceipt(w http.ResponseWriter, r *http.Request, tx *sql.Tx, project, account, board string, input canvasOperationBatch, status int, body response, before []canvasSnapshot, versions map[string]int64) error {
var transactionID string
if err := tx.QueryRowContext(r.Context(), `SELECT gen_random_uuid()::text`).Scan(&transactionID); err != nil {
return err
}
body["transaction_id"] = transactionID
body["protocol_version"] = canvasOperationsProtocol
expires := time.Now().Add(7 * 24 * time.Hour)
bodyRaw, err := json.Marshal(body)
if err != nil {
return err
}
beforeRaw, err := json.Marshal(before)
if err != nil {
return err
}
versionsRaw, err := json.Marshal(versions)
if err != nil {
return err
}
_, err = tx.ExecContext(r.Context(), `INSERT INTO canvas_transactions(project,workspace_id,board_id,id,account_id,action,idempotency_key,payload_hash,response_status,response_body,before_state,after_versions,expires_at) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)`, project, r.PathValue("workspace"), board, transactionID, account, canvasOperationsAction, input.RequestID, payloadDigest(input), status, bodyRaw, beforeRaw, versionsRaw, expires)
if err != nil {
return err
}
if err = tx.Commit(); err != nil {
return err
}
if version := versions[board]; version > 0 {
setVersion(w, version)
}
reply(w, status, body)
return nil
}
// getCanvasOperation 查询本人请求的冻结结果,返回前重查回执内全部快照当前可读性,缺记录为 unknown。
func (s *service) getCanvasOperation(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet {
reject(w, 405, "method_not_allowed")
return nil
}
key := r.PathValue("request")
if !uuidSlugPattern.MatchString(key) {
reject(w, 400, "invalid_request_id")
return nil
}
tx, err := s.db.BeginTx(r.Context(), nil)
if err != nil {
return err
}
defer tx.Rollback()
workspace, board := r.PathValue("workspace"), r.PathValue("material")
if _, _, err = lockMaterial(r.Context(), tx, project, workspace, board, account); err != nil {
return err
}
var raw json.RawMessage
err = tx.QueryRowContext(r.Context(), `SELECT response_body FROM canvas_transactions WHERE project=$1 AND workspace_id=$2 AND board_id=$3 AND account_id=$4 AND action=$5 AND idempotency_key=$6`, project, workspace, board, account, canvasOperationsAction, key).Scan(&raw)
if err == sql.ErrNoRows {
reply(w, 404, response{"status": "unknown", "error": "operation_receipt_unknown", "request_id": key})
return nil
}
if err != nil {
return err
}
var result struct {
Snapshots []canvasSnapshot `json:"snapshots"`
}
if err = json.Unmarshal(raw, &result); err != nil {
return err
}
for _, snapshot := range result.Snapshots {
if _, _, err = lockMaterial(r.Context(), tx, project, workspace, snapshot.BoardID, account); err != nil {
return err
}
}
if err = tx.Rollback(); err != nil {
return err
}
reply(w, 200, raw)
return nil
}
@@ -0,0 +1,172 @@
// 旧 headless 操作批次数据库回归:需要 PLATFORM_TEST_DATABASE_URL 指向隔离且已迁移测试库。
package platform
import (
"bytes"
"context"
"crypto/rand"
"crypto/sha256"
"database/sql"
"encoding/base64"
"encoding/hex"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"os"
"sync"
"testing"
)
// TestCanvasOperationsTransactions 检查应用/拒绝回执可恢复、同键同体重试、权限隔离及多画布批次整体回滚。
func TestCanvasOperationsTransactions(t *testing.T) {
dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL")
if dsn == "" {
t.Skip("requires an isolated integration database")
}
db, err := sql.Open("pgx", dsn)
if err != nil {
t.Fatal(err)
}
defer db.Close()
ctx := context.Background()
var entropy [12]byte
_, _ = rand.Read(entropy[:])
project := "operations-" + hex.EncodeToString(entropy[:])
defer func() {
for _, table := range []string{"canvas_transactions", "workspaces", "project_accounts"} {
_, _ = db.ExecContext(ctx, "DELETE FROM "+table+" WHERE project=$1", project)
}
}()
accounts, tokens := []string{}, []string{}
for range 2 {
var account string
if err = db.QueryRowContext(ctx, `INSERT INTO project_accounts(project,id) VALUES($1,gen_random_uuid()) RETURNING id::text`, project).Scan(&account); err != nil {
t.Fatal(err)
}
var value [32]byte
_, _ = rand.Read(value[:])
token := base64.RawURLEncoding.EncodeToString(value[:])
hash := sha256.Sum256([]byte(token))
if _, err = db.ExecContext(ctx, `INSERT INTO project_sessions(token_hash,project,account_id,expires_at) VALUES($1,$2,$3,now()+interval '1 hour')`, base64.RawURLEncoding.EncodeToString(hash[:]), project, account); err != nil {
t.Fatal(err)
}
accounts, tokens = append(accounts, account), append(tokens, token)
}
var workspace string
if err = db.QueryRowContext(ctx, `INSERT INTO workspaces(project,name,owner_id) VALUES($1,'Operations',$2) RETURNING id::text`, project, accounts[0]).Scan(&workspace); err != nil {
t.Fatal(err)
}
for i, role := range []string{"admin", "viewer"} {
if _, err = db.ExecContext(ctx, `INSERT INTO workspace_members(project,workspace_id,account_id,role) VALUES($1,$2,$3,$4)`, project, workspace, accounts[i], role); err != nil {
t.Fatal(err)
}
}
boards := []string{}
for range 2 {
var board string
if err = db.QueryRowContext(ctx, `INSERT INTO materials(project,workspace_id,kind,title,created_by,canvas_document) VALUES($1,$2,'board','Board',$3,$4) RETURNING id::text`, project, workspace, accounts[0], json.RawMessage(operationsFixture)).Scan(&board); err != nil {
t.Fatal(err)
}
boards = append(boards, board)
}
mux := http.NewServeMux()
Register(mux, db, map[string]string{project: "https://app.example.com/auth/callback"}, "https://api.example.com", nil)
path := "/projects/" + project + "/workspaces/" + workspace + "/materials/" + boards[0] + "/canvas/operations"
key := func(n int) string { return fmt.Sprintf("a0000000-0000-4000-8000-%012d", n) }
// do 执行真实路由,call 断言状态并解码,version 从数据库读取真实 canvas_version。
do := func(method, path, token string, input canvasOperationBatch) *httptest.ResponseRecorder {
encoded, _ := json.Marshal(input)
request := httptest.NewRequest(method, path, bytes.NewReader(encoded))
request.Header.Set("Authorization", "Bearer "+token)
request.Header.Set("Accept", "application/vnd.foundry.canvas+json;version=2")
request.Header.Set("Idempotency-Key", input.RequestID)
writer := httptest.NewRecorder()
mux.ServeHTTP(writer, request)
return writer
}
call := func(method, path, token string, input canvasOperationBatch, status int) response {
t.Helper()
writer := do(method, path, token, input)
if writer.Code != status {
t.Fatalf("%s %s got %d %s want %d", method, path, writer.Code, writer.Body.String(), status)
}
out := response{}
if err := json.Unmarshal(writer.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
return out
}
version := func(board string) int64 {
t.Helper()
var value int64
if err := db.QueryRowContext(ctx, `SELECT canvas_version FROM materials WHERE project=$1 AND workspace_id=$2 AND id=$3`, project, workspace, board).Scan(&value); err != nil {
t.Fatal(err)
}
return value
}
batch := func(n int, expected int64) canvasOperationBatch {
return canvasOperationBatch{ProtocolVersion: 1, RequestID: key(n), ExpectedVersions: map[string]int64{boards[0]: expected}, Operations: []canvasOperation{{ID: key(n + 100), Type: "node.patch", CanvasID: boards[0], ElementID: "a", Patch: map[string]json.RawMessage{"data": json.RawMessage(`{"title":"renamed"}`)}}}}
}
firstBody := batch(1, 1)
first := call("POST", path, tokens[0], firstBody, 200)
retried := call("POST", path, tokens[0], firstBody, 200)
if first["transaction_id"] != retried["transaction_id"] || version(boards[0]) != 2 {
t.Fatal("retry duplicated writes or changed receipt identity")
}
queried := call("GET", path+"/"+key(1), tokens[0], canvasOperationBatch{}, 200)
if queried["status"] != "applied" || queried["transaction_id"] != first["transaction_id"] {
t.Fatal("lost acknowledgment cannot be resolved by request identity")
}
altered := batch(1, 2)
call("POST", path, tokens[0], altered, 409)
call("GET", path+"/"+key(1), tokens[1], canvasOperationBatch{}, 404)
call("POST", path, tokens[1], batch(2, 2), 403)
unknown := call("GET", path+"/"+key(999), tokens[0], canvasOperationBatch{}, 404)
if unknown["status"] != "unknown" || unknown["terminal"] == true {
t.Fatal("missing receipt must not claim terminal zero writes")
}
// Terminal zero-write responses must remain queryable and reserve their frozen body.
// 终局拒绝冻结原键和请求体,不能修正版本后沿用同一键让先前零效果变为实际执行。
stale := batch(3, 1)
rejected := call("POST", path, tokens[0], stale, 412)
proof := call("GET", path+"/"+key(3), tokens[0], canvasOperationBatch{}, 200)
if proof["status"] != "not-applied" || proof["terminal"] != true || proof["transaction_id"] != rejected["transaction_id"] {
t.Fatal("terminal rejection was not persisted")
}
call("POST", path, tokens[0], batch(3, 2), 409)
if version(boards[0]) != 2 {
t.Fatal("rejected request performed a write")
}
// Concurrent exact retries serialize to one transaction and one version increment.
// 四条同键并发请求共享原回执,数据库版本只能前进一次。
concurrent := batch(4, 2)
var wait sync.WaitGroup
results := make(chan *httptest.ResponseRecorder, 4)
for range 4 {
wait.Add(1)
go func() { defer wait.Done(); results <- do("POST", path, tokens[0], concurrent) }()
}
wait.Wait()
close(results)
for result := range results {
if result.Code != 200 {
t.Fatalf("concurrent retry got %d %s", result.Code, result.Body.String())
}
}
if version(boards[0]) != 3 {
t.Fatal("concurrent request executed more than once")
}
// A valid first participant and an invalid second participant produce no partial write.
// 首画布 patch 合法但次画布删除不存在节点,检查两者版本都不变且拒绝回执可查。
atomic := batch(5, 3)
atomic.ExpectedVersions[boards[1]] = 1
atomic.Operations = append(atomic.Operations, canvasOperation{ID: key(500), Type: "node.delete", CanvasID: boards[1], ElementID: "missing"})
call("POST", path, tokens[0], atomic, 400)
if version(boards[0]) != 3 || version(boards[1]) != 1 {
t.Fatal("invalid multi-canvas batch partially committed")
}
if call("GET", path+"/"+key(5), tokens[0], canvasOperationBatch{}, 200)["status"] != "not-applied" {
t.Fatal("invalid batch lost its terminal receipt")
}
}
@@ -0,0 +1,69 @@
// 模型/协议纯回归:用内存对象与 recorder 验证身份、原子变更或流传输契约,不访问真实数据库。
package platform
import (
"encoding/json"
"testing"
)
const operationsFixture = `{"schema_version":2,"nodes":[{"id":"a","type":"plainText","position":{"x":0,"y":0},"width":240,"height":72,"data":{"kind":"plain-text","title":"original","text":"hello"}}],"edges":[],"viewport":{"x":0,"y":0,"zoom":1}}`
// TestCanvasOperationBatchStagesAndMerges 连续执行 data 标题 patch 和位置 patch,验证无关文本保留、整批只加一次版本且输入 JSON 不变。
func TestCanvasOperationBatchStagesAndMerges(t *testing.T) {
initial := map[string]canvasSnapshot{"board": {BoardID: "board", Version: 7, Document: json.RawMessage(operationsFixture)}}
operations := []canvasOperation{
{ID: "11111111-1111-4111-8111-111111111111", Type: "node.patch", CanvasID: "board", ElementID: "a", Patch: map[string]json.RawMessage{"data": json.RawMessage(`{"title":"renamed"}`)}},
{ID: "22222222-2222-4222-8222-222222222222", Type: "node.patch", CanvasID: "board", ElementID: "a", Patch: map[string]json.RawMessage{"position": json.RawMessage(`{"x":90,"y":20}`)}},
}
result, err := applyCanvasOperations(initial, operations)
if err != nil {
t.Fatal(err)
}
if result["board"].Version != 8 {
t.Fatal("version did not advance once")
}
var document struct {
Nodes []struct {
Position struct{ X float64 }
Data struct {
Title string
Text string
}
}
}
if err = json.Unmarshal(result["board"].Document, &document); err != nil {
t.Fatal(err)
}
if document.Nodes[0].Data.Title != "renamed" || document.Nodes[0].Data.Text != "hello" || document.Nodes[0].Position.X != 90 {
t.Fatal("field merge lost unrelated content")
}
if string(initial["board"].Document) != operationsFixture {
t.Fatal("input snapshot mutated")
}
}
// TestCanvasOperationBatchRejectsWithoutPartialOutput 拒绝改 ID、缺目标及指向缺失节点的边,要求错误时不返回任何部分批次结果。
func TestCanvasOperationBatchRejectsWithoutPartialOutput(t *testing.T) {
initial := map[string]canvasSnapshot{"board": {BoardID: "board", Version: 1, Document: json.RawMessage(operationsFixture)}}
for _, operation := range []canvasOperation{
{ID: "11111111-1111-4111-8111-111111111111", Type: "node.patch", CanvasID: "board", ElementID: "a", Patch: map[string]json.RawMessage{"id": json.RawMessage(`"stolen"`)}},
{ID: "11111111-1111-4111-8111-111111111111", Type: "node.patch", CanvasID: "board", ElementID: "missing", Patch: map[string]json.RawMessage{"data": json.RawMessage(`{"title":"no"}`)}},
{ID: "11111111-1111-4111-8111-111111111111", Type: "edge.create", CanvasID: "board", ElementID: "edge", Record: json.RawMessage(`{"id":"edge","source":"a","target":"missing"}`)},
} {
if result, err := applyCanvasOperations(initial, []canvasOperation{operation}); err == nil || result != nil {
t.Fatal("invalid batch partially accepted")
}
}
}
// TestCanvasOperationBatchValidatesFinalGraphInsteadOfIntermediateState 先创建指向 b 的边再创建 b,验证只对整批最终图做引用校验。
func TestCanvasOperationBatchValidatesFinalGraphInsteadOfIntermediateState(t *testing.T) {
initial := map[string]canvasSnapshot{"board": {BoardID: "board", Version: 1, Document: json.RawMessage(operationsFixture)}}
operations := []canvasOperation{
{ID: "11111111-1111-4111-8111-111111111111", Type: "edge.create", CanvasID: "board", ElementID: "edge", Record: json.RawMessage(`{"id":"edge","source":"a","target":"b"}`)},
{ID: "22222222-2222-4222-8222-222222222222", Type: "node.create", CanvasID: "board", ElementID: "b", Record: json.RawMessage(`{"id":"b","type":"plainText","position":{"x":20,"y":20},"width":240,"height":72,"data":{"kind":"plain-text","title":"b","text":""}}`)},
}
if _, err := applyCanvasOperations(initial, operations); err != nil {
t.Fatal(err)
}
}
+8
View File
@@ -1,3 +1,4 @@
// frame 子图扩展与普通快照的所有权守卫,防止绕开多画布事务改写关系。
package platform package platform
import ( import (
@@ -8,6 +9,8 @@ import (
"strings" "strings"
) )
// validCanvasFrameExtensions 仅允许 v2 frame 携带子图、端口和折叠展示配置,检查形状与本地 ID 唯一性。
// 端口 nodeId 的跨文档存在性留给持锁关系命令验证。
func validCanvasFrameExtensions(d map[string]any, v2 bool) bool { func validCanvasFrameExtensions(d map[string]any, v2 bool) bool {
for _, key := range []string{"subgraph", "ports", "presentation"} { for _, key := range []string{"subgraph", "ports", "presentation"} {
value, exists := d[key] value, exists := d[key]
@@ -74,6 +77,7 @@ func validCanvasFrameExtensions(d map[string]any, v2 bool) bool {
return true return true
} }
// canvasNodeData 从已规范化文档提取 id→data;依赖节点形状已验证,不适合直接读取未校验请求。
func canvasNodeData(raw json.RawMessage) map[string]map[string]any { func canvasNodeData(raw json.RawMessage) map[string]map[string]any {
var doc map[string]any var doc map[string]any
_ = json.Unmarshal(raw, &doc) _ = json.Unmarshal(raw, &doc)
@@ -88,6 +92,7 @@ func canvasNodeData(raw json.RawMessage) map[string]map[string]any {
// Ordinary saves cannot create, replace, detach or retarget ownership/ports. // Ordinary saves cannot create, replace, detach or retarget ownership/ports.
// Cross-board commands validate these changes while holding the workspace lock. // Cross-board commands validate these changes while holding the workspace lock.
// validateCanvasRelations 在工作区锁下将新快照与数据库活跃子图关系比较,普通保存不得删除/换绑 frame 或端口。
func validateCanvasRelations(r *http.Request, tx *sql.Tx, project, workspace, board string, before, after json.RawMessage) (bool, error) { func validateCanvasRelations(r *http.Request, tx *sql.Tx, project, workspace, board string, before, after json.RawMessage) (bool, error) {
old, next := canvasNodeData(before), canvasNodeData(after) old, next := canvasNodeData(before), canvasNodeData(after)
rows, err := tx.QueryContext(r.Context(), `SELECT frame_id,child_board_id::text FROM canvas_subgraphs WHERE project=$1 AND workspace_id=$2 AND parent_board_id=$3 AND archived_at IS NULL`, project, workspace, board) rows, err := tx.QueryContext(r.Context(), `SELECT frame_id,child_board_id::text FROM canvas_subgraphs WHERE project=$1 AND workspace_id=$2 AND parent_board_id=$3 AND archived_at IS NULL`, project, workspace, board)
@@ -115,6 +120,7 @@ func validateCanvasRelations(r *http.Request, tx *sql.Tx, project, workspace, bo
return false, nil return false, nil
} }
} }
// 新增伪子图、无关系的非空端口,或把本地图节点挂进已拥有独立子画布的 frame 都拒绝。
for id, d := range next { for id, d := range next {
if sub, exists := d["subgraph"]; exists { if sub, exists := d["subgraph"]; exists {
m, _ := sub.(map[string]any) m, _ := sub.(map[string]any)
@@ -130,6 +136,7 @@ func validateCanvasRelations(r *http.Request, tx *sql.Tx, project, workspace, bo
} }
} }
// A child node referenced by its parent's ports must not disappear or change kind. // A child node referenced by its parent's ports must not disappear or change kind.
// 若当前画布是孩子,还要保持父端口引用的节点存在且种类不变;无父关系则无需此检查。
var parentRaw json.RawMessage var parentRaw json.RawMessage
err = tx.QueryRowContext(r.Context(), `SELECT m.canvas_document FROM canvas_subgraphs s JOIN materials m ON m.project=s.project AND m.workspace_id=s.workspace_id AND m.id=s.parent_board_id WHERE s.project=$1 AND s.workspace_id=$2 AND s.child_board_id=$3 AND s.archived_at IS NULL`, project, workspace, board).Scan(&parentRaw) err = tx.QueryRowContext(r.Context(), `SELECT m.canvas_document FROM canvas_subgraphs s JOIN materials m ON m.project=s.project AND m.workspace_id=s.workspace_id AND m.id=s.parent_board_id WHERE s.project=$1 AND s.workspace_id=$2 AND s.child_board_id=$3 AND s.archived_at IS NULL`, project, workspace, board).Scan(&parentRaw)
if err == sql.ErrNoRows { if err == sql.ErrNoRows {
@@ -155,6 +162,7 @@ func validateCanvasRelations(r *http.Request, tx *sql.Tx, project, workspace, bo
return true, nil return true, nil
} }
// validCanvasPortHandle 接受四个基础方向,或指向另一个已命名端口的 port:<id>。
func validCanvasPortHandle(value any) bool { func validCanvasPortHandle(value any) bool {
if canvasChoice(value, "top", "right", "bottom", "left") { if canvasChoice(value, "top", "right", "bottom", "left") {
return true return true
+8
View File
@@ -1,3 +1,4 @@
// 画布与资产纯函数回归;测试说明对应实际断言,不依赖浏览器或真实模型。
package platform package platform
import ( import (
@@ -6,8 +7,10 @@ import (
"testing" "testing"
) )
// canvasFixture 同时供多组回归使用:含中文文本、脚本、不可连线图标及临时 selected。
const canvasFixture = `{"schema_version":1,"nodes":[{"id":"a","type":"material","position":{"x":100,"y":200},"width":320,"height":220,"selected":true,"data":{"kind":"text","title":"灵感笔记","text":"正文","rotation":30,"fontSize":24,"textStyle":{"color":"#37352f","background":"transparent","bold":true,"italic":false,"underline":false,"align":"left","fontFamily":"sans","lineHeight":1.5}}},{"id":"b","type":"material","position":{"x":0,"y":0},"data":{"kind":"script","title":"Script","text":""}},{"id":"icon","type":"icon","position":{"x":500,"y":200},"width":80,"height":80,"data":{"kind":"icon","title":"火箭","text":"","icon":"Rocket","rotation":0}}],"edges":[{"id":"e","source":"a","target":"b","sourceHandle":"top","targetHandle":"bottom"}],"viewport":{"x":0,"y":0,"zoom":1}}` const canvasFixture = `{"schema_version":1,"nodes":[{"id":"a","type":"material","position":{"x":100,"y":200},"width":320,"height":220,"selected":true,"data":{"kind":"text","title":"灵感笔记","text":"正文","rotation":30,"fontSize":24,"textStyle":{"color":"#37352f","background":"transparent","bold":true,"italic":false,"underline":false,"align":"left","fontFamily":"sans","lineHeight":1.5}}},{"id":"b","type":"material","position":{"x":0,"y":0},"data":{"kind":"script","title":"Script","text":""}},{"id":"icon","type":"icon","position":{"x":500,"y":200},"width":80,"height":80,"data":{"kind":"icon","title":"火箭","text":"","icon":"Rocket","rotation":0}}],"edges":[{"id":"e","source":"a","target":"b","sourceHandle":"top","targetHandle":"bottom"}],"viewport":{"x":0,"y":0,"zoom":1}}`
// TestCanvasValidation 从合法快照逐项破坏类型、范围、引用和版本,检查临时 selected 不落库以及必需文档结构。
func TestCanvasValidation(t *testing.T) { func TestCanvasValidation(t *testing.T) {
out, ok := normalizeCanvas(json.RawMessage(canvasFixture)) out, ok := normalizeCanvas(json.RawMessage(canvasFixture))
if !ok || strings.Contains(string(out), "selected") { if !ok || strings.Contains(string(out), "selected") {
@@ -27,6 +30,8 @@ func TestCanvasValidation(t *testing.T) {
} }
} }
} }
// TestSlugValidation 检查小写连字符别名可用,拒绝空值、空格大写、路径穿越和超长别名。
func TestSlugValidation(t *testing.T) { func TestSlugValidation(t *testing.T) {
for _, v := range []string{"my-board", "workspace-2026"} { for _, v := range []string{"my-board", "workspace-2026"} {
if !validSlug(&v) { if !validSlug(&v) {
@@ -41,8 +46,10 @@ func TestSlugValidation(t *testing.T) {
} }
// Frame nodes follow the frontend contract: membership is data, not containment. // Frame nodes follow the frontend contract: membership is data, not containment.
// frameFixture 把重叠的 outside 留在框外,以区分几何包含与显式 frameId 成员关系。
const frameFixture = `{"schema_version":1,"nodes":[{"id":"text","type":"material","position":{"x":100,"y":100},"data":{"kind":"text","title":"成员","text":"正文","frameId":"frame"}},{"id":"plain","type":"plainText","position":{"x":0,"y":0},"data":{"kind":"plain-text","title":"纯文本","text":"文字","frameId":"frame"}},{"id":"icon","type":"icon","position":{"x":10,"y":10},"data":{"kind":"icon","title":"图标","text":"","icon":"Star","frameId":"frame"}},{"id":"frame","type":"frame","position":{"x":0,"y":0},"width":600,"height":400,"zIndex":-1,"style":{"width":600,"height":400,"pointerEvents":"none"},"data":{"kind":"frame","title":"框选区","text":"","rotation":0,"labelMode":"fixed"}},{"id":"outside","type":"material","position":{"x":100,"y":100},"data":{"kind":"script","title":"重叠但未加入","text":""}}],"edges":[],"viewport":{"x":0,"y":0,"zoom":1}}` const frameFixture = `{"schema_version":1,"nodes":[{"id":"text","type":"material","position":{"x":100,"y":100},"data":{"kind":"text","title":"成员","text":"正文","frameId":"frame"}},{"id":"plain","type":"plainText","position":{"x":0,"y":0},"data":{"kind":"plain-text","title":"纯文本","text":"文字","frameId":"frame"}},{"id":"icon","type":"icon","position":{"x":10,"y":10},"data":{"kind":"icon","title":"图标","text":"","icon":"Star","frameId":"frame"}},{"id":"frame","type":"frame","position":{"x":0,"y":0},"width":600,"height":400,"zIndex":-1,"style":{"width":600,"height":400,"pointerEvents":"none"},"data":{"kind":"frame","title":"框选区","text":"","rotation":0,"labelMode":"fixed"}},{"id":"outside","type":"material","position":{"x":100,"y":100},"data":{"kind":"script","title":"重叠但未加入","text":""}}],"edges":[],"viewport":{"x":0,"y":0,"zoom":1}}`
// TestCanvasFrames 检查三种标签模式、显式成员关系、临时渲染字段剔除;框不可旋转/嵌套为成员,v1 边不可连到框。
func TestCanvasFrames(t *testing.T) { func TestCanvasFrames(t *testing.T) {
for _, mode := range []string{"hidden", "fixed", "scaled"} { for _, mode := range []string{"hidden", "fixed", "scaled"} {
t.Run(mode, func(t *testing.T) { t.Run(mode, func(t *testing.T) {
@@ -89,6 +96,7 @@ func TestCanvasFrames(t *testing.T) {
} }
} }
// TestCanvasPlainImages 验证 v1 plainImage 的类型与源地址契约,以及显式 frameId;v1 下纯图片不能作为连线端点。
func TestCanvasPlainImages(t *testing.T) { func TestCanvasPlainImages(t *testing.T) {
fixture := `{"schema_version":1,"nodes":[{"id":"photo","type":"plainImage","position":{"x":20,"y":30},"width":320,"height":240,"data":{"kind":"plain-image","title":"Photo","text":"","src":"https://example.com/photo.png","rotation":30,"frameId":"frame"}},{"id":"frame","type":"frame","position":{"x":0,"y":0},"width":640,"height":400,"data":{"kind":"frame","title":"Frame","text":"","labelMode":"fixed"}}],"edges":[],"viewport":{"x":0,"y":0,"zoom":1}}` fixture := `{"schema_version":1,"nodes":[{"id":"photo","type":"plainImage","position":{"x":20,"y":30},"width":320,"height":240,"data":{"kind":"plain-image","title":"Photo","text":"","src":"https://example.com/photo.png","rotation":30,"frameId":"frame"}},{"id":"frame","type":"frame","position":{"x":0,"y":0},"width":640,"height":400,"data":{"kind":"frame","title":"Frame","text":"","labelMode":"fixed"}}],"edges":[],"viewport":{"x":0,"y":0,"zoom":1}}`
if _, ok := normalizeCanvas(json.RawMessage(fixture)); !ok { if _, ok := normalizeCanvas(json.RawMessage(fixture)); !ok {
+8
View File
@@ -1,3 +1,4 @@
// 旧多画布事务撤销:校验回执有效性与当前后态,恢复文档/关系并创建独立幂等撤销回执。
package platform package platform
import ( import (
@@ -7,6 +8,7 @@ import (
"strings" "strings"
) )
// undoCanvasTransaction 只支持列出的子图/连接动作,过期或已撤销回执不可再次执行。
func (s *service) undoCanvasTransaction(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) undoCanvasTransaction(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodPost { if r.Method != http.MethodPost {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -91,6 +93,7 @@ func (s *service) undoCanvasTransaction(w http.ResponseWriter, r *http.Request,
if err = json.Unmarshal(relationsRaw, &changes); err != nil { if err = json.Unmarshal(relationsRaw, &changes); err != nil {
return err return err
} }
// 归档孩子无法按普通素材路径授权,需通过其当前父画布验证编辑权限;关系必须仍等于原 After。
archivedParticipants := map[string]bool{} archivedParticipants := map[string]bool{}
for _, change := range changes { for _, change := range changes {
actual, err := readSubgraphRelation(r, tx, project, workspace, change.After.Child) actual, err := readSubgraphRelation(r, tx, project, workspace, change.After.Child)
@@ -122,6 +125,7 @@ func (s *service) undoCanvasTransaction(w http.ResponseWriter, r *http.Request,
if err = json.Unmarshal(afterResponse, &recorded); err != nil { if err = json.Unmarshal(afterResponse, &recorded); err != nil {
return err return err
} }
// 从原响应的不同形态收集操作后文档,用内容相等而非原版本号判断是否仍可安全栈式撤销。
afterStates := map[string]json.RawMessage{} afterStates := map[string]json.RawMessage{}
if recorded.Parent.BoardID != "" { if recorded.Parent.BoardID != "" {
afterStates[recorded.Parent.BoardID] = recorded.Parent.Document afterStates[recorded.Parent.BoardID] = recorded.Parent.Document
@@ -153,12 +157,14 @@ func (s *service) undoCanvasTransaction(w http.ResponseWriter, r *http.Request,
reject(w, 428, "version_required") reject(w, 428, "version_required")
return nil return nil
} }
// 客户端确认当前版本,服务端还确认当前内容等于原后态,防止覆盖后续独立编辑。
if expected != snapshot.Version || !sameCanvasDocument(snapshot.Document, afterStates[id]) { if expected != snapshot.Version || !sameCanvasDocument(snapshot.Document, afterStates[id]) {
reject(w, 412, "version_conflict") reject(w, 412, "version_conflict")
return nil return nil
} }
current[id] = snapshot current[id] = snapshot
} }
// 全部参与者校验完再恢复关系与快照;版本以当前值加一推进,绝不倒退到历史版本。
for _, change := range changes { for _, change := range changes {
if err = writeSubgraphRelation(r, tx, project, workspace, change.Before); err != nil { if err = writeSubgraphRelation(r, tx, project, workspace, change.Before); err != nil {
return err return err
@@ -176,6 +182,7 @@ func (s *service) undoCanvasTransaction(w http.ResponseWriter, r *http.Request,
updated = append(updated, snapshot) updated = append(updated, snapshot)
appliedVersions[snapshot.BoardID] = snapshot.Version appliedVersions[snapshot.BoardID] = snapshot.Version
} }
// 原操作前不存在的孩子不删除,归档并使旧版本失效,保留完整数据供恢复。
archived := []string{} archived := []string{}
for id, snapshot := range current { for id, snapshot := range current {
if beforeIDs[id] { if beforeIDs[id] {
@@ -223,6 +230,7 @@ func (s *service) undoCanvasTransaction(w http.ResponseWriter, r *http.Request,
return nil return nil
} }
// sameCanvasDocument 解码后重编码比较摘要,忽略 JSON 对象键顺序,无法解码时明确不相等。
func sameCanvasDocument(a, b json.RawMessage) bool { func sameCanvasDocument(a, b json.RawMessage) bool {
var first, second any var first, second any
if json.Unmarshal(a, &first) != nil || json.Unmarshal(b, &second) != nil { if json.Unmarshal(a, &first) != nil || json.Unmarshal(b, &second) != nil {
+8
View File
@@ -1,3 +1,4 @@
// schema v2 的协商、点与边扩展校验;这些纯检查被快照、连接和事务命令复用。
package platform package platform
import ( import (
@@ -9,6 +10,7 @@ import (
"strings" "strings"
) )
// canvasSchema 只读取版本字段,无法解码时返回零;不能替代 normalizeCanvas 的完整验证。
func canvasSchema(raw json.RawMessage) int { func canvasSchema(raw json.RawMessage) int {
var d struct { var d struct {
Version int `json:"schema_version"` Version int `json:"schema_version"`
@@ -17,6 +19,7 @@ func canvasSchema(raw json.RawMessage) int {
return d.Version return d.Version
} }
// acceptsCanvasV2 逐项解析 Accept 媒体类型,要求明确 version=2,且存在 q 时必须在 (0,1]。
func acceptsCanvasV2(r *http.Request) bool { func acceptsCanvasV2(r *http.Request) bool {
for _, value := range strings.Split(r.Header.Get("Accept"), ",") { for _, value := range strings.Split(r.Header.Get("Accept"), ",") {
typ, params, err := mime.ParseMediaType(strings.TrimSpace(value)) typ, params, err := mime.ParseMediaType(strings.TrimSpace(value))
@@ -33,11 +36,13 @@ func acceptsCanvasV2(r *http.Request) bool {
return false return false
} }
// canvasPoint 要求完整 x/y 与有限百万坐标范围,供贝塞尔控制点和结点偏移使用。
func canvasPoint(v any) bool { func canvasPoint(v any) bool {
p, ok := v.(map[string]any) p, ok := v.(map[string]any)
return ok && canvasFields(p, "x", "y") && canvasNumber(p["x"], -1e6, 1e6) && canvasNumber(p["y"], -1e6, 1e6) return ok && canvasFields(p, "x", "y") && canvasNumber(p["x"], -1e6, 1e6) && canvasNumber(p["y"], -1e6, 1e6)
} }
// validCanvasEdgeData 分别检查外观、动画、执行开关和贝塞尔链;省略分组合法,出现时拒绝未知键。
func validCanvasEdgeData(v any) bool { func validCanvasEdgeData(v any) bool {
d, ok := v.(map[string]any) d, ok := v.(map[string]any)
if !ok || !canvasFields(d, "appearance", "animation", "path", "execution") { if !ok || !canvasFields(d, "appearance", "animation", "path", "execution") {
@@ -117,6 +122,7 @@ func validCanvasEdgeData(v any) bool {
} }
} }
case "execution": case "execution":
// 执行事件是否启用与展示动画独立,协议只允许布尔 enabled。
if !canvasFields(m, "enabled") { if !canvasFields(m, "enabled") {
return false return false
} }
@@ -126,6 +132,7 @@ func validCanvasEdgeData(v any) bool {
} }
} }
case "path": case "path":
// 路径仅支持 bezier-chain,最多 64 个唯一 ID 的 knot,每个 knot 有位置与进/出切线。
if !canvasFields(m, "type", "startControl", "endControl", "knots") || m["type"] != "bezier-chain" { if !canvasFields(m, "type", "startControl", "endControl", "knots") || m["type"] != "bezier-chain" {
return false return false
} }
@@ -157,6 +164,7 @@ func validCanvasEdgeData(v any) bool {
if !canvasChoice(knot["mode"], "corner", "smooth", "symmetric") { if !canvasChoice(knot["mode"], "corner", "smooth", "symmetric") {
return false return false
} }
// smooth 要求非零切线反向共线;symmetric 进一步要求长度相等,使用相对误差容忍浮点噪声。
if knot["mode"] != "corner" { if knot["mode"] != "corner" {
a, b := knot["in"].(map[string]any), knot["out"].(map[string]any) a, b := knot["in"].(map[string]any), knot["out"].(map[string]any)
ax, ay, bx, by := a["x"].(float64), a["y"].(float64), b["x"].(float64), b["y"].(float64) ax, ay, bx, by := a["x"].(float64), a["y"].(float64), b["x"].(float64), b["y"].(float64)
+5
View File
@@ -1,3 +1,4 @@
// 画布与资产纯函数回归;测试说明对应实际断言,不依赖浏览器或真实模型。
package platform package platform
import ( import (
@@ -10,6 +11,7 @@ import (
"testing" "testing"
) )
// TestCanvasV2EdgeRoundTrip 保存带外观、动画、曲线和执行配置的 v2 边,并逐项破坏范围/枚举/切线关系,验证不丢字段且拒绝非法配置。
func TestCanvasV2EdgeRoundTrip(t *testing.T) { func TestCanvasV2EdgeRoundTrip(t *testing.T) {
raw := strings.Replace(canvasFixture, `"schema_version":1`, `"schema_version":2`, 1) raw := strings.Replace(canvasFixture, `"schema_version":1`, `"schema_version":2`, 1)
data := `{"appearance":{"color":"#AA968B","width":2,"opacity":1,"line":"dashed","head":{"type":"triangle","size":12,"filled":true},"tail":{"type":"circle","size":8,"filled":false}},"animation":{"mode":"executing","effect":"flow","direction":"reverse","durationMs":1600,"color":"#FFFFFF"},"path":{"type":"bezier-chain","startControl":{"x":90,"y":0},"endControl":{"x":-90,"y":0},"knots":[{"id":"k1","position":{"x":450,"y":280},"in":{"x":-60,"y":0},"out":{"x":60,"y":0},"mode":"symmetric"}]},"execution":{"enabled":true}}` data := `{"appearance":{"color":"#AA968B","width":2,"opacity":1,"line":"dashed","head":{"type":"triangle","size":12,"filled":true},"tail":{"type":"circle","size":8,"filled":false}},"animation":{"mode":"executing","effect":"flow","direction":"reverse","durationMs":1600,"color":"#FFFFFF"},"path":{"type":"bezier-chain","startControl":{"x":90,"y":0},"endControl":{"x":-90,"y":0},"knots":[{"id":"k1","position":{"x":450,"y":280},"in":{"x":-60,"y":0},"out":{"x":60,"y":0},"mode":"symmetric"}]},"execution":{"enabled":true}}`
@@ -39,6 +41,7 @@ func TestCanvasV2EdgeRoundTrip(t *testing.T) {
} }
} }
// TestCanvasSchemaAccept 验证媒体类型列表中的显式 version=2 协商,拒绝 q=0、NaN 和相似但不同的版本号。
func TestCanvasSchemaAccept(t *testing.T) { func TestCanvasSchemaAccept(t *testing.T) {
for _, tc := range []struct { for _, tc := range []struct {
accept string accept string
@@ -59,6 +62,7 @@ func TestCanvasSchemaAccept(t *testing.T) {
} }
} }
// TestCanvasV2CurveLimits 检查 64 个 knot 的边界、重复 knot ID 及非有限/越界点;直接构造 float64 覆盖 JSON 不表示的 NaN。
func TestCanvasV2CurveLimits(t *testing.T) { func TestCanvasV2CurveLimits(t *testing.T) {
knot := func(id string) map[string]any { knot := func(id string) map[string]any {
return map[string]any{"id": id, "position": map[string]any{"x": 0.0, "y": 0.0}, "in": map[string]any{"x": -1.0, "y": 0.0}, "out": map[string]any{"x": 1.0, "y": 0.0}, "mode": "smooth"} return map[string]any{"id": id, "position": map[string]any{"x": 0.0, "y": 0.0}, "in": map[string]any{"x": -1.0, "y": 0.0}, "out": map[string]any{"x": 1.0, "y": 0.0}, "mode": "smooth"}
@@ -86,6 +90,7 @@ func TestCanvasV2CurveLimits(t *testing.T) {
} }
} }
// TestCanvasV2AppearanceAndAnimationEnums 遍历受支持标记/线型与动画模式/效果/方向的组合,保证合法枚举组合可被接受。
func TestCanvasV2AppearanceAndAnimationEnums(t *testing.T) { func TestCanvasV2AppearanceAndAnimationEnums(t *testing.T) {
for _, marker := range []string{"none", "open-arrow", "triangle", "circle", "diamond", "square"} { for _, marker := range []string{"none", "open-arrow", "triangle", "circle", "diamond", "square"} {
for _, line := range []string{"solid", "dashed", "dotted"} { for _, line := range []string{"solid", "dashed", "dotted"} {
+19
View File
@@ -1,3 +1,4 @@
// 素材内容 schema v1 的纯校验与规范化,不负责网络抓图或数据库存储。
package platform package platform
import ( import (
@@ -8,32 +9,43 @@ import (
"regexp" "regexp"
) )
// Paragraph 与 Section 的 ID 在同一文章内共享唯一命名空间,用于稳定引用内容块。
type Paragraph struct { type Paragraph struct {
ID string `json:"id"` ID string `json:"id"`
Text string `json:"text"` Text string `json:"text"`
Description string `json:"description,omitempty"` Description string `json:"description,omitempty"`
} }
// Section 聚合标题、描述和有序段落;数量及总段落预算由 validArticle 检查。
type Section struct { type Section struct {
ID string `json:"id"` ID string `json:"id"`
Title string `json:"title"` Title string `json:"title"`
Description string `json:"description,omitempty"` Description string `json:"description,omitempty"`
Paragraphs []Paragraph `json:"paragraphs"` Paragraphs []Paragraph `json:"paragraphs"`
} }
// Article 是有序章节容器,可为空文章,但必须有非 nil 的 Article 对象。
type Article struct { type Article struct {
Sections []Section `json:"sections"` Sections []Section `json:"sections"`
} }
// Image 仅保存 HTTPS 引用及展示信息,尺寸零值表示未提供,不在这里读取远程资源。
type Image struct { type Image struct {
URL string `json:"url"` URL string `json:"url"`
Alt string `json:"alt,omitempty"` Alt string `json:"alt,omitempty"`
Width int `json:"width,omitempty"` Width int `json:"width,omitempty"`
Height int `json:"height,omitempty"` Height int `json:"height,omitempty"`
} }
// CardPart 是带 Kind 的互斥联合,一次只能提供对应的 text/article/image 内容。
type CardPart struct { type CardPart struct {
Kind string `json:"kind"` Kind string `json:"kind"`
Text *string `json:"text,omitempty"` Text *string `json:"text,omitempty"`
Article *Article `json:"article,omitempty"` Article *Article `json:"article,omitempty"`
Image *Image `json:"image,omitempty"` Image *Image `json:"image,omitempty"`
} }
// Content 按素材种类使用互斥字段;board 只存 schema 标记,画布节点通过专用协议管理。
type Content struct { type Content struct {
SchemaVersion int `json:"schema_version"` SchemaVersion int `json:"schema_version"`
Text *string `json:"text,omitempty"` Text *string `json:"text,omitempty"`
@@ -44,6 +56,7 @@ type Content struct {
var blockID = regexp.MustCompile(`^[A-Za-z0-9_-]{1,64}$`) var blockID = regexp.MustCompile(`^[A-Za-z0-9_-]{1,64}$`)
// validArticle 限制章节、段落和文本字节数,并用一个 seen 集合拒绝章节/段落间任何重复 ID。
func validArticle(article *Article) bool { func validArticle(article *Article) bool {
if article == nil || len(article.Sections) > 200 { if article == nil || len(article.Sections) > 200 {
return false return false
@@ -68,6 +81,8 @@ func validArticle(article *Article) bool {
} }
return true return true
} }
// validImage 校验 URL、替代文本及尺寸范围;拒绝用户名密码和 fragment,不执行资源可达性检查。
func validImage(image *Image) bool { func validImage(image *Image) bool {
if image == nil || len(image.URL) > 2048 || len(image.Alt) > 2000 || image.Width < 0 || image.Width > 100000 || image.Height < 0 || image.Height > 100000 { if image == nil || len(image.URL) > 2048 || len(image.Alt) > 2000 || image.Width < 0 || image.Width > 100000 || image.Height < 0 || image.Height > 100000 {
return false return false
@@ -75,6 +90,8 @@ func validImage(image *Image) bool {
u, err := url.Parse(image.URL) u, err := url.Parse(image.URL)
return err == nil && u.Scheme == "https" && u.Hostname() != "" && u.User == nil && u.Fragment == "" return err == nil && u.Scheme == "https" && u.Hostname() != "" && u.User == nil && u.Fragment == ""
} }
// validPart 按判别字段检查唯一有效分支,额外的异类内容即使本身合法也会被拒绝。
func validPart(part CardPart) bool { func validPart(part CardPart) bool {
switch part.Kind { switch part.Kind {
case "text": case "text":
@@ -87,6 +104,8 @@ func validPart(part CardPart) bool {
return false return false
} }
} }
// normalizeContent 严格解码单个对象,将缺省版本补为一,并重编码为统一存储形式。
func normalizeContent(kind string, raw json.RawMessage) (json.RawMessage, bool) { func normalizeContent(kind string, raw json.RawMessage) (json.RawMessage, bool) {
if raw = bytes.TrimSpace(raw); len(raw) == 0 || raw[0] != '{' { if raw = bytes.TrimSpace(raw); len(raw) == 0 || raw[0] != '{' {
return nil, false return nil, false
+2
View File
@@ -1,3 +1,4 @@
// 内容 schema 的纯函数回归,不访问数据库或远程图片。
package platform package platform
import ( import (
@@ -5,6 +6,7 @@ import (
"testing" "testing"
) )
// TestContentValidation 按素材种类检查合法草稿、重复块 ID、未知字段/版本、图片 URL 和互斥内容,并检查规范化输出仍为合法 JSON。
func TestContentValidation(t *testing.T) { func TestContentValidation(t *testing.T) {
cases := []struct { cases := []struct {
name, kind, body string name, kind, body string
+4
View File
@@ -1,7 +1,9 @@
// 素材显式授权由有效 admin 管理;授权写入与撤销都先取得相同的工作区/素材权限锁。
package platform package platform
import "net/http" import "net/http"
// materialGrants 返回最多一千条显式授权,或按账户 upsert editor/viewer;不允许授予素材 admin。
func (s *service) materialGrants(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) materialGrants(w http.ResponseWriter, r *http.Request, project, account string) error {
workspace, material := r.PathValue("workspace"), r.PathValue("material") workspace, material := r.PathValue("workspace"), r.PathValue("material")
if r.Method != http.MethodGet && r.Method != http.MethodPost { if r.Method != http.MethodGet && r.Method != http.MethodPost {
@@ -65,6 +67,8 @@ ON CONFLICT(project,workspace_id,material_id,account_id) DO UPDATE SET role=EXCL
reply(w, 204, nil) reply(w, 204, nil)
return nil return nil
} }
// deleteMaterialGrant 幂等撤销目标账户的素材授权;不存在也返回 204,工作区成员权限不受此操作影响。
func (s *service) deleteMaterialGrant(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) deleteMaterialGrant(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodDelete { if r.Method != http.MethodDelete {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
+37 -1
View File
@@ -1,3 +1,4 @@
// Package platform 提供项目隔离的工作区、素材、画布和协作 API;HTTP 认证与业务事务分层处理。
package platform package platform
import ( import (
@@ -17,6 +18,7 @@ import (
"github.com/jackc/pgx/v5/pgconn" "github.com/jackc/pgx/v5/pgconn"
) )
// service 共享连接池与启动配置;canvasAI 可缺省,队列仅在配置了客户端时启动。
type service struct { type service struct {
canvasAI *codex.CanvasClient canvasAI *codex.CanvasClient
db *sql.DB db *sql.DB
@@ -25,8 +27,10 @@ type service struct {
onboardingConfigs map[string]OnboardingConfig onboardingConfigs map[string]OnboardingConfig
} }
// response 用于小型 JSON 对象;大型画布文档通常保留 RawMessage 避免重编码字段。
type response map[string]any type response map[string]any
// reply 写出 JSON 与 no-store;value 为 nil 时只写状态,供 204 响应使用。
func reply(w http.ResponseWriter, status int, value any) { func reply(w http.ResponseWriter, status int, value any) {
w.Header().Set("Content-Type", "application/json") w.Header().Set("Content-Type", "application/json")
w.Header().Set("Cache-Control", "no-store") w.Header().Set("Cache-Control", "no-store")
@@ -36,10 +40,12 @@ func reply(w http.ResponseWriter, status int, value any) {
} }
} }
// reject 用稳定错误码表示可预期业务拒绝;调用者随后返回 nil,避免 protected 重复响应。
func reject(w http.ResponseWriter, status int, code string) { func reject(w http.ResponseWriter, status int, code string) {
reply(w, status, response{"error": code}) reply(w, status, response{"error": code})
} }
// decode 对普通业务 JSON 限制 1 MiB,拒绝未知字段以及第二个 JSON 值;失败已经写出 400。
func decode(w http.ResponseWriter, r *http.Request, value any) bool { func decode(w http.ResponseWriter, r *http.Request, value any) bool {
decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)) decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20))
decoder.DisallowUnknownFields() decoder.DisallowUnknownFields()
@@ -54,8 +60,10 @@ func decode(w http.ResponseWriter, r *http.Request, value any) bool {
return true return true
} }
// endpoint 接收已认证的 project/account;具体资源可见性仍由业务处理器在事务内校验。
type endpoint func(http.ResponseWriter, *http.Request, string, string) error type endpoint func(http.ResponseWriter, *http.Request, string, string) error
// protected 是统一路由包装:项目白名单/CORS、会话续期、资源别名解析、canonical 写入守卫和错误映射。
func (s *service) protected(callbacks map[string]string, handle endpoint) http.HandlerFunc { func (s *service) protected(callbacks map[string]string, handle endpoint) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) { return func(w http.ResponseWriter, r *http.Request) {
project := r.PathValue("project") project := r.PathValue("project")
@@ -74,9 +82,10 @@ func (s *service) protected(callbacks map[string]string, handle endpoint) http.H
w.Header().Set("Access-Control-Allow-Origin", origin) w.Header().Set("Access-Control-Allow-Origin", origin)
w.Header().Set("Access-Control-Expose-Headers", "ETag, X-Canvas-Schema-Version, "+auth.SessionExpiryHeader) w.Header().Set("Access-Control-Expose-Headers", "ETag, X-Canvas-Schema-Version, "+auth.SessionExpiryHeader)
} }
// 预检只验证项目和 Origin,不要求 bearer;真正业务请求仍必须通过会话认证。
if r.Method == http.MethodOptions { if r.Method == http.MethodOptions {
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PATCH, DELETE, OPTIONS") w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PATCH, DELETE, OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type, If-Match, Idempotency-Key") w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type, If-Match, Idempotency-Key, X-Expected-Account, X-Resource-Id")
reply(w, 204, nil) reply(w, 204, nil)
return return
} }
@@ -88,7 +97,13 @@ func (s *service) protected(callbacks map[string]string, handle endpoint) http.H
account := session.AccountID account := session.AccountID
if err == nil { if err == nil {
auth.WriteSessionHeaders(w, session) auth.WriteSessionHeaders(w, session)
// 客户端可携带预期账户,阻止浏览器切换身份后把旧页面的写入落到新账户。
if expected := r.Header.Get("X-Expected-Account"); expected != "" && expected != account {
reject(w, 409, "identity_changed")
return
}
} }
// 将 slug 或 UUID 统一为 UUID 后再分派,后续 SQL 无需兼容两种引用;这一步不替代资源授权。
if err == nil && r.PathValue("workspace") != "" { if err == nil && r.PathValue("workspace") != "" {
var id string var id string
err = s.db.QueryRowContext(r.Context(), "SELECT id::text FROM workspaces WHERE project=$1 AND (id::text=$2 OR slug=$2)", project, r.PathValue("workspace")).Scan(&id) err = s.db.QueryRowContext(r.Context(), "SELECT id::text FROM workspaces WHERE project=$1 AND (id::text=$2 OR slug=$2)", project, r.PathValue("workspace")).Scan(&id)
@@ -103,12 +118,22 @@ func (s *service) protected(callbacks map[string]string, handle endpoint) http.H
r.SetPathValue("material", id) r.SetPathValue("material", id)
} }
} }
if err == nil {
var stopped bool
stopped, err = s.guardLegacyCanonicalRequest(w, r, project, account)
if stopped {
return
}
}
if err == nil { if err == nil {
err = handle(w, r, project, account) err = handle(w, r, project, account)
} }
// 只公开可识别的约束/领域错误;其余依赖错误记录类型并统一返回 503。
if err != nil { if err != nil {
var pg *pgconn.PgError var pg *pgconn.PgError
switch { switch {
case errors.As(err, &pg) && pg.Code == "55000" && pg.Message == "canonical_write_required":
reject(w, 409, "canonical_write_required")
case errors.Is(err, errSubgraphCycle): case errors.Is(err, errSubgraphCycle):
reject(w, 409, "subgraph_cycle") reject(w, 409, "subgraph_cycle")
case errors.Is(err, errSubgraphDepth): case errors.Is(err, errSubgraphDepth):
@@ -127,6 +152,7 @@ func (s *service) protected(callbacks map[string]string, handle endpoint) http.H
} }
} }
// Register 由 main 装配平台路径;私有 AI 客户端存在时启动进程级队列,公开短链接单独处理。
func Register(mux *http.ServeMux, db *sql.DB, callbacks map[string]string, origin string, configs map[string]OnboardingConfig, clients ...*codex.CanvasClient) { func Register(mux *http.ServeMux, db *sql.DB, callbacks map[string]string, origin string, configs map[string]OnboardingConfig, clients ...*codex.CanvasClient) {
s := &service{db: db, origin: origin, callbacks: callbacks, onboardingConfigs: configs} s := &service{db: db, origin: origin, callbacks: callbacks, onboardingConfigs: configs}
if len(clients) > 0 { if len(clients) > 0 {
@@ -137,16 +163,25 @@ func Register(mux *http.ServeMux, db *sql.DB, callbacks map[string]string, origi
} }
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials", s.protected(callbacks, s.materials)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials", s.protected(callbacks, s.materials))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/assets", s.protected(callbacks, s.uploadAsset)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/assets", s.protected(callbacks, s.uploadAsset))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/assets/operations/{request}", s.protected(callbacks, s.assetOperation))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/assets/metadata/{asset}", s.protected(callbacks, s.getAssetMetadata))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/assets/{asset}", s.protected(callbacks, s.getAsset)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/assets/{asset}", s.protected(callbacks, s.getAsset))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}", s.protected(callbacks, s.material)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}", s.protected(callbacks, s.material))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas", s.protected(callbacks, s.canvas)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas", s.protected(callbacks, s.canvas))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai/models", s.protected(callbacks, s.canvasAIModels)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai/models", s.protected(callbacks, s.canvasAIModels))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai/operations/{request}", s.protected(callbacks, s.getCanvasAIAdmission))
mux.HandleFunc("POST /projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai/runs", s.protected(callbacks, s.createCanvasAIRun)) mux.HandleFunc("POST /projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai/runs", s.protected(callbacks, s.createCanvasAIRun))
mux.HandleFunc("GET /projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai/runs", s.protected(callbacks, s.listCanvasAIRuns)) mux.HandleFunc("GET /projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai/runs", s.protected(callbacks, s.listCanvasAIRuns))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai/runs/{run}", s.protected(callbacks, s.getCanvasAIRun)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai/runs/{run}", s.protected(callbacks, s.getCanvasAIRun))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai/runs/{run}/cancel", s.protected(callbacks, s.cancelCanvasAIRun)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai/runs/{run}/cancel", s.protected(callbacks, s.cancelCanvasAIRun))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai/runs/{run}/apply", s.protected(callbacks, s.applyCanvasAIOutput)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/ai/runs/{run}/apply", s.protected(callbacks, s.applyCanvasAIOutput))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/capabilities", s.protected(callbacks, s.canvasCapabilities)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/capabilities", s.protected(callbacks, s.canvasCapabilities))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/operations", s.protected(callbacks, s.submitCanvasOperations))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/operations/{request}", s.protected(callbacks, s.getCanvasOperation))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/model", s.protected(callbacks, s.getCanvasModel))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/model/migrate", s.protected(callbacks, s.migrateCanonicalCanvas))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/model/operations", s.protected(callbacks, s.submitCanvasModelOperations))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/model/operations/{request}", s.protected(callbacks, s.getCanvasModelOperation))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/connections", s.protected(callbacks, s.createCanvasConnection)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/connections", s.protected(callbacks, s.createCanvasConnection))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/subgraphs", s.protected(callbacks, s.createSubgraph)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/subgraphs", s.protected(callbacks, s.createSubgraph))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/subgraphs/migrate", s.protected(callbacks, s.migrateSubgraphs)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/materials/{material}/canvas/subgraphs/migrate", s.protected(callbacks, s.migrateSubgraphs))
@@ -176,6 +211,7 @@ func Register(mux *http.ServeMux, db *sql.DB, callbacks map[string]string, origi
var usernamePattern = regexp.MustCompile(`^[a-z0-9][a-z0-9_-]{2,39}$`) var usernamePattern = regexp.MustCompile(`^[a-z0-9][a-z0-9_-]{2,39}$`)
// profile 只操作当前项目的本人账户;PATCH 规范化用户名后与 GET 共用完整资料响应。
func (s *service) profile(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) profile(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method == http.MethodPatch { if r.Method == http.MethodPatch {
var input struct { var input struct {
+150 -3
View File
@@ -1,3 +1,5 @@
// 平台综合数据库回归:需要 PLATFORM_TEST_DATABASE_URL 指向已迁移的隔离测试库,缺省会跳过。
// 使用随机项目和真实 HTTP handler 覆盖权限、版本、子图事务与资源生命周期,不连接真实 OAuth 或邮件服务。
package platform package platform
import ( import (
@@ -27,6 +29,8 @@ import (
_ "github.com/jackc/pgx/v5/stdlib" _ "github.com/jackc/pgx/v5/stdlib"
) )
// TestOnboardingAndSharing 是跨模块流程测试,后续画布/资产/邮箱检查复用最初创建的三个账户。
// tokens[0] 为所有者,tokens[1] 经邀请成为 viewer,tokens[2] 只按阶段授予局部素材权限。
func TestOnboardingAndSharing(t *testing.T) { func TestOnboardingAndSharing(t *testing.T) {
dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL") dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL")
if dsn == "" { if dsn == "" {
@@ -60,6 +64,7 @@ func TestOnboardingAndSharing(t *testing.T) {
} }
tokens = append(tokens, token) tokens = append(tokens, token)
} }
// 按引用关系先删除资产绑定、事务和子图,再删除工作区/账户,避免回归数据残留。
defer func() { defer func() {
_, _ = db.ExecContext(ctx, "DELETE FROM canvas_asset_bindings WHERE project=$1", project) _, _ = db.ExecContext(ctx, "DELETE FROM canvas_asset_bindings WHERE project=$1", project)
_, _ = db.ExecContext(ctx, "DELETE FROM canvas_assets WHERE project=$1", project) _, _ = db.ExecContext(ctx, "DELETE FROM canvas_assets WHERE project=$1", project)
@@ -79,6 +84,7 @@ func TestOnboardingAndSharing(t *testing.T) {
Register(mux, db, callbacks, "https://api.example.com", map[string]OnboardingConfig{ Register(mux, db, callbacks, "https://api.example.com", map[string]OnboardingConfig{
project: {RequireWorkspace: true, Questions: []Question{{Key: "purpose", Required: true}}}, project: {RequireWorkspace: true, Questions: []Question{{Key: "purpose", Required: true}}},
}) })
// call 在内存 recorder 上走真实路由;可选参数依次代表 If-Match、Accept 和幂等键。
call := func(method, path, token string, body any, status int, versions ...string) response { call := func(method, path, token string, body any, status int, versions ...string) response {
t.Helper() t.Helper()
encoded, err := json.Marshal(body) encoded, err := json.Marshal(body)
@@ -111,6 +117,7 @@ func TestOnboardingAndSharing(t *testing.T) {
} }
return out return out
} }
// 首段验证引导重试不重复建工作区,以及分享次数、重复兑换、owner 不可降级和撤销效果。
base := "/projects/" + project base := "/projects/" + project
call("GET", base+"/workspaces", "", nil, 401) call("GET", base+"/workspaces", "", nil, 401)
call("POST", base+"/onboarding", tokens[0], response{"answers": response{}}, 400) call("POST", base+"/onboarding", tokens[0], response{"answers": response{}}, 400)
@@ -145,6 +152,7 @@ func TestOnboardingAndSharing(t *testing.T) {
contentShare := call("POST", workspacePath+"/shares", tokens[0], response{"role": "editor", "material_id": material}, 201) contentShare := call("POST", workspacePath+"/shares", tokens[0], response{"role": "editor", "material_id": material}, 201)
call("POST", base+"/shares/redeem", tokens[2], response{"token": contentShare["token"]}, 200) call("POST", base+"/shares/redeem", tokens[2], response{"token": contentShare["token"]}, 200)
call("GET", workspacePath, tokens[2], nil, 404) call("GET", workspacePath, tokens[2], nil, 404)
// 素材局部授权不授予工作区可见性;随后验证 viewer/editor 区别与 If-Match 防止旧版本覆盖。
articleContent := response{"schema_version": 1, "article": response{"sections": []any{response{ articleContent := response{"schema_version": 1, "article": response{"sections": []any{response{
"id": "chapter-1", "title": "Chapter", "description": "Chapter summary", "paragraphs": []any{response{"id": "p1", "text": "Paragraph", "description": "Paragraph summary"}}, "id": "chapter-1", "title": "Chapter", "description": "Chapter summary", "paragraphs": []any{response{"id": "p1", "text": "Paragraph", "description": "Paragraph summary"}},
}}}} }}}}
@@ -173,6 +181,7 @@ func TestOnboardingAndSharing(t *testing.T) {
board := call("POST", workspacePath+"/materials", tokens[0], response{"kind": "board", "title": "Board", "content": response{}}, 201) board := call("POST", workspacePath+"/materials", tokens[0], response{"kind": "board", "title": "Board", "content": response{}}, 201)
boardPath := workspacePath + "/materials/" + board["id"].(string) boardPath := workspacePath + "/materials/" + board["id"].(string)
// 画布快照版本与素材元数据版本相互独立,保存/改名各自只推进对应版本。
canvasPath := boardPath + "/canvas" canvasPath := boardPath + "/canvas"
empty := call("GET", canvasPath, tokens[0], nil, 200) empty := call("GET", canvasPath, tokens[0], nil, 200)
if empty["version"] != float64(1) { if empty["version"] != float64(1) {
@@ -221,6 +230,7 @@ func TestOnboardingAndSharing(t *testing.T) {
// Restore the material version expected by the pre-existing layout checks below. // Restore the material version expected by the pre-existing layout checks below.
// Exercise two independent HTTP transactions against the same expected version. // Exercise two independent HTTP transactions against the same expected version.
// 同一旧版本的两个并发保存必须一成一败,不能都成功或出现部分持久化。
encodedSnapshot, _ := json.Marshal(snapshot) encodedSnapshot, _ := json.Marshal(snapshot)
statuses := make(chan int, 2) statuses := make(chan int, 2)
start := make(chan struct{}) start := make(chan struct{})
@@ -253,6 +263,7 @@ func TestOnboardingAndSharing(t *testing.T) {
} }
// Frames round-trip through PostgreSQL with all label modes and explicit memberships. // Frames round-trip through PostgreSQL with all label modes and explicit memberships.
// 三种框标签模式逐次落库并回读;失效成员引用必须拒绝且不推进版本。
for index, mode := range []string{"hidden", "fixed", "scaled"} { for index, mode := range []string{"hidden", "fixed", "scaled"} {
version := strconv.Itoa(4 + index) version := strconv.Itoa(4 + index)
raw := strings.Replace(frameFixture, `"labelMode":"fixed"`, `"labelMode":"`+mode+`"`, 1) raw := strings.Replace(frameFixture, `"labelMode":"fixed"`, `"labelMode":"`+mode+`"`, 1)
@@ -304,6 +315,7 @@ func TestOnboardingAndSharing(t *testing.T) {
// Subgraph creation is atomic and idempotent, and cannot be undone by // Subgraph creation is atomic and idempotent, and cannot be undone by
// a stale or legacy whole-document save. // a stale or legacy whole-document save.
// 子图创建将文档、子素材、关系和事务回执原子保存;同键重放只返回原结果,不再递增版本。
subBoard := call("POST", workspacePath+"/materials", tokens[0], response{"kind": "board", "title": "Subgraphs", "content": response{}}, 201) subBoard := call("POST", workspacePath+"/materials", tokens[0], response{"kind": "board", "title": "Subgraphs", "content": response{}}, 201)
subPath := workspacePath + "/materials/" + subBoard["id"].(string) + "/canvas" subPath := workspacePath + "/materials/" + subBoard["id"].(string) + "/canvas"
accept := "application/vnd.foundry.canvas+json;version=2" accept := "application/vnd.foundry.canvas+json;version=2"
@@ -367,6 +379,7 @@ func TestOnboardingAndSharing(t *testing.T) {
call("POST", dissolveUndoPath, tokens[0], response{"expected_versions": map[string]int64{subBoard["id"].(string): 3, childID: 2}}, 200, "", accept, "88888888-8888-4888-8888-888888888888") call("POST", dissolveUndoPath, tokens[0], response{"expected_versions": map[string]int64{subBoard["id"].(string): 3, childID: 2}}, 200, "", accept, "88888888-8888-4888-8888-888888888888")
call("GET", childPath, tokens[0], nil, 200, "", accept) call("GET", childPath, tokens[0], nil, 200, "", accept)
// 旧框迁移先 dry-run 生成计划,陈旧计划不得留下孤儿素材;执行与撤销都验证幂等回执。
migrationBoard := call("POST", workspacePath+"/materials", tokens[0], response{"kind": "board", "title": "Legacy migration", "content": response{}}, 201) migrationBoard := call("POST", workspacePath+"/materials", tokens[0], response{"kind": "board", "title": "Legacy migration", "content": response{}}, 201)
migrationPath := workspacePath + "/materials/" + migrationBoard["id"].(string) + "/canvas" migrationPath := workspacePath + "/materials/" + migrationBoard["id"].(string) + "/canvas"
call("PATCH", migrationPath, tokens[0], response{"document": json.RawMessage(legacyMigrationFixture)}, 200, `"1"`) call("PATCH", migrationPath, tokens[0], response{"document": json.RawMessage(legacyMigrationFixture)}, 200, `"1"`)
@@ -423,7 +436,9 @@ func TestOnboardingAndSharing(t *testing.T) {
} }
parentID := migrationBoard["id"].(string) parentID := migrationBoard["id"].(string)
memberPath := migrationPath + "/subgraphs/f/members" memberPath := migrationPath + "/subgraphs/f/members"
moveCommand := response{"source_board_id": membersSource, "target_board_id": membersTarget, "node_ids": []string{"a"}, "expected_versions": map[string]int64{parentID: 5, membersSource: 1, membersTarget: 1}} // 多画布移动携带完整预期版本及来源局部坐标,要求节点所有权、几何位置和撤销一起生效。
moveCommand := response{"source_board_id": membersSource, "target_board_id": membersTarget, "node_ids": []string{"a"}, "positions": map[string]memberDropPosition{"a": {X: 40, Y: 50}}, "expected_versions": map[string]int64{parentID: 5, membersSource: 1, membersTarget: 1}}
call("POST", memberPath, tokens[0], response{"source_board_id": membersSource, "target_board_id": membersTarget, "node_ids": []string{"a"}, "positions": response{"wrong": response{"x": 1, "y": 2}}, "expected_versions": map[string]int64{parentID: 5, membersSource: 1, membersTarget: 1}}, 400, "", accept, "eeeeeeee-1111-4111-8111-111111111111")
movedMembers := call("POST", memberPath, tokens[0], moveCommand, 200, "", accept, "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb") movedMembers := call("POST", memberPath, tokens[0], moveCommand, 200, "", accept, "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb")
memberRetry := call("POST", memberPath, tokens[0], moveCommand, 200, "", accept, "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb") memberRetry := call("POST", memberPath, tokens[0], moveCommand, 200, "", accept, "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb")
if movedMembers["transaction_id"] != memberRetry["transaction_id"] { if movedMembers["transaction_id"] != memberRetry["transaction_id"] {
@@ -435,6 +450,10 @@ func TestOnboardingAndSharing(t *testing.T) {
targetRead := call("GET", targetCanvasPath, tokens[0], nil, 200, "", accept) targetRead := call("GET", targetCanvasPath, tokens[0], nil, 200, "", accept)
sourceJSON, _ := json.Marshal(sourceRead["document"]) sourceJSON, _ := json.Marshal(sourceRead["document"])
targetJSON, _ := json.Marshal(targetRead["document"]) targetJSON, _ := json.Marshal(targetRead["document"])
dropPosition := canvasNodesByID(targetJSON)["a"]["position"].(map[string]any)
if dropPosition["x"] != float64(140) || dropPosition["y"] != float64(250) {
t.Fatalf("atomic drop geometry %v", dropPosition)
}
if canvasNodeData(sourceJSON)["a"] != nil || canvasNodeData(targetJSON)["a"] == nil { if canvasNodeData(sourceJSON)["a"] != nil || canvasNodeData(targetJSON)["a"] == nil {
t.Fatal("member move duplicated or lost ownership") t.Fatal("member move duplicated or lost ownership")
} }
@@ -443,6 +462,7 @@ func TestOnboardingAndSharing(t *testing.T) {
parentMove := call("POST", memberPath, tokens[0], response{"source_board_id": parentID, "target_board_id": membersSource, "node_ids": []string{"outside"}, "expected_versions": map[string]int64{parentID: 7, membersSource: 3}}, 200, "", accept, "eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee") parentMove := call("POST", memberPath, tokens[0], response{"source_board_id": parentID, "target_board_id": membersSource, "node_ids": []string{"outside"}, "expected_versions": map[string]int64{parentID: 7, membersSource: 3}}, 200, "", accept, "eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee")
call("POST", migrationPath+"/transactions/"+parentMove["transaction_id"].(string)+"/undo", tokens[0], response{"expected_versions": map[string]int64{parentID: 8, membersSource: 4}}, 200, "", accept, "ffffffff-ffff-4fff-8fff-ffffffffffff") call("POST", migrationPath+"/transactions/"+parentMove["transaction_id"].(string)+"/undo", tokens[0], response{"expected_versions": map[string]int64{parentID: 8, membersSource: 4}}, 200, "", accept, "ffffffff-ffff-4fff-8fff-ffffffffffff")
innerCreated := call("POST", sourceCanvasPath+"/subgraphs", tokens[0], response{"frame": response{"id": "inner-frame", "title": "Inner", "position": response{"x": 20, "y": 40}, "width": 400, "height": 300, "labelMode": "fixed"}}, 201, `"5"`, accept, "10000000-0000-4000-8000-000000000001") innerCreated := call("POST", sourceCanvasPath+"/subgraphs", tokens[0], response{"frame": response{"id": "inner-frame", "title": "Inner", "position": response{"x": 20, "y": 40}, "width": 400, "height": 300, "labelMode": "fixed"}}, 201, `"5"`, accept, "10000000-0000-4000-8000-000000000001")
// 移动包含子图的框必须重挂原子图关系,而非复制孩子;撤销要恢复原父级。
innerID := innerCreated["child_board"].(map[string]any)["id"].(string) innerID := innerCreated["child_board"].(map[string]any)["id"].(string)
nestedMove := call("POST", memberPath, tokens[0], response{"source_board_id": membersSource, "target_board_id": membersTarget, "node_ids": []string{"inner-frame"}, "expected_versions": map[string]int64{parentID: 9, membersSource: 6, membersTarget: 3, innerID: 1}}, 200, "", accept, "10000000-0000-4000-8000-000000000002") nestedMove := call("POST", memberPath, tokens[0], response{"source_board_id": membersSource, "target_board_id": membersTarget, "node_ids": []string{"inner-frame"}, "expected_versions": map[string]int64{parentID: 9, membersSource: 6, membersTarget: 3, innerID: 1}}, 200, "", accept, "10000000-0000-4000-8000-000000000002")
var nestedParent string var nestedParent string
@@ -456,6 +476,7 @@ func TestOnboardingAndSharing(t *testing.T) {
// Moving an externally exposed node inside a nested frame must repair the // Moving an externally exposed node inside a nested frame must repair the
// ancestor boundary atomically and preserve its port/edge identities. // ancestor boundary atomically and preserve its port/edge identities.
// 嵌套移动和解散需同时修复祖先端口,保留逻辑端点身份;漏报祖先版本应返回 428。
innerMemberPath := sourceCanvasPath + "/subgraphs/inner-frame/members" innerMemberPath := sourceCanvasPath + "/subgraphs/inner-frame/members"
nestedMemberCommand := response{"source_board_id": membersSource, "target_board_id": innerID, "node_ids": []string{"b"}, "expected_versions": map[string]int64{parentID: 11, membersSource: 8, innerID: 3}} nestedMemberCommand := response{"source_board_id": membersSource, "target_board_id": innerID, "node_ids": []string{"b"}, "expected_versions": map[string]int64{parentID: 11, membersSource: 8, innerID: 3}}
nestedMemberMove := call("POST", innerMemberPath, tokens[0], nestedMemberCommand, 200, "", accept, "30000000-0000-4000-8000-000000000001") nestedMemberMove := call("POST", innerMemberPath, tokens[0], nestedMemberCommand, 200, "", accept, "30000000-0000-4000-8000-000000000001")
@@ -490,7 +511,8 @@ func TestOnboardingAndSharing(t *testing.T) {
if err := png.Encode(&assetPNG, image.NewRGBA(image.Rect(0, 0, 3, 2))); err != nil { if err := png.Encode(&assetPNG, image.NewRGBA(image.Rect(0, 0, 3, 2))); err != nil {
t.Fatal(err) t.Fatal(err)
} }
upload := func(encoded []byte, key string, status int) response { // 上传使用故意错误的文件扩展名验证真实 MIME 嗅探,并可指定客户端预分配资源 ID。
upload := func(encoded []byte, key string, status int, resourceIDs ...string) response {
t.Helper() t.Helper()
var body bytes.Buffer var body bytes.Buffer
writer := multipart.NewWriter(&body) writer := multipart.NewWriter(&body)
@@ -504,6 +526,9 @@ func TestOnboardingAndSharing(t *testing.T) {
request.Header.Set("Authorization", "Bearer "+tokens[0]) request.Header.Set("Authorization", "Bearer "+tokens[0])
request.Header.Set("Content-Type", writer.FormDataContentType()) request.Header.Set("Content-Type", writer.FormDataContentType())
request.Header.Set("Idempotency-Key", key) request.Header.Set("Idempotency-Key", key)
if len(resourceIDs) > 0 {
request.Header.Set("X-Resource-Id", resourceIDs[0])
}
result := httptest.NewRecorder() result := httptest.NewRecorder()
mux.ServeHTTP(result, request) mux.ServeHTTP(result, request)
if result.Code != status { if result.Code != status {
@@ -520,6 +545,34 @@ func TestOnboardingAndSharing(t *testing.T) {
if uploaded["id"] != retriedAsset["id"] || uploaded["mime_type"] != "image/png" { if uploaded["id"] != retriedAsset["id"] || uploaded["mime_type"] != "image/png" {
t.Fatal("asset idempotency or actual MIME detection") t.Fatal("asset idempotency or actual MIME detection")
} }
// New uploads keep the resource identity allocated in the frontend durable cut.
resourceID, resourceKey := modelTestID(9100), modelTestID(9101)
managed := upload(assetPNG.Bytes(), resourceKey, 201, resourceID)
if managed["protocol_version"] != float64(2) || managed["request_id"] != resourceKey || managed["asset"].(map[string]any)["id"] != resourceID {
t.Fatal("upload did not retain client resource identity")
}
repeated := upload(assetPNG.Bytes(), resourceKey, 201, resourceID)
if !modelEqual(managed, repeated) {
t.Fatal("resource retry changed receipt")
}
// 模拟响应丢失后查询回执:已应用可恢复原资产,未知请求不能被误报为已确定零写入。
lookup := call("GET", workspacePath+"/assets/operations/"+resourceKey, tokens[0], nil, 200)
if lookup["status"] != "applied" || !modelEqual(lookup["asset"], managed["asset"]) {
t.Fatal("lost upload acknowledgment cannot be recovered")
}
unknown := call("GET", workspacePath+"/assets/operations/"+modelTestID(9102), tokens[0], nil, 404)
if unknown["status"] != "unknown" || unknown["terminal"] == true {
t.Fatal("missing asset receipt misreported zero-write")
}
call("GET", workspacePath+"/assets/operations/"+resourceKey, tokens[2], nil, 404)
upload(assetPNG.Bytes(), resourceKey, 409, modelTestID(9103))
upload(assetPNG.Bytes(), modelTestID(9104), 409, resourceID)
var alternatePNG bytes.Buffer
if err := png.Encode(&alternatePNG, image.NewRGBA(image.Rect(0, 0, 4, 4))); err != nil {
t.Fatal(err)
}
upload(alternatePNG.Bytes(), resourceKey, 409, resourceID)
upload(assetPNG.Bytes(), modelTestID(9105), 400, "invalid-resource")
download := func(token string, status int) { download := func(token string, status int) {
t.Helper() t.Helper()
request := httptest.NewRequest("GET", workspacePath+"/assets/"+uploaded["id"].(string), nil) request := httptest.NewRequest("GET", workspacePath+"/assets/"+uploaded["id"].(string), nil)
@@ -549,9 +602,37 @@ func TestOnboardingAndSharing(t *testing.T) {
t.Fatal("preview changed small original or privacy headers") t.Fatal("preview changed small original or privacy headers")
} }
} }
// Metadata discloses the same immutable identity only after a fresh read permission check.
metadataPath := workspacePath + "/assets/metadata/" + uploaded["id"].(string)
for _, sample := range []struct {
token string
status int
}{{tokens[0], 200}, {tokens[1], 404}, {tokens[2], 404}} {
request := httptest.NewRequest("GET", metadataPath, nil)
request.Header.Set("Authorization", "Bearer "+sample.token)
result := httptest.NewRecorder()
mux.ServeHTTP(result, request)
if result.Code != sample.status {
t.Fatalf("metadata permission got %d want %d: %s", result.Code, sample.status, result.Body.String())
}
if result.Code == 200 {
var metadata response
if err := json.Unmarshal(result.Body.Bytes(), &metadata); err != nil {
t.Fatal(err)
}
digest := sha256.Sum256(assetPNG.Bytes())
if metadata["metadata_version"] != float64(1) || metadata["sha256"] != hex.EncodeToString(digest[:]) || !modelEqual(metadata["asset"], uploaded) {
t.Fatalf("invalid metadata identity: %s", result.Body.String())
}
if result.Header().Get("Cache-Control") != "private, no-store" {
t.Fatalf("invalid metadata privacy header: %q", result.Header().Get("Cache-Control"))
}
}
}
// Neither a snapshot nor an asset response may keep the workspace locked // Neither a snapshot nor an asset response may keep the workspace locked
// while a slow downstream consumer is accepting its body. // while a slow downstream consumer is accepting its body.
for _, path := range []string{canvasPath, workspacePath + "/assets/" + uploaded["id"].(string)} { // 在真正写出响应体时另开事务 NOWAIT 抢工作区锁,防止慢消费者拖长数据库锁生命周期。
for _, path := range []string{canvasPath, workspacePath + "/assets/" + uploaded["id"].(string), metadataPath} {
var probeErr error var probeErr error
writer := &readLockProbe{ResponseRecorder: httptest.NewRecorder(), probe: func() { writer := &readLockProbe{ResponseRecorder: httptest.NewRecorder(), probe: func() {
lockTx, e := db.BeginTx(ctx, nil) lockTx, e := db.BeginTx(ctx, nil)
@@ -572,6 +653,7 @@ func TestOnboardingAndSharing(t *testing.T) {
} }
// A slow multipart body must not hold the workspace lock either. // A slow multipart body must not hold the workspace lock either.
func() { func() {
// 管道先交付 multipart 头再暂停正文,探测接收慢上传期间是否错误持有工作区锁。
reader, pipe := io.Pipe() reader, pipe := io.Pipe()
defer reader.Close() defer reader.Close()
defer pipe.Close() defer pipe.Close()
@@ -626,6 +708,7 @@ func TestOnboardingAndSharing(t *testing.T) {
download(tokens[0], 200) download(tokens[0], 200)
download(tokens[1], 404) download(tokens[1], 404)
download(tokens[2], 404) download(tokens[2], 404)
// 资产由上传者可读,写入可访问画布并绑定后才允许该画布协作者读取。
assetBoard := call("POST", workspacePath+"/materials", tokens[0], response{"kind": "board", "title": "Assets", "content": response{}}, 201) assetBoard := call("POST", workspacePath+"/materials", tokens[0], response{"kind": "board", "title": "Assets", "content": response{}}, 201)
assetDoc := response{"schema_version": 2, "nodes": []any{response{"id": "asset-node", "type": "plainImage", "position": response{"x": 0, "y": 0}, "data": response{"kind": "plain-image", "title": "Image", "text": "", "src": uploaded["url"], "assetId": uploaded["id"]}}}, "edges": []any{}, "viewport": response{"x": 0, "y": 0, "zoom": 1}} assetDoc := response{"schema_version": 2, "nodes": []any{response{"id": "asset-node", "type": "plainImage", "position": response{"x": 0, "y": 0}, "data": response{"kind": "plain-image", "title": "Image", "text": "", "src": uploaded["url"], "assetId": uploaded["id"]}}}, "edges": []any{}, "viewport": response{"x": 0, "y": 0, "zoom": 1}}
call("PATCH", workspacePath+"/materials/"+assetBoard["id"].(string)+"/canvas", tokens[0], response{"document": assetDoc}, 200, `"1"`, accept) call("PATCH", workspacePath+"/materials/"+assetBoard["id"].(string)+"/canvas", tokens[0], response{"document": assetDoc}, 200, `"1"`, accept)
@@ -644,9 +727,68 @@ func TestOnboardingAndSharing(t *testing.T) {
t.Fatalf("stable URL lost child asset binding: %v count=%d", err, managedBindings) t.Fatalf("stable URL lost child asset binding: %v count=%d", err, managedBindings)
} }
call("POST", assetCanvasPath+"/subgraphs/asset-frame/dissolve", tokens[0], response{"expected_versions": map[string]int64{assetBoard["id"].(string): 5, assetChild: 2}}, 200, "", accept, "40000000-0000-4000-8000-000000000003") call("POST", assetCanvasPath+"/subgraphs/asset-frame/dissolve", tokens[0], response{"expected_versions": map[string]int64{assetBoard["id"].(string): 5, assetChild: 2}}, 200, "", accept, "40000000-0000-4000-8000-000000000003")
// A warm metadata/original cache is not a future permission grant. An external
// collaborator can read through a source board grant, but a new canonical
// target write must recheck asset readability after that grant is revoked.
// 先暖元数据/原图缓存再撤销来源权限,确保新目标写入实时检查授权而非信任缓存命中。
sourceGrantPath := workspacePath + "/materials/" + assetBoard["id"].(string) + "/grants"
call("POST", sourceGrantPath, tokens[0], response{"account_id": accounts[2], "role": "viewer"}, 204)
call("GET", metadataPath, tokens[2], nil, 200)
download(tokens[2], 200)
targetBoard := call("POST", workspacePath+"/materials", tokens[0], response{"kind": "board", "title": "Asset adoption target", "content": response{}}, 201)
targetID := targetBoard["id"].(string)
targetPath := workspacePath + "/materials/" + targetID
targetGrantPath := targetPath + "/grants"
call("POST", targetGrantPath, tokens[0], response{"account_id": accounts[2], "role": "editor"}, 204)
migrationID := modelTestID(9200)
call("POST", targetPath+"/canvas/model/migrate", tokens[0], response{"protocol_version": 2, "request_id": migrationID, "expected_versions": map[string]int64{targetID: 1}}, 200, "", accept, migrationID)
targetModel := call("GET", targetPath+"/canvas/model", tokens[2], nil, 200)["model"].(map[string]any)
targetVersion := int64(targetModel["versions"].(map[string]any)[targetID].(float64))
adoptedElement := modelTestNode(modelTestID(9201), targetID)
adoptedElement["componentId"] = "image"
adoptedElement["data"] = map[string]any{"title": "Adopted", "text": "", "assetId": uploaded["id"], "src": uploaded["url"]}
adoptionRequest := func(requestID, operationID string) modelBatch {
return modelBatch{ProtocolVersion: 2, RequestID: requestID, Expected: map[string]int64{targetID: targetVersion}, Operations: []modelOperation{{ID: operationID, Changes: []modelChange{{Kind: "element", ID: modelString(adoptedElement["id"]), Before: modelJSON(nil), After: modelJSON(adoptedElement)}}}}}
}
call("DELETE", sourceGrantPath+"/"+accounts[2], tokens[0], nil, 204)
call("GET", metadataPath, tokens[2], nil, 404)
download(tokens[2], 404)
deniedID := modelTestID(9202)
deniedBody := adoptionRequest(deniedID, modelTestID(9203))
denied := call("POST", targetPath+"/canvas/model/operations", tokens[2], deniedBody, 400, "", accept, deniedID)
if denied["status"] != "not-applied" || denied["terminal"] != true || denied["error"] != "invalid_asset_reference" {
t.Fatalf("revoked source did not yield a definitive no-write receipt: %v", denied)
}
unchanged := call("GET", targetPath+"/canvas/model", tokens[2], nil, 200)["model"].(map[string]any)
if !modelEqual(unchanged, targetModel) {
t.Fatal("revoked-source adoption changed target model or versions")
}
var targetBindings int
if err := db.QueryRowContext(ctx, "SELECT count(*) FROM canvas_asset_bindings WHERE project=$1 AND asset_id=$2 AND board_id=$3", project, uploaded["id"], targetID).Scan(&targetBindings); err != nil || targetBindings != 0 {
t.Fatalf("rejected adoption left a target binding: %d %v", targetBindings, err)
}
// Restoring source access does not change the frozen rejected request's result.
call("POST", sourceGrantPath, tokens[0], response{"account_id": accounts[2], "role": "viewer"}, 204)
call("GET", metadataPath, tokens[2], nil, 200)
replayedDenial := call("POST", targetPath+"/canvas/model/operations", tokens[2], deniedBody, 400, "", accept, deniedID)
if !modelEqual(denied, replayedDenial) {
t.Fatal("permission restoration changed a terminal receipt")
}
// 恢复权限后必须新建请求才可成功;目标获得独立绑定后,撤销来源不应破坏目标读权限。
acceptedID := modelTestID(9204)
call("POST", targetPath+"/canvas/model/operations", tokens[2], adoptionRequest(acceptedID, modelTestID(9205)), 200, "", accept, acceptedID)
call("DELETE", sourceGrantPath+"/"+accounts[2], tokens[0], nil, 204)
// The independently authorized target now owns a binding; source revocation
// must not revoke a resource still readable through that target.
call("GET", metadataPath, tokens[2], nil, 200)
download(tokens[2], 200)
call("DELETE", targetGrantPath+"/"+accounts[2], tokens[0], nil, 204)
call("GET", metadataPath, tokens[2], nil, 404)
download(tokens[2], 404)
download(tokens[1], 200) download(tokens[1], 200)
upload([]byte("not an image"), "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", 400) upload([]byte("not an image"), "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", 400)
// 超出节点预算要求确定拒绝且版本不变;UUID 幂等键大小写应归一到同一次操作。
limitBoard := call("POST", workspacePath+"/materials", tokens[0], response{"kind": "board", "title": "Limits", "content": response{}}, 201) limitBoard := call("POST", workspacePath+"/materials", tokens[0], response{"kind": "board", "title": "Limits", "content": response{}}, 201)
limitPath := workspacePath + "/materials/" + limitBoard["id"].(string) + "/canvas" limitPath := workspacePath + "/materials/" + limitBoard["id"].(string) + "/canvas"
oversizedNodes := []any{} oversizedNodes := []any{}
@@ -669,6 +811,7 @@ func TestOnboardingAndSharing(t *testing.T) {
code int code int
body []byte body []byte
} }
// 四条并发同键请求应收敛到同一 transaction 和一个子图,而不是各创建一次。
results := make(chan concurrentResult, 4) results := make(chan concurrentResult, 4)
startConcurrent := make(chan struct{}) startConcurrent := make(chan struct{})
encodedFrame, _ := json.Marshal(caseFrame) encodedFrame, _ := json.Marshal(caseFrame)
@@ -703,6 +846,7 @@ func TestOnboardingAndSharing(t *testing.T) {
if err := db.QueryRowContext(ctx, `SELECT count(*) FROM canvas_subgraphs WHERE project=$1 AND parent_board_id=$2`, project, concurrentBoard["id"]).Scan(&concurrentChildren); err != nil || concurrentChildren != 1 { if err := db.QueryRowContext(ctx, `SELECT count(*) FROM canvas_subgraphs WHERE project=$1 AND parent_board_id=$2`, project, concurrentBoard["id"]).Scan(&concurrentChildren); err != nil || concurrentChildren != 1 {
t.Fatalf("concurrent retry duplicated children: %d %v", concurrentChildren, err) t.Fatalf("concurrent retry duplicated children: %d %v", concurrentChildren, err)
} }
// 让父文档接近字节预算,使创建子图在最终父文档校验失败,验证孩子和父版本共同回滚。
rollbackBoard := call("POST", workspacePath+"/materials", tokens[0], response{"kind": "board", "title": "Rollback", "content": response{}}, 201) rollbackBoard := call("POST", workspacePath+"/materials", tokens[0], response{"kind": "board", "title": "Rollback", "content": response{}}, 201)
rollbackPath := workspacePath + "/materials/" + rollbackBoard["id"].(string) + "/canvas" rollbackPath := workspacePath + "/materials/" + rollbackBoard["id"].(string) + "/canvas"
nearLimit := []any{} nearLimit := []any{}
@@ -733,6 +877,7 @@ func TestOnboardingAndSharing(t *testing.T) {
t.Fatal("failed create changed parent version") t.Fatal("failed create changed parent version")
} }
// 最后用 outbox 内链接完成邮箱验证:未验证不能登录,验证码不可重放,注销后的会话不可访问资料。
email := "fixture@example.invalid" email := "fixture@example.invalid"
password := "a-long-fixture-password" password := "a-long-fixture-password"
call("POST", base+"/auth/register", "", response{"email": email, "password": password}, 202) call("POST", base+"/auth/register", "", response{"email": email, "password": password}, 202)
@@ -764,11 +909,13 @@ func TestOnboardingAndSharing(t *testing.T) {
// A real SQL NOWAIT probe at the response-write boundary catches locks that // A real SQL NOWAIT probe at the response-write boundary catches locks that
// would otherwise remain invisible in a buffered httptest recorder. // would otherwise remain invisible in a buffered httptest recorder.
// readLockProbe 在首个 Write 前执行外部锁探测;只运行一次以免多段响应反复探测。
type readLockProbe struct { type readLockProbe struct {
*httptest.ResponseRecorder *httptest.ResponseRecorder
probe func() probe func()
} }
// Write 先清空 probe 再调用,随后交给 recorder 保存实际响应体。
func (w *readLockProbe) Write(body []byte) (int, error) { func (w *readLockProbe) Write(body []byte) (int, error) {
if w.probe != nil { if w.probe != nil {
probe := w.probe probe := w.probe
+7
View File
@@ -1,3 +1,4 @@
// 旧 board_layouts 路由:布局变更与父素材版本递增同事务执行,canonical 画布由入口守卫限制旧写入。
package platform package platform
import ( import (
@@ -7,6 +8,7 @@ import (
"net/http" "net/http"
) )
// placement 是素材在旧画布内的矩形位置,MaterialID 指向工作区内可访问且非 board 的素材。
type placement struct { type placement struct {
MaterialID string `json:"material_id"` MaterialID string `json:"material_id"`
X float64 `json:"x"` X float64 `json:"x"`
@@ -16,12 +18,15 @@ type placement struct {
ZIndex int `json:"z_index"` ZIndex int `json:"z_index"`
} }
// valid 限制有限坐标、正尺寸和层级范围;NaN 显式拒绝,无穷值也会被范围判断拒绝。
func (p placement) valid() bool { func (p placement) valid() bool {
return !math.IsNaN(p.X) && !math.IsNaN(p.Y) && !math.IsNaN(p.Width) && !math.IsNaN(p.Height) && return !math.IsNaN(p.X) && !math.IsNaN(p.Y) && !math.IsNaN(p.Width) && !math.IsNaN(p.Height) &&
p.X >= -1000000 && p.X <= 1000000 && p.Y >= -1000000 && p.Y <= 1000000 && p.X >= -1000000 && p.X <= 1000000 && p.Y >= -1000000 && p.Y <= 1000000 &&
p.Width >= 1 && p.Width <= 100000 && p.Height >= 1 && p.Height <= 100000 && p.Width >= 1 && p.Width <= 100000 && p.Height >= 1 && p.Height <= 100000 &&
p.ZIndex >= -1000000 && p.ZIndex <= 1000000 p.ZIndex >= -1000000 && p.ZIndex <= 1000000
} }
// layouts 对集合提供 GET/POST,对单条提供 PATCH/DELETE;所有写入都比较父画布 If-Match。
func (s *service) layouts(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) layouts(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet && r.Method != http.MethodPost && r.Method != http.MethodPatch && r.Method != http.MethodDelete { if r.Method != http.MethodGet && r.Method != http.MethodPost && r.Method != http.MethodPatch && r.Method != http.MethodDelete {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -84,6 +89,7 @@ ORDER BY l.z_index,l.id LIMIT 2000
if !ok { if !ok {
return nil return nil
} }
// 工作区锁保护当前事务内版本检查与写入;不匹配立即返回 412,不进入布局变更。
if expected != version { if expected != version {
reject(w, 412, "version_conflict") reject(w, 412, "version_conflict")
return nil return nil
@@ -141,6 +147,7 @@ WHERE project=$1 AND workspace_id=$2 AND board_id=$3 AND id=$4
return sql.ErrNoRows return sql.ErrNoRows
} }
} }
// 即使只移动或删除一条布局,也递增父素材版本,供其他客户端发现画布变更。
_, err = tx.ExecContext(r.Context(), "UPDATE materials SET version=version+1,modified_at=now() WHERE project=$1 AND workspace_id=$2 AND id=$3", project, workspace, board) _, err = tx.ExecContext(r.Context(), "UPDATE materials SET version=version+1,modified_at=now() WHERE project=$1 AND workspace_id=$2 AND id=$3", project, workspace, board)
if err != nil { if err != nil {
return err return err
+13
View File
@@ -1,3 +1,4 @@
// 素材 CRUD、根画布授权继承与乐观版本控制;画布专用结构由其他文件处理。
package platform package platform
import ( import (
@@ -8,6 +9,8 @@ import (
"strconv" "strconv"
) )
// lockMaterial 先锁工作区,再向上遍历最多八层子图祖先获取根素材授权,返回目标类型与有效角色。
// 任一祖先关系归档则不可访问;子素材单独授权不能绕过父级。事务由调用方持有。
func lockMaterial(ctx context.Context, tx *sql.Tx, project, workspace, material, account string) (string, string, error) { func lockMaterial(ctx context.Context, tx *sql.Tx, project, workspace, material, account string) (string, string, error) {
var locked, kind, role string var locked, kind, role string
err := tx.QueryRowContext(ctx, "SELECT id::text FROM workspaces WHERE project=$1 AND id=$2 FOR UPDATE", project, workspace).Scan(&locked) err := tx.QueryRowContext(ctx, "SELECT id::text FROM workspaces WHERE project=$1 AND id=$2 FOR UPDATE", project, workspace).Scan(&locked)
@@ -36,6 +39,7 @@ func lockMaterial(ctx context.Context, tx *sql.Tx, project, workspace, material,
return kind, role, err return kind, role, err
} }
// expectedVersion 解析带双引号的正整数 If-Match;缺少返回 428,格式错误返回 400。
func expectedVersion(w http.ResponseWriter, r *http.Request) (int64, bool) { func expectedVersion(w http.ResponseWriter, r *http.Request) (int64, bool) {
header := r.Header.Get("If-Match") header := r.Header.Get("If-Match")
if header == "" { if header == "" {
@@ -53,10 +57,13 @@ func expectedVersion(w http.ResponseWriter, r *http.Request) (int64, bool) {
} }
return version, true return version, true
} }
// setVersion 将素材版本写成带引号 ETag,与 expectedVersion 的输入格式对应。
func setVersion(w http.ResponseWriter, version int64) { func setVersion(w http.ResponseWriter, version int64) {
w.Header().Set("ETag", strconv.Quote(strconv.FormatInt(version, 10))) w.Header().Set("ETag", strconv.Quote(strconv.FormatInt(version, 10)))
} }
// materials 的 GET 转入筛选列表,POST 要求工作区编辑权限并按种类验证内容后创建版本一。
func (s *service) materials(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) materials(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method == http.MethodGet { if r.Method == http.MethodGet {
return s.listMaterials(w, r, project, account) return s.listMaterials(w, r, project, account)
@@ -110,6 +117,7 @@ VALUES($1,$2,$3,$4,$5,$6,$7,$8) RETURNING id::text,slug
return nil return nil
} }
// material 先校验根级权限;读取返回完整内容与 ETag,修改/删除同时要求角色和预期版本。
func (s *service) material(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) material(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodGet && r.Method != http.MethodPatch && r.Method != http.MethodDelete { if r.Method != http.MethodGet && r.Method != http.MethodPatch && r.Method != http.MethodDelete {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -182,6 +190,7 @@ WHERE project=$1 AND workspace_id=$2 AND id=$3 AND version=$7
if err != nil { if err != nil {
return err return err
} }
// 已通过可见性检查但版本条件未命中,视为并发冲突;事务回滚,不能覆盖其他客户端更新。
if n == 0 { if n == 0 {
reject(w, 412, "version_conflict") reject(w, 412, "version_conflict")
return nil return nil
@@ -196,6 +205,7 @@ WHERE project=$1 AND workspace_id=$2 AND id=$3 AND version=$7
return nil return nil
} }
// openMaterial 记录当前账户最近打开时间,重复打开更新同一记录,不修改素材内容版本。
func (s *service) openMaterial(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) openMaterial(w http.ResponseWriter, r *http.Request, project, account string) error {
if r.Method != http.MethodPost { if r.Method != http.MethodPost {
reject(w, 405, "method_not_allowed") reject(w, 405, "method_not_allowed")
@@ -224,6 +234,7 @@ ON CONFLICT(project,workspace_id,material_id,account_id) DO UPDATE SET opened_at
return nil return nil
} }
// listMaterials 按授权与筛选返回元数据,默认隐藏子图;排序片段只从固定白名单选择。
func (s *service) listMaterials(w http.ResponseWriter, r *http.Request, project, account string) error { func (s *service) listMaterials(w http.ResponseWriter, r *http.Request, project, account string) error {
sort := r.URL.Query().Get("sort") sort := r.URL.Query().Get("sort")
orders := map[string]string{ orders := map[string]string{
@@ -267,6 +278,7 @@ func (s *service) listMaterials(w http.ResponseWriter, r *http.Request, project,
reject(w, 400, "invalid_filter") reject(w, 400, "invalid_filter")
return nil return nil
} }
// 子图默认通过父画布进入;显式请求后仍需根级权限且整条祖先链未归档。
includeSubgraphs := false includeSubgraphs := false
if value := r.URL.Query().Get("include_subgraphs"); value != "" { if value := r.URL.Query().Get("include_subgraphs"); value != "" {
if value != "true" && value != "false" { if value != "true" && value != "false" {
@@ -314,6 +326,7 @@ ORDER BY `+order+` LIMIT $7 OFFSET $8`, project, r.PathValue("workspace"), accou
if err := rows.Err(); err != nil { if err := rows.Err(); err != nil {
return err return err
} }
// SQL 多取一条探测后页;响应截回 limit,并给出下一次应使用的 offset。
var next *int var next *int
if len(items) > limit { if len(items) > limit {
items = items[:limit] items = items[:limit]
+78
View File
@@ -0,0 +1,78 @@
// 子图成员拖放可附带来源画布局部坐标;此处只更新来源文档,目标坐标转换由所有权事务完成。
package platform
import (
"encoding/json"
"fmt"
"math"
)
// Positions are expressed in the source board's local coordinates. The existing
// ownership transaction converts them into destination coordinates exactly once.
// memberDropPosition 必须显式携带 x/y,避免遗漏字段被当作零而让节点意外跳位。
type memberDropPosition struct {
X float64 `json:"x"`
Y float64 `json:"y"`
}
// validMemberDropPositions 兼容缺省坐标的旧客户端;提供时必须与成员 ID 集合完全一致且坐标有限。
func validMemberDropPositions(ids []string, positions map[string]memberDropPosition) bool {
if positions == nil {
return true
} // Backward-compatible old clients.
if len(positions) != len(ids) {
return false
}
seen := map[string]bool{}
for _, id := range ids {
p, ok := positions[id]
if !ok || seen[id] || math.IsNaN(p.X) || math.IsNaN(p.Y) || math.IsInf(p.X, 0) || math.IsInf(p.Y, 0) || math.Abs(p.X) > 1e6 || math.Abs(p.Y) > 1e6 {
return false
}
seen[id] = true
}
return true
}
// positionMemberDrop 在 JSON 节点数组中替换所有指定位置,缺节点或非法文档返回所有权错误。
func positionMemberDrop(raw json.RawMessage, positions map[string]memberDropPosition) (json.RawMessage, error) {
var doc map[string]any
if err := json.Unmarshal(raw, &doc); err != nil {
return nil, err
}
found := 0
nodes, ok := doc["nodes"].([]any)
if !ok {
return nil, errGraphOwnership
}
for _, v := range nodes {
n, ok := v.(map[string]any)
if !ok {
return nil, errGraphOwnership
}
id, _ := n["id"].(string)
if p, ok := positions[id]; ok {
n["position"] = map[string]any{"x": p.X, "y": p.Y}
found++
}
}
if found != len(positions) {
return nil, errGraphOwnership
}
return json.Marshal(doc)
}
// UnmarshalJSON 只接受两个非 null 数值字段;范围与有限性由 validMemberDropPositions 继续检查。
func (p *memberDropPosition) UnmarshalJSON(raw []byte) error {
var fields map[string]json.RawMessage
if err := json.Unmarshal(raw, &fields); err != nil {
return err
}
if len(fields) != 2 || fields["x"] == nil || fields["y"] == nil || string(fields["x"]) == "null" || string(fields["y"]) == "null" {
return fmt.Errorf("invalid member position")
}
if err := json.Unmarshal(fields["x"], &p.X); err != nil {
return err
}
return json.Unmarshal(fields["y"], &p.Y)
}

Some files were not shown because too many files have changed in this diff Show More