cover_url、urdf_main_object_key、urdf_prefix只存相对路径,不包含域名+环境根目录

This commit is contained in:
lxp
2026-10-19 14:53:06 +08:00
parent 8a3ecabdc0
commit f8f2e95dbe
34 changed files with 1700 additions and 58 deletions
@@ -27,6 +27,7 @@ community:
access-key-id: ${OSS_ACCESS_KEY_ID:}
access-key-secret: ${OSS_ACCESS_KEY_SECRET:}
public-base-url: ${OSS_PUBLIC_BASE_URL:https://linkerbot.oss-cn-beijing.aliyuncs.com}
legacy-public-base-urls: ${OSS_LEGACY_PUBLIC_BASE_URLS:}
urdf:
max-file-bytes: ${URDF_MAX_FILE_BYTES:52428800}
max-total-bytes: ${URDF_MAX_TOTAL_BYTES:209715200}
@@ -21,6 +21,7 @@ import com.linkerbot.community.service.ProjectService;
import com.linkerbot.community.service.ai.AiModelClient;
import com.linkerbot.community.service.ai.AiProjectAssistant;
import com.linkerbot.community.service.config.AiProperties;
import com.linkerbot.community.service.config.OssProperties;
import com.linkerbot.community.service.config.ForkProperties;
import com.linkerbot.community.service.gitea.GiteaClient.Change;
import com.linkerbot.community.service.mapper.ProjectMapper;
@@ -91,6 +92,7 @@ class AiSearchTest {
@Autowired AiProjectAssistant assistant;
@Autowired FakeGitSnapshotCopier snapshots;
@Autowired ForkProperties forkProperties;
@Autowired OssProperties oss;
private User user;
private String token;
@@ -462,6 +464,9 @@ class AiSearchTest {
@Test void forksExplicitCodeWithCustomNameAndCopiesPublishedSnapshot() throws Exception {
Project source = publishedRepository("轮式教学");
String cover = "/project-covers/111111111111/20261019/a.png";
source.setCoverUrl(cover);
projects.updateById(source);
model.handler = (name, input) -> forkIntent(source.getProjectCode(), "我的学习副本");
List<JsonNode> events = finish(start(Map.of("message", "Fork " + source.getProjectCode() + ",命名为我的学习副本")));
JsonNode data = events.getLast().path("data");
@@ -474,6 +479,8 @@ class AiSearchTest {
assertThat(fork.path("publishStatus").asText()).isEqualTo("UNPUBLISHED");
assertThat(fork.has("id")).isFalse();
Project copied = projectService.owner(user.getId(), fork.path("projectCode").asText());
assertThat(copied.getCoverUrl()).isEqualTo(cover);
assertThat(fork.path("coverUrl").asText()).isEqualTo(oss.publicBaseUrl() + "/" + oss.getRootDirectory() + cover);
assertThat(gitea.file(projectService.repository(copied), gitea.head(projectService.repository(copied)), "README.md").bytes())
.isEqualTo(gitea.file(projectService.repository(source), source.getPublishedCommitSha(), "README.md").bytes());
assertThat(projects.selectCount(null)).isEqualTo(2L);
@@ -483,6 +490,23 @@ class AiSearchTest {
.containsExactly("understanding", "forking");
}
@Test void createsHostedCoverAndSearchReturnsPublicUrlForStoredPath() throws Exception {
String cover = "/project-covers/111111111111/20261019/a.png";
String fullUrl = oss.publicBaseUrl() + "/" + oss.getRootDirectory() + cover;
model.handler = (name, input) -> createIntent("WHEELED", "路径测试机器人").put("coverUrl", fullUrl);
JsonNode created = finish(start(Map.of("message", "创建路径测试机器人,使用给定封面")))
.getLast().path("data").path("project");
assertThat(created.path("coverUrl").asText()).isEqualTo(fullUrl);
Project project = projectService.owner(user.getId(), created.path("projectCode").asText());
assertThat(project.getCoverUrl()).isEqualTo(cover);
projectService.publish(user.getId(), project.getProjectCode(), gitea.head(projectService.repository(project)));
model.handler = (name, input) -> name.endsWith("intent") ? intent("WHEELED", List.of("路径测试")) : rank(input);
JsonNode card = finish(start(Map.of("message", "寻找路径测试机器人")))
.getLast().path("data").path("projects").get(0).path("project");
assertThat(card.path("coverUrl").asText()).isEqualTo(fullUrl);
assertThat(projectService.owner(user.getId(), project.getProjectCode()).getCoverUrl()).isEqualTo(cover);
}
@Test void forkGetsItsOwnDeadlineAfterUnderstandingRatherThanTheSearchTimeout() throws Exception {
Project source = publishedRepository("教学项目");
properties.setSearchTimeout(Duration.ofMillis(150));
@@ -0,0 +1,150 @@
package com.linkerbot.community.api;
import static org.assertj.core.api.Assertions.*;
import com.linkerbot.community.service.config.OssProperties;
import com.linkerbot.community.service.oss.OssResourcePaths;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.SingleConnectionDataSource;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
/** 执行数据库文档中的 SQL;仅将 MySQL JOIN UPDATE、排序规则和正则语法适配到 H2。 */
class ResourcePathMigrationTest {
private static final String ROOT = "vibemake_dev";
private static final String BASE = "https://linkerbot.oss-cn-beijing.aliyuncs.com";
private static final String CODE = "1".repeat(12);
private static final String COVER = "/project-covers/" + "1".repeat(32) + "/20261019/" + "a".repeat(32) + ".png";
private static final String PREFIX = "/urdf/" + CODE + "/" + "a".repeat(32) + "/";
private static final String MAIN = PREFIX + "urdf/机械 臂 #?%+.URDF";
private SingleConnectionDataSource source;
private JdbcTemplate jdbc;
private String document;
private OssResourcePaths paths;
@BeforeEach
void prepare() throws Exception {
source = new SingleConnectionDataSource("jdbc:h2:mem:migration;MODE=MySQL", "sa", "", true);
jdbc = new JdbcTemplate(source);
jdbc.execute("CREATE TABLE project (project_code VARCHAR(32) PRIMARY KEY, cover_url VARCHAR(2048),"
+ " urdf_main_object_key VARCHAR(512) NOT NULL, urdf_prefix VARCHAR(512) NOT NULL)");
document = Files.readString(Path.of("../docs/database.md"));
OssProperties oss = new OssProperties();
oss.setRootDirectory(ROOT);
oss.setPublicBaseUrl(BASE);
paths = new OssResourcePaths(oss);
}
@AfterEach
void close() {
source.destroy();
}
@Test
void migrationIsIdempotentAndPreservesExternalUrlsAndObjectLocations() {
insert(CODE, BASE + "/" + ROOT + COVER, ROOT + MAIN, ROOT + PREFIX);
insert("2".repeat(12), "https://external.example.com" + COVER, "", "");
insert("3".repeat(12), BASE + "/" + ROOT + COVER + "?version=2", "", "");
insert("4".repeat(12), BASE + "/" + ROOT + COVER + "#preview", "", "");
insert("5".repeat(12), COVER, "/urdf/already/a.urdf", "/urdf/already/");
insert("6".repeat(12), BASE + "/vibemake" + COVER, "vibemake" + MAIN, "vibemake" + PREFIX);
insert("7".repeat(12), null, ROOT + "/urdf/wrong/a.urdf", ROOT + PREFIX);
insert("8".repeat(12), BASE + ".evil/" + ROOT + COVER, "", "");
insert("9".repeat(12), BASE + "/VIBEMAKE_DEV" + COVER, "", "");
Map<String, Object> externalBefore = row("2".repeat(12));
String publicCover = paths.coverUrl(row(CODE).get("COVER_URL").toString());
String publicMain = paths.publicUrl(ROOT + MAIN);
execute("migration-prepare");
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM resource_path_changes", Integer.class)).isEqualTo(1);
execute("migration-apply");
assertThat(row(CODE)).containsEntry("COVER_URL", COVER)
.containsEntry("URDF_MAIN_OBJECT_KEY", MAIN).containsEntry("URDF_PREFIX", PREFIX);
assertThat(paths.coverUrl(row(CODE).get("COVER_URL").toString())).isEqualTo(publicCover);
assertThat(paths.publicUrl(row(CODE).get("URDF_MAIN_OBJECT_KEY").toString())).isEqualTo(publicMain);
assertThat(row("2".repeat(12))).isEqualTo(externalBefore);
assertThat(row("3".repeat(12)).get("COVER_URL")).asString().endsWith("?version=2");
assertThat(row("4".repeat(12)).get("COVER_URL")).asString().endsWith("#preview");
assertThat(row("6".repeat(12)).get("URDF_PREFIX")).isEqualTo("vibemake" + PREFIX);
assertThat(row("7".repeat(12)).get("URDF_PREFIX")).isEqualTo(ROOT + PREFIX);
assertThat(row("8".repeat(12)).get("COVER_URL")).asString().contains(".evil/");
assertThat(row("9".repeat(12)).get("COVER_URL")).asString().contains("/VIBEMAKE_DEV/");
execute("migration-prepare");
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM resource_path_changes", Integer.class)).isZero();
execute("migration-apply");
assertThat(row(CODE).get("COVER_URL")).isEqualTo(COVER);
}
@Test
void concurrentChangesAreNotOverwrittenAndNewPathsCanBeRolledBack() {
insert(CODE, BASE + "/" + ROOT + COVER, ROOT + MAIN, ROOT + PREFIX);
execute("migration-prepare");
jdbc.update("UPDATE project SET cover_url = ? WHERE project_code = ?", "https://external.example.com/new.png", CODE);
execute("migration-apply");
assertThat(row(CODE)).containsEntry("COVER_URL", "https://external.example.com/new.png")
.containsEntry("URDF_MAIN_OBJECT_KEY", ROOT + MAIN);
jdbc.update("UPDATE project SET cover_url = ? WHERE project_code = ?", BASE + "/" + ROOT + COVER, CODE);
execute("migration-prepare");
execute("migration-apply");
execute("rollback-prepare");
jdbc.update("INSERT INTO resource_cover_rollback VALUES (?, ?, ?)", CODE, COVER, paths.coverUrl(COVER));
execute("rollback-apply");
assertThat(row(CODE)).containsEntry("COVER_URL", BASE + "/" + ROOT + COVER)
.containsEntry("URDF_MAIN_OBJECT_KEY", ROOT + MAIN).containsEntry("URDF_PREFIX", ROOT + PREFIX);
execute("rollback-apply");
assertThat(row(CODE).get("URDF_PREFIX")).isEqualTo(ROOT + PREFIX);
}
private void insert(String code, String cover, String main, String prefix) {
jdbc.update("INSERT INTO project VALUES (?, ?, ?, ?)", code, cover, main, prefix);
}
@Test
void urdfResumeCommitsEarlierCoverChangeWithoutStartingAnotherTransaction() throws Exception {
insert(CODE, BASE + "/" + ROOT + COVER, ROOT + MAIN, ROOT + PREFIX);
source.getConnection().setAutoCommit(false);
jdbc.update("UPDATE project SET cover_url = ? WHERE project_code = ?", COVER, CODE);
execute("migration-resume-urdf");
JdbcTemplate observer = new JdbcTemplate(
new DriverManagerDataSource("jdbc:h2:mem:migration;MODE=MySQL", "sa", ""));
assertThat(observer.queryForMap("SELECT * FROM project WHERE project_code = ?", CODE))
.containsEntry("COVER_URL", COVER).containsEntry("URDF_MAIN_OBJECT_KEY", MAIN)
.containsEntry("URDF_PREFIX", PREFIX);
execute("migration-resume-urdf");
assertThat(row(CODE).get("URDF_PREFIX")).isEqualTo(PREFIX);
}
private Map<String, Object> row(String code) {
return jdbc.queryForMap("SELECT * FROM project WHERE project_code = ?", code);
}
private void execute(String name) {
Matcher block = Pattern.compile("```sql\\s*-- resource-path-" + name + "\\s+([\\s\\S]*?)```").matcher(document);
assertThat(block.find()).as("文档 SQL 块 %s", name).isTrue();
String sql = block.group(1).replaceAll("(?m)^--.*$", "")
.replace(" COLLATE utf8mb4_bin", "")
.replace(" CHARACTER SET utf8mb4", "")
.replace("DROP TEMPORARY TABLE", "DROP TABLE")
.replace("START TRANSACTION", "SET AUTOCOMMIT FALSE")
.replace("SET NAMES utf8mb4", "")
.replace("<=>", "IS NOT DISTINCT FROM")
.replace("[[:cntrl:]:]", "[\\p{Cntrl}:]");
for (String statement : sql.split(";")) {
if (statement.isBlank()) continue;
Matcher update = Pattern.compile("UPDATE project p JOIN (\\w+) c ON c.project_code = p.project_code\\s+SET ([\\s\\S]*?)\\s+WHERE ([\\s\\S]*)")
.matcher(statement.trim());
if (update.matches()) {
statement = "MERGE INTO project p USING " + update.group(1)
+ " c ON c.project_code = p.project_code WHEN MATCHED AND " + update.group(3)
+ " THEN UPDATE SET " + update.group(2).replace("p.", "");
}
jdbc.execute(statement);
}
}
}
@@ -14,6 +14,8 @@ import com.linkerbot.community.service.config.UrdfProperties;
import com.linkerbot.community.common.BusinessException;
import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.autoconfigure.web.servlet.MockMvcPrint;
@@ -84,6 +86,7 @@ class WorkflowTest {
snapshots.available = true;
snapshots.beforePush = null;
oss.setEnabled(false);
oss.setLegacyPublicBaseUrls(List.of());
ossObjects.reset();
urdfLimits.setMaxFileBytes(52428800);
urdfLimits.setMaxTotalBytes(209715200);
@@ -358,6 +361,41 @@ class WorkflowTest {
.path("data").path("coverUrl").asText()).isEqualTo(max);
}
@ParameterizedTest
@ValueSource(booleans = {false, true})
void hostedCoversStoreRelativePathsAndLegacyUrlsRemainUsableByFork(boolean legacy) throws Exception {
enableUrdfOss();
String owner = login("hosted-cover-owner@example.com");
String other = login("hosted-cover-other@example.com");
String stored = "/project-covers/111111111111/20261019/a.png";
String uploaded = oss.uploadUrl() + "/vibemake_dev" + stored;
String expected = "https://images.example.com/assets/vibemake_dev" + stored;
Map<String, Object> input = new LinkedHashMap<>(Map.of(
"name", "平台封面", "projectType", "GENERAL", "coverUrl", uploaded));
JsonNode created = perform(body(auth(post("/api/workspace/projects"), owner), input), 200).path("data");
String code = created.path("projectCode").asText();
String endpoint = "/api/workspace/projects/" + code;
assertThat(created.path("coverUrl").asText()).isEqualTo(expected);
assertThat(jdbc.queryForObject("SELECT cover_url FROM project WHERE project_code = ?", String.class, code)).isEqualTo(stored);
if (legacy) jdbc.update("UPDATE project SET cover_url = ? WHERE project_code = ?", uploaded, code);
assertThat(perform(auth(get(endpoint), owner), 200).path("data").path("coverUrl").asText()).isEqualTo(expected);
assertThat(jdbc.queryForObject("SELECT cover_url FROM project WHERE project_code = ?", String.class, code))
.isEqualTo(legacy ? uploaded : stored); // 读取不会隐式迁移。
String sha = head(owner, code);
publish(owner, code, sha);
JsonNode fork = perform(body(auth(post("/api/community/projects/" + code + "/forks"), other),
Map.of("name", "封面副本", "publishedCommitSha", sha)), 200).path("data");
assertThat(fork.path("coverUrl").asText()).isEqualTo(expected);
assertThat(jdbc.queryForObject("SELECT cover_url FROM project WHERE project_code = ?", String.class,
fork.path("projectCode").asText())).isEqualTo(stored);
input.put("coverUrl", expected);
perform(body(auth(patch(endpoint), owner), input), 200);
assertThat(jdbc.queryForObject("SELECT cover_url FROM project WHERE project_code = ?", String.class, code)).isEqualTo(stored);
oss.setPublicBaseUrl("https://new-cdn.example.com/base");
assertThat(perform(get("/api/community/projects/" + code), 200).path("data").path("coverUrl").asText())
.isEqualTo("https://new-cdn.example.com/base/vibemake_dev" + stored);
}
private void enableUrdfOss() {
oss.setRegion("cn-hangzhou");
oss.setEndpoint("");
@@ -463,7 +501,9 @@ class WorkflowTest {
assertThat(bound.path("urdfMainUrl").asText()).isEqualTo(baseUrl + "urdf/%E6%9C%BA%E6%A2%B0%20%E8%87%82.URDF");
assertThat(bound.has("id")).isFalse();
assertThat(jdbc.queryForObject("SELECT urdf_main_object_key FROM project WHERE project_code = ?", String.class, code))
.isEqualTo(expectedPrefix + "urdf/机械 臂.URDF");
.isEqualTo(expectedPrefix.substring("vibemake_dev".length()) + "urdf/机械 臂.URDF");
assertThat(jdbc.queryForObject("SELECT urdf_prefix FROM project WHERE project_code = ?", String.class, code))
.isEqualTo(expectedPrefix.substring("vibemake_dev".length()));
assertThat(json.readTree(jdbc.queryForObject("SELECT urdf_files FROM project WHERE project_code = ?", String.class, code)))
.isEqualTo(json.valueToTree(files));
assertThat(perform(get("/api/community/projects/" + code), 200).path("data").path("urdfMainUrl")).isEqualTo(bound.path("urdfMainUrl"));
@@ -510,8 +550,9 @@ class WorkflowTest {
.contains(first.path("batchCode").asText());
}
@Test
void urdfForkCopiesIndependentObjectsAndCopyFailureDoesNotReturnReady() throws Exception {
@ParameterizedTest
@ValueSource(booleans = {false, true})
void urdfForkCopiesIndependentObjectsAndCopyFailureDoesNotReturnReady(boolean legacy) throws Exception {
String owner = login("urdf-fork-source@example.com");
String other = login("urdf-fork-target@example.com");
String code = create(owner, "URDF 来源");
@@ -519,6 +560,8 @@ class WorkflowTest {
List<Map<String, Object>> files = urdfFiles();
JsonNode uploaded = uploadUrdf(owner, code, files);
JsonNode source = confirmUrdf(owner, code, uploaded, files, 200).path("data");
if (legacy) jdbc.update("UPDATE project SET urdf_prefix = CONCAT('vibemake_dev', urdf_prefix),"
+ " urdf_main_object_key = CONCAT('vibemake_dev', urdf_main_object_key) WHERE project_code = ?", code);
String sha = head(owner, code);
publish(owner, code, sha);
String forkEndpoint = "/api/community/projects/" + code + "/forks";
@@ -528,8 +571,9 @@ class WorkflowTest {
assertThat(fork.path("repoStatus").asText()).isEqualTo("READY");
assertThat(fork.path("urdfMainUrl").asText()).contains("/urdf/" + targetCode + "/").doesNotContain("/urdf/" + code + "/");
String targetPrefix = jdbc.queryForObject("SELECT urdf_prefix FROM project WHERE project_code = ?", String.class, targetCode);
assertThat(targetPrefix).startsWith("/urdf/" + targetCode + "/");
for (int index = 0; index < files.size(); index++)
assertThat(ossObjects.objects.get(targetPrefix + files.get(index).get("relativePath")))
assertThat(ossObjects.objects.get("vibemake_dev" + targetPrefix + files.get(index).get("relativePath")))
.containsExactly(ossObjects.objects.get(uploaded.path("files").get(index).path("objectKey").asText()));
confirmUrdf(owner, code, uploadUrdf(owner, code, files), files, 200);
perform(auth(delete("/api/workspace/projects/" + code + "/urdf"), owner), 200);